collectionSetChooser.cpp revision 9727:f944761a3ce3 
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/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.
41static 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) {
49    return -1;
50  }
51
52  double gc_eff1 = hr1->gc_efficiency();
53  double gc_eff2 = hr2->gc_efficiency();
54  if (gc_eff1 > gc_eff2) {
55    return -1;
56  } if (gc_eff1 < gc_eff2) {
57    return 1;
58  } else {
59    return 0;
60  }
61}
62
63static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) {
64  return order_regions(*hr1p, *hr2p);
65}
66
67CollectionSetChooser::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
71  // that it should allocate its elem array(s) on the C heap.
72  //
73  // The first argument, however, is actually a comma expression
74  // (set_allocation_type(this, C_HEAP), 100). The purpose of the
75  // set_allocation_type() call is to replace the default allocation
76  // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will
77  // allow to pass the assert in GenericGrowableArray() which checks
78  // that a growable array object must be on C heap if elements are.
79  //
80  // Note: containing object is allocated on C heap since it is CHeapObj.
81  //
82  _regions((ResourceObj::set_allocation_type((address) &_regions,
83                                             ResourceObj::C_HEAP),
84                  100), true /* C_Heap */),
85    _front(0), _end(0), _first_par_unreserved_idx(0),
86    _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) {
87  _region_live_threshold_bytes =
88    HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100;
89}
90
91#ifndef PRODUCT
92void CollectionSetChooser::verify() {
93  guarantee(_end <= regions_length(), "_end: %u regions length: %u", _end, regions_length());
94  guarantee(_front <= _end, "_front: %u _end: %u", _front, _end);
95  uint index = 0;
96  size_t sum_of_reclaimable_bytes = 0;
97  while (index < _front) {
98    guarantee(regions_at(index) == NULL,
99              "all entries before _front should be NULL");
100    index += 1;
101  }
102  HeapRegion *prev = NULL;
103  while (index < _end) {
104    HeapRegion *curr = regions_at(index++);
105    guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
106    guarantee(!curr->is_young(), "should not be young!");
107    guarantee(!curr->is_pinned(),
108              "Pinned region should not be in collection set (index %u)", curr->hrm_index());
109    if (prev != NULL) {
110      guarantee(order_regions(prev, curr) != 1,
111                "GC eff prev: %1.4f GC eff curr: %1.4f",
112                prev->gc_efficiency(), curr->gc_efficiency());
113    }
114    sum_of_reclaimable_bytes += curr->reclaimable_bytes();
115    prev = curr;
116  }
117  guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
118            "reclaimable bytes inconsistent, "
119            "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
120            _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
121}
122#endif // !PRODUCT
123
124void 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
149void 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
159void CollectionSetChooser::push(HeapRegion* hr) {
160  assert(hr != NULL, "Can't put back a NULL region");
161  assert(_front >= 1, "Too many regions have been put back");
162  _front--;
163  regions_at_put(_front, hr);
164  _remaining_reclaimable_bytes += hr->reclaimable_bytes();
165}
166
167void CollectionSetChooser::prepare_for_par_region_addition(uint n_threads,
168                                                           uint n_regions,
169                                                           uint chunk_size) {
170  _first_par_unreserved_idx = 0;
171  uint max_waste = n_threads * chunk_size;
172  // it should be aligned with respect to chunk_size
173  uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size;
174  assert(aligned_n_regions % chunk_size == 0, "should be aligned");
175  regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL);
176}
177
178uint CollectionSetChooser::claim_array_chunk(uint chunk_size) {
179  uint res = (uint) Atomic::add((jint) chunk_size,
180                                (volatile jint*) &_first_par_unreserved_idx);
181  assert(regions_length() > res + chunk_size - 1,
182         "Should already have been expanded");
183  return res - chunk_size;
184}
185
186void CollectionSetChooser::set_region(uint index, HeapRegion* hr) {
187  assert(regions_at(index) == NULL, "precondition");
188  assert(!hr->is_young(), "should not be young!");
189  regions_at_put(index, hr);
190  hr->calc_gc_efficiency();
191}
192
193void CollectionSetChooser::update_totals(uint region_num,
194                                         size_t reclaimable_bytes) {
195  // Only take the lock if we actually need to update the totals.
196  if (region_num > 0) {
197    assert(reclaimable_bytes > 0, "invariant");
198    // We could have just used atomics instead of taking the
199    // lock. However, we currently don't have an atomic add for size_t.
200    MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
201    _end += region_num;
202    _remaining_reclaimable_bytes += reclaimable_bytes;
203  } else {
204    assert(reclaimable_bytes == 0, "invariant");
205  }
206}
207
208void CollectionSetChooser::clear() {
209  _regions.clear();
210  _front = 0;
211  _end = 0;
212  _remaining_reclaimable_bytes = 0;
213};
214