author | jwilhelm |
Thu, 03 Oct 2013 21:36:29 +0200 | |
changeset 20398 | b206c580c45f |
parent 15861 | 974c3ccaa5d2 |
child 22234 | da823d78ad65 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
2 |
* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4473
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4473
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4473
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 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" |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
8930
diff
changeset
|
29 |
#include "gc_implementation/g1/g1ErgoVerbose.hpp" |
7397 | 30 |
#include "memory/space.inline.hpp" |
1374 | 31 |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
32 |
// Even though we don't use the GC efficiency in our heuristics as |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
33 |
// much as we used to, we still order according to GC efficiency. This |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
34 |
// will cause regions with a lot of live objects and large RSets to |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
35 |
// end up at the end of the array. Given that we might skip collecting |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
36 |
// the last few old regions, if after a few mixed GCs the remaining |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
37 |
// have reclaimable bytes under a certain threshold, the hope is that |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
38 |
// the ones we'll skip are ones with both large RSets and a lot of |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
39 |
// live objects, not the ones with just a lot of live objects if we |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
40 |
// ordered according to the amount of reclaimable bytes per region. |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
41 |
static int order_regions(HeapRegion* hr1, HeapRegion* hr2) { |
1374 | 42 |
if (hr1 == NULL) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
43 |
if (hr2 == NULL) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
44 |
return 0; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
45 |
} else { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
46 |
return 1; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
47 |
} |
1374 | 48 |
} else if (hr2 == NULL) { |
49 |
return -1; |
|
50 |
} |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
51 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
52 |
double gc_eff1 = hr1->gc_efficiency(); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
53 |
double gc_eff2 = hr2->gc_efficiency(); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
54 |
if (gc_eff1 > gc_eff2) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
55 |
return -1; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
56 |
} if (gc_eff1 < gc_eff2) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
57 |
return 1; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
58 |
} else { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
59 |
return 0; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
60 |
} |
1374 | 61 |
} |
62 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
63 |
static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
64 |
return order_regions(*hr1p, *hr2p); |
1374 | 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 |
|
6183
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
71 |
// that it should allocate its elem array(s) on the C heap. |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
72 |
// |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
73 |
// The first argument, however, is actually a comma expression |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
74 |
// (set_allocation_type(this, C_HEAP), 100). The purpose of the |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
75 |
// set_allocation_type() call is to replace the default allocation |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
76 |
// type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
77 |
// allow to pass the assert in GenericGrowableArray() which checks |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
78 |
// that a growable array object must be on C heap if elements are. |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
79 |
// |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
80 |
// Note: containing object is allocated on C heap since it is CHeapObj. |
4c74cfe14f20
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
5547
diff
changeset
|
81 |
// |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
82 |
_regions((ResourceObj::set_allocation_type((address) &_regions, |
1374 | 83 |
ResourceObj::C_HEAP), |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
84 |
100), true /* C_Heap */), |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
85 |
_curr_index(0), _length(0), _first_par_unreserved_idx(0), |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
86 |
_region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
87 |
_region_live_threshold_bytes = |
15089 | 88 |
HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
89 |
} |
1374 | 90 |
|
91 |
#ifndef PRODUCT |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
92 |
void CollectionSetChooser::verify() { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
93 |
guarantee(_length <= regions_length(), |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
94 |
err_msg("_length: %u regions length: %u", _length, regions_length())); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
95 |
guarantee(_curr_index <= _length, |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
96 |
err_msg("_curr_index: %u _length: %u", _curr_index, _length)); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
97 |
uint index = 0; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
98 |
size_t sum_of_reclaimable_bytes = 0; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
99 |
while (index < _curr_index) { |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
100 |
guarantee(regions_at(index) == NULL, |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
101 |
"all entries before _curr_index should be NULL"); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
102 |
index += 1; |
1374 | 103 |
} |
104 |
HeapRegion *prev = NULL; |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
105 |
while (index < _length) { |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
106 |
HeapRegion *curr = regions_at(index++); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
107 |
guarantee(curr != NULL, "Regions in _regions array cannot be NULL"); |
10680
f7bdba11999b
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
10523
diff
changeset
|
108 |
guarantee(!curr->is_young(), "should not be young!"); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
109 |
guarantee(!curr->isHumongous(), "should not be humongous!"); |
10680
f7bdba11999b
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
10523
diff
changeset
|
110 |
if (prev != NULL) { |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
111 |
guarantee(order_regions(prev, curr) != 1, |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
112 |
err_msg("GC eff prev: %1.4f GC eff curr: %1.4f", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
113 |
prev->gc_efficiency(), curr->gc_efficiency())); |
1374 | 114 |
} |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
115 |
sum_of_reclaimable_bytes += curr->reclaimable_bytes(); |
10680
f7bdba11999b
7095236: G1: _markedRegions never contains NULL regions
ysr
parents:
10523
diff
changeset
|
116 |
prev = curr; |
1374 | 117 |
} |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
118 |
guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes, |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
119 |
err_msg("reclaimable bytes inconsistent, " |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
120 |
"remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT, |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
121 |
_remaining_reclaimable_bytes, sum_of_reclaimable_bytes)); |
1374 | 122 |
} |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
123 |
#endif // !PRODUCT |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
124 |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
125 |
void CollectionSetChooser::sort_regions() { |
1374 | 126 |
// First trim any unused portion of the top in the parallel case. |
127 |
if (_first_par_unreserved_idx > 0) { |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
128 |
assert(_first_par_unreserved_idx <= regions_length(), |
1374 | 129 |
"Or we didn't reserved enough length"); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
130 |
regions_trunc_to(_first_par_unreserved_idx); |
1374 | 131 |
} |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
132 |
_regions.sort(order_regions); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
133 |
assert(_length <= regions_length(), "Requirement"); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
134 |
#ifdef ASSERT |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
135 |
for (uint i = 0; i < _length; i++) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
136 |
assert(regions_at(i) != NULL, "Should be true by sorting!"); |
1374 | 137 |
} |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
138 |
#endif // ASSERT |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
7397
diff
changeset
|
139 |
if (G1PrintRegionLivenessInfo) { |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
7397
diff
changeset
|
140 |
G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
141 |
for (uint i = 0; i < _length; ++i) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
142 |
HeapRegion* r = regions_at(i); |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
7397
diff
changeset
|
143 |
cl.doHeapRegion(r); |
1374 | 144 |
} |
145 |
} |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
146 |
verify(); |
1374 | 147 |
} |
148 |
||
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
149 |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
150 |
void CollectionSetChooser::add_region(HeapRegion* hr) { |
1374 | 151 |
assert(!hr->isHumongous(), |
152 |
"Humongous regions shouldn't be added to the collection set"); |
|
153 |
assert(!hr->is_young(), "should not be young!"); |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
154 |
_regions.append(hr); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
155 |
_length++; |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
156 |
_remaining_reclaimable_bytes += hr->reclaimable_bytes(); |
1374 | 157 |
hr->calc_gc_efficiency(); |
158 |
} |
|
159 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
160 |
void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions, |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
161 |
uint chunk_size) { |
1374 | 162 |
_first_par_unreserved_idx = 0; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12228
diff
changeset
|
163 |
uint n_threads = (uint) ParallelGCThreads; |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
164 |
if (UseDynamicNumberOfGCThreads) { |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
165 |
assert(G1CollectedHeap::heap()->workers()->active_workers() > 0, |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
166 |
"Should have been set earlier"); |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
167 |
// This is defensive code. As the assertion above says, the number |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
168 |
// of active threads should be > 0, but in case there is some path |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
169 |
// or some improperly initialized variable with leads to no |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
170 |
// active threads, protect against that in a product build. |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
171 |
n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(), |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11174
diff
changeset
|
172 |
1U); |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
10680
diff
changeset
|
173 |
} |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
174 |
uint max_waste = n_threads * chunk_size; |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
175 |
// it should be aligned with respect to chunk_size |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
176 |
uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size; |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
177 |
assert(aligned_n_regions % chunk_size == 0, "should be aligned"); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
178 |
regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL); |
1374 | 179 |
} |
180 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
181 |
uint CollectionSetChooser::claim_array_chunk(uint chunk_size) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
182 |
uint res = (uint) Atomic::add((jint) chunk_size, |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
183 |
(volatile jint*) &_first_par_unreserved_idx); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
184 |
assert(regions_length() > res + chunk_size - 1, |
1374 | 185 |
"Should already have been expanded"); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
186 |
return res - chunk_size; |
1374 | 187 |
} |
188 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
189 |
void CollectionSetChooser::set_region(uint index, HeapRegion* hr) { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
190 |
assert(regions_at(index) == NULL, "precondition"); |
1374 | 191 |
assert(!hr->is_young(), "should not be young!"); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
192 |
regions_at_put(index, hr); |
1374 | 193 |
hr->calc_gc_efficiency(); |
194 |
} |
|
195 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
196 |
void CollectionSetChooser::update_totals(uint region_num, |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
197 |
size_t reclaimable_bytes) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
198 |
// Only take the lock if we actually need to update the totals. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
199 |
if (region_num > 0) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
200 |
assert(reclaimable_bytes > 0, "invariant"); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
201 |
// We could have just used atomics instead of taking the |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
202 |
// lock. However, we currently don't have an atomic add for size_t. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
203 |
MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
204 |
_length += region_num; |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
205 |
_remaining_reclaimable_bytes += reclaimable_bytes; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
206 |
} else { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
207 |
assert(reclaimable_bytes == 0, "invariant"); |
1374 | 208 |
} |
209 |
} |
|
210 |
||
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
211 |
void CollectionSetChooser::clear() { |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
212 |
_regions.clear(); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
213 |
_curr_index = 0; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
214 |
_length = 0; |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
215 |
_remaining_reclaimable_bytes = 0; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11396
diff
changeset
|
216 |
}; |