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) {
119 "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(_end <= regions_length(), "Requirement");
134 #ifdef ASSERT
135 for (uint i = 0; i < _end; 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 < _end; ++i) {
142 HeapRegion* r = regions_at(i);
143 cl.doHeapRegion(r);
144 }
145 }
146 verify();
147 }
148
149
150 void CollectionSetChooser::add_region(HeapRegion* hr) {
151 assert(!hr->is_pinned(),
152 "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
153 assert(!hr->is_young(), "should not be young!");
154 _regions.append(hr);
155 _end++;
156 _remaining_reclaimable_bytes += hr->reclaimable_bytes();
157 hr->calc_gc_efficiency();
158 }
159
160 void CollectionSetChooser::push(HeapRegion* hr) {
|
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/shared/space.inline.hpp"
30 #include "runtime/atomic.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) {
118 "reclaimable bytes inconsistent, "
119 "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
120 _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
121 }
122 #endif // !PRODUCT
123
124 void CollectionSetChooser::sort_regions() {
125 // First trim any unused portion of the top in the parallel case.
126 if (_first_par_unreserved_idx > 0) {
127 assert(_first_par_unreserved_idx <= regions_length(),
128 "Or we didn't reserved enough length");
129 regions_trunc_to(_first_par_unreserved_idx);
130 }
131 _regions.sort(order_regions);
132 assert(_end <= regions_length(), "Requirement");
133 #ifdef ASSERT
134 for (uint i = 0; i < _end; i++) {
135 assert(regions_at(i) != NULL, "Should be true by sorting!");
136 }
137 #endif // ASSERT
138 if (log_is_enabled(Trace, gc, liveness)) {
139 G1PrintRegionLivenessInfoClosure cl("Post-Sorting");
140 for (uint i = 0; i < _end; ++i) {
141 HeapRegion* r = regions_at(i);
142 cl.doHeapRegion(r);
143 }
144 }
145 verify();
146 }
147
148
149 void CollectionSetChooser::add_region(HeapRegion* hr) {
150 assert(!hr->is_pinned(),
151 "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
152 assert(!hr->is_young(), "should not be young!");
153 _regions.append(hr);
154 _end++;
155 _remaining_reclaimable_bytes += hr->reclaimable_bytes();
156 hr->calc_gc_efficiency();
157 }
158
159 void CollectionSetChooser::push(HeapRegion* hr) {
|