1 /* 2 * Copyright (c) 2001, 2012, 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 #include "precompiled.hpp" 26 #include "gc_implementation/g1/collectionSetChooser.hpp" 27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" 28 #include "gc_implementation/g1/g1CollectorPolicy.hpp" 29 #include "gc_implementation/g1/g1ErgoVerbose.hpp" 30 #include "memory/space.inline.hpp" 31 32 // Even though we don't use the GC efficiency in our heuristics as 33 // much as we used to, we still order according to GC efficiency. This 34 // will cause regions with a lot of live objects and large RSets to 35 // end up at the end of the array. Given that we might skip collecting 36 // the last few old regions, if after a few mixed GCs the remaining 37 // have reclaimable bytes under a certain threshold, the hope is that 38 // the ones we'll skip are ones with both large RSets and a lot of 39 // live objects, not the ones with just a lot of live objects if we 40 // ordered according to the amount of reclaimable bytes per region. 41 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) { 42 if (hr1 == NULL) { 43 if (hr2 == NULL) { 44 return 0; 45 } else { 46 return 1; 47 } 48 } else if (hr2 == NULL) { 49 return -1; 50 } 51 52 double gc_eff1 = hr1->gc_efficiency(); 53 double gc_eff2 = hr2->gc_efficiency(); 54 if (gc_eff1 > gc_eff2) { 55 return -1; 56 } if (gc_eff1 < gc_eff2) { 57 return 1; 58 } else { 59 return 0; 60 } 61 } 62 63 static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) { 64 return order_regions(*hr1p, *hr2p); 65 } 66 67 CollectionSetChooser::CollectionSetChooser() : 68 // The line below is the worst bit of C++ hackery I've ever written 69 // (Detlefs, 11/23). You should think of it as equivalent to 70 // "_regions(100, true)": initialize the growable array and inform it 71 // that it should allocate its elem array(s) on the C heap. 72 // 73 // The first argument, however, is actually a comma expression 74 // (set_allocation_type(this, C_HEAP), 100). The purpose of the 75 // set_allocation_type() call is to replace the default allocation 76 // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will 77 // allow to pass the assert in GenericGrowableArray() which checks 78 // that a growable array object must be on C heap if elements are. 79 // 80 // Note: containing object is allocated on C heap since it is CHeapObj. 81 // 82 _regions((ResourceObj::set_allocation_type((address) &_regions, 83 ResourceObj::C_HEAP), 84 100), true /* C_Heap */), 85 _curr_index(0), _length(0), _first_par_unreserved_idx(0), 86 _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) { 87 _region_live_threshold_bytes = 88 HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100; 89 } 90 91 #ifndef PRODUCT 92 void CollectionSetChooser::verify() { 93 guarantee(_length <= regions_length(), 94 err_msg("_length: %u regions length: %u", _length, regions_length())); 95 guarantee(_curr_index <= _length, 96 err_msg("_curr_index: %u _length: %u", _curr_index, _length)); 97 uint index = 0; 98 size_t sum_of_reclaimable_bytes = 0; 99 while (index < _curr_index) { 100 guarantee(regions_at(index) == NULL, 101 "all entries before _curr_index should be NULL"); 102 index += 1; 103 } 104 HeapRegion *prev = NULL; 105 while (index < _length) { 106 HeapRegion *curr = regions_at(index++); 107 guarantee(curr != NULL, "Regions in _regions array cannot be NULL"); 108 guarantee(!curr->is_young(), "should not be young!"); 109 guarantee(!curr->isHumongous(), "should not be humongous!"); 110 if (prev != NULL) { 111 guarantee(order_regions(prev, curr) != 1, 112 err_msg("GC eff prev: %1.4f GC eff curr: %1.4f", 113 prev->gc_efficiency(), curr->gc_efficiency())); 114 } 115 sum_of_reclaimable_bytes += curr->reclaimable_bytes(); 116 prev = curr; 117 } 118 guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes, 119 err_msg("reclaimable bytes inconsistent, " 120 "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT, 121 _remaining_reclaimable_bytes, sum_of_reclaimable_bytes)); 122 } 123 #endif // !PRODUCT 124 125 void CollectionSetChooser::sort_regions() { 126 // First trim any unused portion of the top in the parallel case. 127 if (_first_par_unreserved_idx > 0) { 128 assert(_first_par_unreserved_idx <= regions_length(), 129 "Or we didn't reserved enough length"); 130 regions_trunc_to(_first_par_unreserved_idx); 131 } 132 _regions.sort(order_regions); 133 assert(_length <= regions_length(), "Requirement"); 134 #ifdef ASSERT 135 for (uint i = 0; i < _length; i++) { 136 assert(regions_at(i) != NULL, "Should be true by sorting!"); 137 } 138 #endif // ASSERT 139 if (G1PrintRegionLivenessInfo) { 140 G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); 141 for (uint i = 0; i < _length; ++i) { 142 HeapRegion* r = regions_at(i); 143 cl.doHeapRegion(r); 144 } 145 } 146 verify(); 147 } 148 149 uint CollectionSetChooser::calc_min_old_cset_length() { 150 // The min old CSet region bound is based on the maximum desired 151 // number of mixed GCs after a cycle. I.e., even if some old regions 152 // look expensive, we should add them to the CSet anyway to make 153 // sure we go through the available old regions in no more than the 154 // maximum desired number of mixed GCs. 155 // 156 // The calculation is based on the number of marked regions we added 157 // to the CSet chooser in the first place, not how many remain, so 158 // that the result is the same during all mixed GCs that follow a cycle. 159 160 const size_t region_num = (size_t) _length; 161 const size_t gc_num = (size_t) G1MixedGCCountTarget; 162 size_t result = region_num / gc_num; 163 // emulate ceiling 164 if (result * gc_num < region_num) { 165 result += 1; 166 } 167 return (uint) result; 168 } 169 170 uint CollectionSetChooser::calc_max_old_cset_length() { 171 // The max old CSet region bound is based on the threshold expressed 172 // as a percentage of the heap size. I.e., it should bound the 173 // number of old regions added to the CSet irrespective of how many 174 // of them are available. 175 176 G1CollectedHeap* g1h = G1CollectedHeap::heap(); 177 const size_t region_num = g1h->n_regions(); 178 const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; 179 size_t result = region_num * perc / 100; 180 // emulate ceiling 181 if (100 * result < region_num * perc) { 182 result += 1; 183 } 184 return (uint) result; 185 } 186 187 void CollectionSetChooser::add_region(HeapRegion* hr) { 188 assert(!hr->isHumongous(), 189 "Humongous regions shouldn't be added to the collection set"); 190 assert(!hr->is_young(), "should not be young!"); 191 _regions.append(hr); 192 _length++; 193 _remaining_reclaimable_bytes += hr->reclaimable_bytes(); 194 hr->calc_gc_efficiency(); 195 } 196 197 void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions, 198 uint chunk_size) { 199 _first_par_unreserved_idx = 0; 200 uint n_threads = (uint) ParallelGCThreads; 201 if (UseDynamicNumberOfGCThreads) { 202 assert(G1CollectedHeap::heap()->workers()->active_workers() > 0, 203 "Should have been set earlier"); 204 // This is defensive code. As the assertion above says, the number 205 // of active threads should be > 0, but in case there is some path 206 // or some improperly initialized variable with leads to no 207 // active threads, protect against that in a product build. 208 n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(), 209 1U); 210 } 211 uint max_waste = n_threads * chunk_size; 212 // it should be aligned with respect to chunk_size 213 uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size; 214 assert(aligned_n_regions % chunk_size == 0, "should be aligned"); 215 regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL); 216 } 217 218 uint CollectionSetChooser::claim_array_chunk(uint chunk_size) { 219 uint res = (uint) Atomic::add((jint) chunk_size, 220 (volatile jint*) &_first_par_unreserved_idx); 221 assert(regions_length() > res + chunk_size - 1, 222 "Should already have been expanded"); 223 return res - chunk_size; 224 } 225 226 void CollectionSetChooser::set_region(uint index, HeapRegion* hr) { 227 assert(regions_at(index) == NULL, "precondition"); 228 assert(!hr->is_young(), "should not be young!"); 229 regions_at_put(index, hr); 230 hr->calc_gc_efficiency(); 231 } 232 233 void CollectionSetChooser::update_totals(uint region_num, 234 size_t reclaimable_bytes) { 235 // Only take the lock if we actually need to update the totals. 236 if (region_num > 0) { 237 assert(reclaimable_bytes > 0, "invariant"); 238 // We could have just used atomics instead of taking the 239 // lock. However, we currently don't have an atomic add for size_t. 240 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); 241 _length += region_num; 242 _remaining_reclaimable_bytes += reclaimable_bytes; 243 } else { 244 assert(reclaimable_bytes == 0, "invariant"); 245 } 246 } 247 248 void CollectionSetChooser::clear() { 249 _regions.clear(); 250 _curr_index = 0; 251 _length = 0; 252 _remaining_reclaimable_bytes = 0; 253 };