< prev index next >

src/hotspot/share/gc/g1/collectionSetChooser.cpp

Print this page
rev 53416 : imported patch 8217330-split-collectionsetchooser
rev 53417 : [mq]: 8217330-leo-review
   1 /*
   2  * Copyright (c) 2001, 2018, 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/heapRegionRemSet.hpp"
  29 #include "gc/shared/space.inline.hpp"
  30 #include "runtime/atomic.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) {
  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 
  63 static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) {
  64   return order_regions(*hr1p, *hr2p);
  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
  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 = mixed_gc_live_threshold_bytes();
  88 }
  89 
  90 #ifndef PRODUCT
  91 void CollectionSetChooser::verify() {
  92   guarantee(_end <= regions_length(), "_end: %u regions length: %u", _end, regions_length());
  93   guarantee(_front <= _end, "_front: %u _end: %u", _front, _end);
  94   uint index = 0;
  95   size_t sum_of_reclaimable_bytes = 0;
  96   while (index < _front) {
  97     guarantee(regions_at(index) == NULL,
  98               "all entries before _front should be NULL");
  99     index += 1;
 100   }
 101   HeapRegion *prev = NULL;
 102   while (index < _end) {
 103     HeapRegion *curr = regions_at(index++);
 104     guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
 105     guarantee(!curr->is_young(), "should not be young!");
 106     guarantee(!curr->is_pinned(),
 107               "Pinned region should not be in collection set (index %u)", curr->hrm_index());
 108     if (prev != NULL) {
 109       guarantee(order_regions(prev, curr) != 1,
 110                 "GC eff prev: %1.4f GC eff curr: %1.4f",
 111                 prev->gc_efficiency(), curr->gc_efficiency());
 112     }
 113     sum_of_reclaimable_bytes += curr->reclaimable_bytes();
 114     prev = curr;
 115   }
 116   guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
 117             "reclaimable bytes inconsistent, "
 118             "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
 119             _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
 120 }
 121 #endif // !PRODUCT
 122 
 123 void CollectionSetChooser::sort_regions() {
 124   // First trim any unused portion of the top in the parallel case.
 125   if (_first_par_unreserved_idx > 0) {
 126     assert(_first_par_unreserved_idx <= regions_length(),
 127            "Or we didn't reserved enough length");
 128     regions_trunc_to(_first_par_unreserved_idx);
 129   }
 130   _regions.sort(order_regions);
 131   assert(_end <= regions_length(), "Requirement");
 132 #ifdef ASSERT
 133   for (uint i = 0; i < _end; i++) {
 134     assert(regions_at(i) != NULL, "Should be true by sorting!");
 135   }
 136 #endif // ASSERT
 137   if (log_is_enabled(Trace, gc, liveness)) {
 138     G1PrintRegionLivenessInfoClosure cl("Post-Sorting");
 139     for (uint i = 0; i < _end; ++i) {
 140       HeapRegion* r = regions_at(i);
 141       cl.do_heap_region(r);
 142     }
 143   }
 144   verify();
 145 }
 146 
 147 void CollectionSetChooser::add_region(HeapRegion* hr) {
 148   assert(!hr->is_pinned(),
 149          "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
 150   assert(hr->is_old(), "should be old but is %s", hr->get_type_str());
 151   assert(hr->rem_set()->is_complete(),
 152          "Trying to add region %u to the collection set with incomplete remembered set", hr->hrm_index());
 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) {
 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 
 167 void 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 
 178 uint 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 
 186 void CollectionSetChooser::set_region(uint index, HeapRegion* hr) {
 187   assert(regions_at(index) == NULL, "precondition");
 188   assert(hr->is_old(), "should be old but is %s", hr->get_type_str());
 189   regions_at_put(index, hr);
 190   hr->calc_gc_efficiency();
 191 }
 192 
 193 void 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 
 208 void CollectionSetChooser::iterate(HeapRegionClosure* cl) {
 209   for (uint i = _front; i < _end; i++) {
 210     HeapRegion* r = regions_at(i);
 211     if (cl->do_heap_region(r)) {
 212       cl->set_incomplete();
 213       break;
 214     }




 215   }
 216 }











 217 
 218 void CollectionSetChooser::clear() {
 219   _regions.clear();
 220   _front = 0;
 221   _end = 0;
 222   _remaining_reclaimable_bytes = 0;
 223 }
 224 
 225 class ParKnownGarbageHRClosure: public HeapRegionClosure {
 226   G1CollectedHeap* _g1h;
 227   CSetChooserParUpdater _cset_updater;
 228 
 229 public:
 230   ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted,
 231                            uint chunk_size) :
 232     _g1h(G1CollectedHeap::heap()),
 233     _cset_updater(hrSorted, true /* parallel */, chunk_size) { }






















 234 
 235   bool do_heap_region(HeapRegion* r) {
 236     // We will skip any region that's currently used as an old GC
 237     // alloc region (we should not consider those for collection
 238     // before we fill them up).
 239     if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) {
 240       _cset_updater.add_region(r);
 241     } else if (r->is_old()) {
 242       // Keep remembered sets for humongous regions, otherwise clean out remembered
 243       // sets for old regions.
 244       r->rem_set()->clear(true /* only_cardset */);
 245     } else {
 246       assert(r->is_archive() || !r->is_old() || !r->rem_set()->is_tracked(),
 247              "Missed to clear unused remembered set of region %u (%s) that is %s",
 248              r->hrm_index(), r->get_type_str(), r->rem_set()->get_state_str());
 249     }
 250     return false;
 251   }
 252 };
 253 
 254 class ParKnownGarbageTask: public AbstractGangTask {
 255   CollectionSetChooser* _hrSorted;
 256   uint _chunk_size;

 257   G1CollectedHeap* _g1h;
 258   HeapRegionClaimer _hrclaimer;
 259 















 260 public:
 261   ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size, uint n_workers) :
 262       AbstractGangTask("ParKnownGarbageTask"),
 263       _hrSorted(hrSorted), _chunk_size(chunk_size),
 264       _g1h(G1CollectedHeap::heap()), _hrclaimer(n_workers) {}



 265 
 266   void work(uint worker_id) {
 267     ParKnownGarbageHRClosure par_known_garbage_cl(_hrSorted, _chunk_size);
 268     _g1h->heap_region_par_iterate_from_worker_offset(&par_known_garbage_cl, &_hrclaimer, worker_id);

 269   }
 270 };
 271 
 272 uint CollectionSetChooser::calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const {
 273   assert(n_workers > 0, "Active gc workers should be greater than 0");
 274   const uint overpartition_factor = 4;
 275   const uint min_chunk_size = MAX2(n_regions / n_workers, 1U);
 276   return MAX2(n_regions / (n_workers * overpartition_factor), min_chunk_size);
 277 }


 278 
 279 bool CollectionSetChooser::region_occupancy_low_enough_for_evac(size_t live_bytes) {
 280   return live_bytes < mixed_gc_live_threshold_bytes();

 281 }
 282 
 283 bool CollectionSetChooser::should_add(HeapRegion* hr) const {
 284   return !hr->is_young() &&
 285          !hr->is_pinned() &&
 286          region_occupancy_low_enough_for_evac(hr->live_bytes()) &&
 287          hr->rem_set()->is_complete();
 288 }
 289 
 290 void CollectionSetChooser::rebuild(WorkGang* workers, uint n_regions) {
 291   clear();
 292 
 293   uint n_workers = workers->active_workers();
 294 
 295   uint chunk_size = calculate_parallel_work_chunk_size(n_workers, n_regions);
 296   prepare_for_par_region_addition(n_workers, n_regions, chunk_size);
 297 
 298   ParKnownGarbageTask par_known_garbage_task(this, chunk_size, n_workers);
 299   workers->run_task(&par_known_garbage_task);
 300 
 301   sort_regions();
 302 }
   1 /*
   2  * Copyright (c) 2001, 2019, 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/heapRegionRemSet.hpp"
  29 #include "gc/shared/space.inline.hpp"
  30 #include "runtime/atomic.hpp"
  31 #include "utilities/quickSort.hpp"
  32 
  33 // Order regions according to GC efficiency. This will cause regions with a lot
  34 // of live objects and large remembered sets to end up at the end of the array.
  35 // Given that we might skip collecting the last few old regions, if after a few
  36 // mixed GCs the remaining have reclaimable bytes under a certain threshold, the
  37 // hope is that the ones we'll skip are ones with both large remembered sets and
  38 // a lot of live objects, not the ones with just a lot of live objects if we


  39 // ordered according to the amount of reclaimable bytes per region.
  40 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {
  41   // Make sure that NULL entries are moved to the end.
  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 
  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 // Determine collection set candidates: For all regions determine whether they
  65 // should be a collection set candidates, calculate their efficiency, sort and
  66 // return them as G1CollectionSetCandidates instance.
  67 // Threads calculate the GC efficiency of the regions they get to process, and
  68 // put them into some work area unsorted. At the end the array is sorted and
  69 // copied into the G1CollectionSetCandidates instance; the caller will be the new
  70 // owner of this object.
  71 class G1BuildCandidateRegionsTask : public AbstractGangTask {
  72 
  73   // Work area for building the set of collection set candidates. Contains references
  74   // to heap regions with their GC efficiencies calculated. To reduce contention
  75   // on claiming array elements, worker threads claim parts of this array in chunks;
  76   // Array elements may be NULL as threads might not get enough regions to fill
  77   // up their chunks completely.
  78   // Final sorting will remove them.
  79   class G1BuildCandidateArray : public StackObj {















  80 
  81     uint const _max_size;
  82     uint const _chunk_size;






























  83 
  84     HeapRegion** _data;






















  85 
  86     uint volatile _cur_claim_idx;










  87 
  88     // Calculates the maximum array size that will be used.
  89     static uint required_array_size(uint num_regions, uint num_workers, uint chunk_size) {
  90       uint const max_waste = num_workers * chunk_size;
  91       // The array should be aligned with respect to chunk_size.
  92       uint const aligned_num_regions = ((num_regions + chunk_size - 1) / chunk_size) * chunk_size;


  93 
  94       return aligned_num_regions + max_waste;
  95     }








  96 
  97   public:
  98     G1BuildCandidateArray(uint max_num_regions, uint num_workers, uint chunk_size) :
  99       _max_size(required_array_size(max_num_regions, num_workers, chunk_size)),
 100       _chunk_size(chunk_size),
 101       _data(NEW_C_HEAP_ARRAY(HeapRegion*, _max_size, mtGC)),
 102       _cur_claim_idx(0) {
 103       for (uint i = 0; i < _max_size; i++) {
 104         _data[i] = NULL;
 105       }
 106     }
 107 
 108     ~G1BuildCandidateArray() {
 109       FREE_C_HEAP_ARRAY(HeapRegion*, _data);
 110     }



 111 
 112     // Claim a new chunk, returning its bounds [from, to[.
 113     void claim_chunk(uint& from, uint& to) {
 114       uint result = Atomic::add(_chunk_size, &_cur_claim_idx);
 115       assert(_max_size > result - 1,
 116              "Array too small, is %u should be %u with chunk size %u.",
 117              _max_size, result, _chunk_size);
 118       from = result - _chunk_size;
 119       to = result;




 120     }

 121 
 122     // Set element in array.
 123     void set(uint idx, HeapRegion* hr) {
 124       assert(idx < _max_size, "Index %u out of bounds %u", idx, _max_size);
 125       assert(_data[idx] == NULL, "Value must not have been set.");
 126       _data[idx] = hr;

 127     }
 128 
 129     void sort_and_copy_into(HeapRegion** dest, uint num_regions) {
 130       if (_cur_claim_idx == 0) {
 131         return;
 132       }
 133       for (uint i = _cur_claim_idx; i < _max_size; i++) {
 134         assert(_data[i] == NULL, "must be");
 135       }
 136       QuickSort::sort(_data, _cur_claim_idx, order_regions, true);
 137       for (uint i = num_regions; i < _max_size; i++) {
 138         assert(_data[i] == NULL, "must be");
 139       }
 140       for (uint i = 0; i < num_regions; i++) {
 141         dest[i] = _data[i];
 142       }
 143     }
 144   };
 145 
 146   // Per-region closure. In addition to determining whether a region should be
 147   // added to the candidates, and calculating those regions' gc efficiencies, also
 148   // gather additional statistics.
 149   class G1BuildCandidateRegionsClosure : public HeapRegionClosure {
 150     G1BuildCandidateArray* _array;

 151 
 152     uint _cur_chunk_idx;
 153     uint _cur_chunk_end;

 154 
 155     uint _regions_added;
 156     size_t _reclaimable_bytes_added;
 157 
 158     void add_region(HeapRegion* hr) {
 159       if (_cur_chunk_idx == _cur_chunk_end) {
 160         _array->claim_chunk(_cur_chunk_idx, _cur_chunk_end);
 161       }
 162       assert(_cur_chunk_idx < _cur_chunk_end, "Must be");
 163 
 164       hr->calc_gc_efficiency();
 165       _array->set(_cur_chunk_idx, hr);
 166 
 167       _cur_chunk_idx++;
 168 
 169       _regions_added++;
 170       _reclaimable_bytes_added += hr->reclaimable_bytes();
 171     }
 172 
 173     bool should_add(HeapRegion* hr) { return CollectionSetChooser::should_add(hr); }
 174 
 175   public:
 176     G1BuildCandidateRegionsClosure(G1BuildCandidateArray* array) :
 177       _array(array),
 178       _cur_chunk_idx(0),
 179       _cur_chunk_end(0),
 180       _regions_added(0),
 181       _reclaimable_bytes_added(0) { }
 182 
 183     bool do_heap_region(HeapRegion* r) {
 184       // We will skip any region that's currently used as an old GC
 185       // alloc region (we should not consider those for collection
 186       // before we fill them up).
 187       if (should_add(r) && !G1CollectedHeap::heap()->is_old_gc_alloc_region(r)) {
 188         add_region(r);
 189       } else if (r->is_old()) {
 190         // Keep remembered sets for humongous regions, otherwise clean out remembered
 191         // sets for old regions.
 192         r->rem_set()->clear(true /* only_cardset */);
 193       } else {
 194         assert(r->is_archive() || !r->is_old() || !r->rem_set()->is_tracked(),
 195                "Missed to clear unused remembered set of region %u (%s) that is %s",
 196                r->hrm_index(), r->get_type_str(), r->rem_set()->get_state_str());
 197       }
 198       return false;
 199     }

 200 
 201     uint regions_added() const { return _regions_added; }
 202     size_t reclaimable_bytes_added() const { return _reclaimable_bytes_added; }
 203   };
 204 
 205   G1CollectedHeap* _g1h;
 206   HeapRegionClaimer _hrclaimer;
 207 
 208   uint volatile _num_regions_added;
 209   size_t volatile _reclaimable_bytes_added;
 210 
 211   G1BuildCandidateArray _result;
 212 
 213   void update_totals(uint num_regions, size_t reclaimable_bytes) {
 214     if (num_regions > 0) {
 215       assert(reclaimable_bytes > 0, "invariant");
 216       Atomic::add(num_regions, &_num_regions_added);
 217       Atomic::add(reclaimable_bytes, &_reclaimable_bytes_added);
 218     } else {
 219       assert(reclaimable_bytes == 0, "invariant");
 220     }
 221   }
 222 
 223 public:
 224   G1BuildCandidateRegionsTask(uint max_num_regions, uint chunk_size, uint num_workers) :
 225     AbstractGangTask("G1 Build Candidate Regions"),
 226     _g1h(G1CollectedHeap::heap()),
 227     _hrclaimer(num_workers),
 228     _num_regions_added(0),
 229     _reclaimable_bytes_added(0),
 230     _result(max_num_regions, chunk_size, num_workers) { }
 231 
 232   void work(uint worker_id) {
 233     G1BuildCandidateRegionsClosure cl(&_result);
 234     _g1h->heap_region_par_iterate_from_worker_offset(&cl, &_hrclaimer, worker_id);
 235     update_totals(cl.regions_added(), cl.reclaimable_bytes_added());
 236   }

 237 
 238   G1CollectionSetCandidates* get_sorted_candidates() {
 239     HeapRegion** regions = NEW_C_HEAP_ARRAY(HeapRegion*, _num_regions_added, mtGC);
 240     _result.sort_and_copy_into(regions, _num_regions_added);
 241     return new G1CollectionSetCandidates(regions,
 242                                          _num_regions_added,
 243                                          _reclaimable_bytes_added);
 244   }
 245 };
 246 
 247 uint CollectionSetChooser::calculate_work_chunk_size(uint num_workers, uint num_regions) {
 248   assert(num_workers > 0, "Active gc workers should be greater than 0");
 249   return MAX2(num_regions / num_workers, 1U);
 250 }
 251 
 252 bool CollectionSetChooser::should_add(HeapRegion* hr) {
 253   return !hr->is_young() &&
 254          !hr->is_pinned() &&
 255          region_occupancy_low_enough_for_evac(hr->live_bytes()) &&
 256          hr->rem_set()->is_complete();
 257 }
 258 
 259 G1CollectionSetCandidates* CollectionSetChooser::build(WorkGang* workers, uint max_num_regions) {
 260   uint num_workers = workers->active_workers();
 261   uint chunk_size = calculate_work_chunk_size(num_workers, max_num_regions);
 262 
 263   G1BuildCandidateRegionsTask cl(max_num_regions, chunk_size, num_workers);
 264   workers->run_task(&cl, num_workers);
 265 
 266   G1CollectionSetCandidates* result = cl.get_sorted_candidates();
 267   result->verify();
 268   return result;


 269 }
< prev index next >