1 /*
2 * Copyright (c) 2001, 2015, 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/g1/collectionSetChooser.hpp"
27 #include "gc/g1/g1CollectedHeap.inline.hpp"
28 #include "gc/g1/g1CollectorPolicy.hpp"
29 #include "gc/g1/g1ErgoVerbose.hpp"
30 #include "gc/shared/space.inline.hpp"
31 #include "runtime/atomic.inline.hpp"
32
33 // Even though we don't use the GC efficiency in our heuristics as
34 // much as we used to, we still order according to GC efficiency. This
35 // will cause regions with a lot of live objects and large RSets to
36 // end up at the end of the array. Given that we might skip collecting
37 // the last few old regions, if after a few mixed GCs the remaining
38 // have reclaimable bytes under a certain threshold, the hope is that
39 // the ones we'll skip are ones with both large RSets and a lot of
40 // live objects, not the ones with just a lot of live objects if we
41 // ordered according to the amount of reclaimable bytes per region.
42 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {
43 if (hr1 == NULL) {
44 if (hr2 == NULL) {
45 return 0;
46 } else {
47 return 1;
48 }
49 } else if (hr2 == NULL) {
50 return -1;
51 }
52
53 double gc_eff1 = hr1->gc_efficiency();
54 double gc_eff2 = hr2->gc_efficiency();
55 if (gc_eff1 > gc_eff2) {
56 return -1;
57 } if (gc_eff1 < gc_eff2) {
58 return 1;
59 } else {
60 return 0;
61 }
62 }
63
64 static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) {
65 return order_regions(*hr1p, *hr2p);
66 }
67
68 CollectionSetChooser::CollectionSetChooser() :
69 // The line below is the worst bit of C++ hackery I've ever written
70 // (Detlefs, 11/23). You should think of it as equivalent to
71 // "_regions(100, true)": initialize the growable array and inform it
72 // that it should allocate its elem array(s) on the C heap.
73 //
74 // The first argument, however, is actually a comma expression
75 // (set_allocation_type(this, C_HEAP), 100). The purpose of the
76 // set_allocation_type() call is to replace the default allocation
77 // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will
78 // allow to pass the assert in GenericGrowableArray() which checks
79 // that a growable array object must be on C heap if elements are.
80 //
81 // Note: containing object is allocated on C heap since it is CHeapObj.
82 //
83 _regions((ResourceObj::set_allocation_type((address) &_regions,
84 ResourceObj::C_HEAP),
85 100), true /* C_Heap */),
86 _curr_index(0), _length(0), _first_par_unreserved_idx(0),
87 _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) {
88 _region_live_threshold_bytes =
89 HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100;
90 }
91
92 #ifndef PRODUCT
93 void CollectionSetChooser::verify() {
94 guarantee(_length <= regions_length(),
95 err_msg("_length: %u regions length: %u", _length, regions_length()));
96 guarantee(_curr_index <= _length,
97 err_msg("_curr_index: %u _length: %u", _curr_index, _length));
98 uint index = 0;
99 size_t sum_of_reclaimable_bytes = 0;
100 while (index < _curr_index) {
101 guarantee(regions_at(index) == NULL,
102 "all entries before _curr_index should be NULL");
103 index += 1;
104 }
105 HeapRegion *prev = NULL;
106 while (index < _length) {
107 HeapRegion *curr = regions_at(index++);
108 guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
109 guarantee(!curr->is_young(), "should not be young!");
110 guarantee(!curr->is_pinned(), "should not be pinned!");
111 if (prev != NULL) {
112 guarantee(order_regions(prev, curr) != 1,
113 err_msg("GC eff prev: %1.4f GC eff curr: %1.4f",
114 prev->gc_efficiency(), curr->gc_efficiency()));
115 }
116 sum_of_reclaimable_bytes += curr->reclaimable_bytes();
117 prev = curr;
118 }
119 guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
120 err_msg("reclaimable bytes inconsistent, "
121 "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT,
122 _remaining_reclaimable_bytes, sum_of_reclaimable_bytes));
123 }
124 #endif // !PRODUCT
125
126 void CollectionSetChooser::sort_regions() {
127 // First trim any unused portion of the top in the parallel case.
128 if (_first_par_unreserved_idx > 0) {
129 assert(_first_par_unreserved_idx <= regions_length(),
130 "Or we didn't reserved enough length");
131 regions_trunc_to(_first_par_unreserved_idx);
132 }
133 _regions.sort(order_regions);
134 assert(_length <= regions_length(), "Requirement");
135 #ifdef ASSERT
136 for (uint i = 0; i < _length; i++) {
137 assert(regions_at(i) != NULL, "Should be true by sorting!");
138 }
139 #endif // ASSERT
140 if (G1PrintRegionLivenessInfo) {
141 G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting");
142 for (uint i = 0; i < _length; ++i) {
143 HeapRegion* r = regions_at(i);
144 cl.doHeapRegion(r);
145 }
146 }
147 verify();
148 }
149
150
151 void CollectionSetChooser::add_region(HeapRegion* hr) {
152 assert(!hr->is_pinned(),
153 "Pinned regions shouldn't be added to the collection set");
154 assert(!hr->is_young(), "should not be young!");
155 _regions.append(hr);
156 _length++;
157 _remaining_reclaimable_bytes += hr->reclaimable_bytes();
158 hr->calc_gc_efficiency();
159 }
160
161 void CollectionSetChooser::prepare_for_par_region_addition(uint n_threads,
162 uint n_regions,
163 uint chunk_size) {
164 _first_par_unreserved_idx = 0;
165 uint max_waste = n_threads * chunk_size;
166 // it should be aligned with respect to chunk_size
167 uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size;
168 assert(aligned_n_regions % chunk_size == 0, "should be aligned");
169 regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL);
170 }
171
172 uint CollectionSetChooser::claim_array_chunk(uint chunk_size) {
173 uint res = (uint) Atomic::add((jint) chunk_size,
174 (volatile jint*) &_first_par_unreserved_idx);
175 assert(regions_length() > res + chunk_size - 1,
176 "Should already have been expanded");
177 return res - chunk_size;
178 }
179
180 void CollectionSetChooser::set_region(uint index, HeapRegion* hr) {
181 assert(regions_at(index) == NULL, "precondition");
182 assert(!hr->is_young(), "should not be young!");
183 regions_at_put(index, hr);
184 hr->calc_gc_efficiency();
185 }
186
187 void CollectionSetChooser::update_totals(uint region_num,
188 size_t reclaimable_bytes) {
189 // Only take the lock if we actually need to update the totals.
190 if (region_num > 0) {
191 assert(reclaimable_bytes > 0, "invariant");
192 // We could have just used atomics instead of taking the
193 // lock. However, we currently don't have an atomic add for size_t.
194 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
195 _length += region_num;
196 _remaining_reclaimable_bytes += reclaimable_bytes;
197 } else {
198 assert(reclaimable_bytes == 0, "invariant");
199 }
200 }
201
202 void CollectionSetChooser::clear() {
203 _regions.clear();
204 _curr_index = 0;
205 _length = 0;
206 _remaining_reclaimable_bytes = 0;
207 };