Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/collectionSetChooser.cpp @ 8081:579f6adb7f51
8003539: Minimal VM don't react to -Dcom.sun.management and -XX:+ManagementServer
Summary: A warning message should be displayed if these options are used with the Minimal VM.
Reviewed-by: dholmes, dsamersoff
author | jprovino |
---|---|
date | Tue, 05 Feb 2013 13:32:34 -0500 |
parents | 37f7535e5f18 |
children | 27714220e50e |
rev | line source |
---|---|
342 | 1 /* |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
342 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1103
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1103
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1103
diff
changeset
|
21 * questions. |
342 | 22 * |
23 */ | |
24 | |
1972 | 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" | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
2435
diff
changeset
|
29 #include "gc_implementation/g1/g1ErgoVerbose.hpp" |
1972 | 30 #include "memory/space.inline.hpp" |
342 | 31 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
32 // Even though we don't use the GC efficiency in our heuristics as |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
33 // much as we used to, we still order according to GC efficiency. This |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
34 // will cause regions with a lot of live objects and large RSets to |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
35 // end up at the end of the array. Given that we might skip collecting |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
36 // the last few old regions, if after a few mixed GCs the remaining |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
37 // have reclaimable bytes under a certain threshold, the hope is that |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
38 // the ones we'll skip are ones with both large RSets and a lot of |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
39 // live objects, not the ones with just a lot of live objects if we |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
40 // ordered according to the amount of reclaimable bytes per region. |
6011 | 41 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) { |
342 | 42 if (hr1 == NULL) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
43 if (hr2 == NULL) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
44 return 0; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
45 } else { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
46 return 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
47 } |
342 | 48 } else if (hr2 == NULL) { |
49 return -1; | |
50 } | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
51 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
52 double gc_eff1 = hr1->gc_efficiency(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
53 double gc_eff2 = hr2->gc_efficiency(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
54 if (gc_eff1 > gc_eff2) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
55 return -1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
56 } if (gc_eff1 < gc_eff2) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
57 return 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
58 } else { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
59 return 0; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
60 } |
342 | 61 } |
62 | |
6011 | 63 static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) { |
64 return order_regions(*hr1p, *hr2p); | |
342 | 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 | |
1688
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
71 // that it should allocate its elem array(s) on the C heap. |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
72 // |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
73 // The first argument, however, is actually a comma expression |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
74 // (set_allocation_type(this, C_HEAP), 100). The purpose of the |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
75 // set_allocation_type() call is to replace the default allocation |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
76 // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
77 // allow to pass the assert in GenericGrowableArray() which checks |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
78 // that a growable array object must be on C heap if elements are. |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
79 // |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
80 // Note: containing object is allocated on C heap since it is CHeapObj. |
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1552
diff
changeset
|
81 // |
6011 | 82 _regions((ResourceObj::set_allocation_type((address) &_regions, |
342 | 83 ResourceObj::C_HEAP), |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
84 100), true /* C_Heap */), |
6011 | 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 = | |
7449 | 88 HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
89 } |
342 | 90 |
91 #ifndef PRODUCT | |
6011 | 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; | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
98 size_t sum_of_reclaimable_bytes = 0; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
99 while (index < _curr_index) { |
6011 | 100 guarantee(regions_at(index) == NULL, |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
101 "all entries before _curr_index should be NULL"); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
102 index += 1; |
342 | 103 } |
104 HeapRegion *prev = NULL; | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
105 while (index < _length) { |
6011 | 106 HeapRegion *curr = regions_at(index++); |
107 guarantee(curr != NULL, "Regions in _regions array cannot be NULL"); | |
3989
b9390528617c
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
3914
diff
changeset
|
108 guarantee(!curr->is_young(), "should not be young!"); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
109 guarantee(!curr->isHumongous(), "should not be humongous!"); |
3989
b9390528617c
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
3914
diff
changeset
|
110 if (prev != NULL) { |
6011 | 111 guarantee(order_regions(prev, curr) != 1, |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
112 err_msg("GC eff prev: %1.4f GC eff curr: %1.4f", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
113 prev->gc_efficiency(), curr->gc_efficiency())); |
342 | 114 } |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
115 sum_of_reclaimable_bytes += curr->reclaimable_bytes(); |
3989
b9390528617c
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
3914
diff
changeset
|
116 prev = curr; |
342 | 117 } |
6011 | 118 guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes, |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
119 err_msg("reclaimable bytes inconsistent, " |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
120 "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT, |
6011 | 121 _remaining_reclaimable_bytes, sum_of_reclaimable_bytes)); |
342 | 122 } |
6011 | 123 #endif // !PRODUCT |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
124 |
6011 | 125 void CollectionSetChooser::sort_regions() { |
342 | 126 // First trim any unused portion of the top in the parallel case. |
127 if (_first_par_unreserved_idx > 0) { | |
6011 | 128 assert(_first_par_unreserved_idx <= regions_length(), |
342 | 129 "Or we didn't reserved enough length"); |
6011 | 130 regions_trunc_to(_first_par_unreserved_idx); |
342 | 131 } |
6011 | 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!"); | |
342 | 137 } |
6011 | 138 #endif // ASSERT |
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
1972
diff
changeset
|
139 if (G1PrintRegionLivenessInfo) { |
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
1972
diff
changeset
|
140 G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); |
6011 | 141 for (uint i = 0; i < _length; ++i) { |
142 HeapRegion* r = regions_at(i); | |
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
1972
diff
changeset
|
143 cl.doHeapRegion(r); |
342 | 144 } |
145 } | |
6011 | 146 verify(); |
342 | 147 } |
148 | |
6011 | 149 uint CollectionSetChooser::calc_min_old_cset_length() { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
150 // The min old CSet region bound is based on the maximum desired |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
151 // number of mixed GCs after a cycle. I.e., even if some old regions |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
152 // look expensive, we should add them to the CSet anyway to make |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
153 // sure we go through the available old regions in no more than the |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
154 // maximum desired number of mixed GCs. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
155 // |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
156 // The calculation is based on the number of marked regions we added |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
157 // to the CSet chooser in the first place, not how many remain, so |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
158 // that the result is the same during all mixed GCs that follow a cycle. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
159 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
160 const size_t region_num = (size_t) _length; |
5964
21595f05bc93
7146246: G1: expose some of the -XX flags that drive which old regions to collect during mixed GCs
tonyp
parents:
4912
diff
changeset
|
161 const size_t gc_num = (size_t) G1MixedGCCountTarget; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
162 size_t result = region_num / gc_num; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
163 // emulate ceiling |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
164 if (result * gc_num < region_num) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
165 result += 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
166 } |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
5964
diff
changeset
|
167 return (uint) result; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
168 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
169 |
6011 | 170 uint CollectionSetChooser::calc_max_old_cset_length() { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
171 // The max old CSet region bound is based on the threshold expressed |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
172 // as a percentage of the heap size. I.e., it should bound the |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
173 // number of old regions added to the CSet irrespective of how many |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
174 // of them are available. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
175 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
176 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
177 const size_t region_num = g1h->n_regions(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
178 const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
179 size_t result = region_num * perc / 100; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
180 // emulate ceiling |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
181 if (100 * result < region_num * perc) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
182 result += 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
183 } |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
5964
diff
changeset
|
184 return (uint) result; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
185 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
186 |
6011 | 187 void CollectionSetChooser::add_region(HeapRegion* hr) { |
342 | 188 assert(!hr->isHumongous(), |
189 "Humongous regions shouldn't be added to the collection set"); | |
190 assert(!hr->is_young(), "should not be young!"); | |
6011 | 191 _regions.append(hr); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
192 _length++; |
6011 | 193 _remaining_reclaimable_bytes += hr->reclaimable_bytes(); |
342 | 194 hr->calc_gc_efficiency(); |
195 } | |
196 | |
6011 | 197 void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions, |
198 uint chunk_size) { | |
342 | 199 _first_par_unreserved_idx = 0; |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
5964
diff
changeset
|
200 uint n_threads = (uint) ParallelGCThreads; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
201 if (UseDynamicNumberOfGCThreads) { |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
202 assert(G1CollectedHeap::heap()->workers()->active_workers() > 0, |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
203 "Should have been set earlier"); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
204 // This is defensive code. As the assertion above says, the number |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
205 // of active threads should be > 0, but in case there is some path |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
206 // or some improperly initialized variable with leads to no |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
207 // active threads, protect against that in a product build. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
208 n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(), |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
209 1U); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3989
diff
changeset
|
210 } |
6011 | 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); | |
342 | 216 } |
217 | |
6011 | 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, | |
342 | 222 "Should already have been expanded"); |
6011 | 223 return res - chunk_size; |
342 | 224 } |
225 | |
6011 | 226 void CollectionSetChooser::set_region(uint index, HeapRegion* hr) { |
227 assert(regions_at(index) == NULL, "precondition"); | |
342 | 228 assert(!hr->is_young(), "should not be young!"); |
6011 | 229 regions_at_put(index, hr); |
342 | 230 hr->calc_gc_efficiency(); |
231 } | |
232 | |
6011 | 233 void CollectionSetChooser::update_totals(uint region_num, |
234 size_t reclaimable_bytes) { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
235 // Only take the lock if we actually need to update the totals. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
236 if (region_num > 0) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
237 assert(reclaimable_bytes > 0, "invariant"); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
238 // We could have just used atomics instead of taking the |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
239 // lock. However, we currently don't have an atomic add for size_t. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
240 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); |
6011 | 241 _length += region_num; |
242 _remaining_reclaimable_bytes += reclaimable_bytes; | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
243 } else { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
244 assert(reclaimable_bytes == 0, "invariant"); |
342 | 245 } |
246 } | |
247 | |
6011 | 248 void CollectionSetChooser::clear() { |
249 _regions.clear(); | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
250 _curr_index = 0; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
251 _length = 0; |
6011 | 252 _remaining_reclaimable_bytes = 0; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4728
diff
changeset
|
253 }; |