1 /* 2 * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_GC_G1_G1COLLECTIONSET_HPP 26 #define SHARE_GC_G1_G1COLLECTIONSET_HPP 27 28 #include "utilities/debug.hpp" 29 #include "utilities/globalDefinitions.hpp" 30 31 class G1CollectedHeap; 32 class G1CollectionSetCandidates; 33 class G1CollectorState; 34 class G1GCPhaseTimes; 35 class G1ParScanThreadStateSet; 36 class G1Policy; 37 class G1SurvivorRegions; 38 class HeapRegion; 39 class HeapRegionClosure; 40 41 // The collection set. 42 // 43 // The collection set is built incrementally: it starts off with the set of 44 // survivor regions, and at mutator time G1 adds retired up eden regions to it. 45 // 46 // For non-mixed collections this is all the collection set consists of and its 47 // regions are evacuated in one pass. 48 // 49 // For mixed collections we not only determine a few old gen regions for an initial 50 // collection set, but also a set of optional collection set regions from the 51 // collection set candidates. 52 // 53 // After evacuating the initial collection set, G1 incrementally selects more 54 // regions from the optional collection set regions as time prediction permit. 55 // 56 // Support for incremental building is implemented by keeping an index into the 57 // collection set set; during evacuation only the part from that index to the 58 // end is used for evacuation. 59 // 60 // This results in having a single complete collection set of the evacuation phases 61 // for cleaning up. 62 class G1CollectionSet { 63 G1CollectedHeap* _g1h; 64 G1Policy* _policy; 65 66 // All old gen collection set candidate regions for the current mixed phase. 67 G1CollectionSetCandidates* _candidates; 68 69 uint _eden_region_length; 70 uint _survivor_region_length; 71 uint _old_region_length; 72 73 // The actual collection set as a set of region indices. 74 // All entries in _collection_set_regions below _collection_set_cur_length are 75 // assumed to be part of the collection set. 76 // We assume that at any time there is at most only one writer and (one or more) 77 // concurrent readers. This means we are good with using storestore and loadload 78 // barriers on the writer and reader respectively only. 79 uint* _collection_set_regions; 80 volatile size_t _collection_set_cur_length; 81 size_t _collection_set_max_length; 82 83 // When doing mixed collections we can add old regions to the collection set, which 84 // will be collected only if there is enough time. We call these optional regions. 85 // This member records the current number of regions that are of that type that 86 // correspond to the first x entries in the collection set candidates. 87 uint _num_optional_regions; 88 89 // The number of bytes in the collection set before the pause. Set from 90 // the incrementally built collection set at the start of an evacuation 91 // pause, and updated as more regions are added to the collection set. 92 size_t _bytes_used_before; 93 94 // The number of cards in the remembered set in the collection set. Set from 95 // the incrementally built collection set at the start of an evacuation 96 // pause, and updated as more regions are added to the collection set. 97 size_t _recorded_rs_lengths; 98 99 enum CSetBuildType { 100 Active, // We are actively building the collection set 101 Inactive // We are not actively building the collection set 102 }; 103 104 CSetBuildType _inc_build_state; 105 size_t _inc_part_start; 106 107 // The associated information that is maintained while the incremental 108 // collection set is being built with *young* regions. Used to populate 109 // the recorded info for the evacuation pause. 110 111 // The number of bytes in the incrementally built collection set. 112 // Used to set _collection_set_bytes_used_before at the start of 113 // an evacuation pause. 114 size_t _inc_bytes_used_before; 115 116 // The RSet lengths recorded for regions in the CSet. It is updated 117 // by the thread that adds a new region to the CSet. We assume that 118 // only one thread can be allocating a new CSet region (currently, 119 // it does so after taking the Heap_lock) hence no need to 120 // synchronize updates to this field. 121 size_t _inc_recorded_rs_lengths; 122 123 // A concurrent refinement thread periodically samples the young 124 // region RSets and needs to update _inc_recorded_rs_lengths as 125 // the RSets grow. Instead of having to synchronize updates to that 126 // field we accumulate them in this field and add it to 127 // _inc_recorded_rs_lengths_diffs at the start of a GC. 128 ssize_t _inc_recorded_rs_lengths_diffs; 129 130 // The predicted elapsed time it will take to collect the regions in 131 // the CSet. This is updated by the thread that adds a new region to 132 // the CSet. See the comment for _inc_recorded_rs_lengths about 133 // MT-safety assumptions. 134 double _inc_predicted_elapsed_time_ms; 135 136 // See the comment for _inc_recorded_rs_lengths_diffs. 137 double _inc_predicted_elapsed_time_ms_diffs; 138 139 G1CollectorState* collector_state(); 140 G1GCPhaseTimes* phase_times(); 141 142 void verify_young_cset_indices() const NOT_DEBUG_RETURN; 143 144 double predict_region_elapsed_time_ms(HeapRegion* hr); 145 146 // Update the incremental collection set information when adding a region. 147 void add_young_region_common(HeapRegion* hr); 148 149 // Add old region "hr" to the collection set. 150 void add_old_region(HeapRegion* hr); 151 152 // Add old region "hr" to optional collection set. 153 void add_optional_region(HeapRegion* hr); 154 155 void move_candidates_to_collection_set(uint num_regions); 156 157 // Choose a new collection set. Marks the chosen regions as being 158 // "in_collection_set". 159 double finalize_young_part(double target_pause_time_ms, G1SurvivorRegions* survivors); 160 // Perform any final calculations on the incremental collection set fields 161 // before we can use them. 162 void finalize_young_increment(); 163 164 void finalize_old_part(double time_remaining_ms); 165 public: 166 G1CollectionSet(G1CollectedHeap* g1h, G1Policy* policy); 167 ~G1CollectionSet(); 168 169 // Initializes the collection set giving the maximum possible length of the collection set. 170 void initialize(uint max_region_length); 171 void initialize_optional(uint max_length); 172 void free_optional_regions(); 173 174 void clear_candidates(); 175 176 void set_candidates(G1CollectionSetCandidates* candidates) { 177 assert(_candidates == NULL, "Trying to replace collection set candidates."); 178 _candidates = candidates; 179 } 180 G1CollectionSetCandidates* candidates() { return _candidates; } 181 182 void init_region_lengths(uint eden_cset_region_length, 183 uint survivor_cset_region_length); 184 185 void set_recorded_rs_lengths(size_t rs_lengths); 186 187 uint region_length() const { return young_region_length() + 188 old_region_length(); } 189 uint young_region_length() const { return eden_region_length() + 190 survivor_region_length(); } 191 192 uint eden_region_length() const { return _eden_region_length; } 193 uint survivor_region_length() const { return _survivor_region_length; } 194 uint old_region_length() const { return _old_region_length; } 195 uint optional_region_length() const { return _num_optional_regions; } 196 197 // Reset the contents of the collection set. 198 void clear(); 199 200 // Incremental collection set support 201 202 // Initialize incremental collection set info. 203 void start_incremental_building(); 204 // Start a new collection set increment. 205 void update_incremental_marker() { _inc_build_state = Active; _inc_part_start = _collection_set_cur_length; } 206 // Stop adding regions to the current collection set increment. 207 void stop_incremental_building() { _inc_build_state = Inactive; } 208 209 // Iterate over the current collection set increment applying the given HeapRegionClosure 210 // from a starting position determined by the given worker id. 211 void iterate_incremental_part_from(HeapRegionClosure* cl, uint worker_id, uint total_workers) const; 212 213 // Iterate over the entire collection set (all increments calculated so far), applying 214 // the given HeapRegionClosure on all of them. 215 void iterate(HeapRegionClosure* cl) const; 216 217 void iterate_optional(HeapRegionClosure* cl) const; 218 219 size_t recorded_rs_lengths() { return _recorded_rs_lengths; } 220 221 size_t bytes_used_before() const { 222 return _bytes_used_before; 223 } 224 225 void reset_bytes_used_before() { 226 _bytes_used_before = 0; 227 } 228 229 // Finalize the initial (first) collection set consisting of all young regions and a 230 // few old gen regions. 231 void finalize_initial_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor); 232 // Finalize the next collection set from the set of available optional old gen regions. 233 bool finalize_optional_for_evacuation(double remaining_pause_time); 234 // Abandon (clean up) optional collection set regions that were not evacuated in this 235 // pause. 236 void abandon_optional_collection_set(G1ParScanThreadStateSet* pss); 237 238 // Update information about hr in the aggregated information for 239 // the incrementally built collection set. 240 void update_young_region_prediction(HeapRegion* hr, size_t new_rs_length); 241 242 // Add eden region to the collection set. 243 void add_eden_region(HeapRegion* hr); 244 245 // Add survivor region to the collection set. 246 void add_survivor_regions(HeapRegion* hr); 247 248 #ifndef PRODUCT 249 bool verify_young_ages(); 250 251 void print(outputStream* st); 252 #endif // !PRODUCT 253 }; 254 255 #endif // SHARE_GC_G1_G1COLLECTIONSET_HPP