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