29 #include "utilities/growableArray.hpp"

    29 #include "memory/allocation.hpp"

    30 #include "runtime/globals.hpp"

    31 class CollectionSetChooser: public CHeapObj<mtGC> {

    32 class G1CollectionSetCandidates;

    33 class WorkGang;

    33   GrowableArray<HeapRegion*> _regions;

    35 // Helper class to calculate collection set candidates, and containing some related

    34 

    36 // methods.

    35   // Unfortunately, GrowableArray uses ints for length and indexes. To

    37 class CollectionSetChooser : public AllStatic {

    36   // avoid excessive casting in the rest of the class the following

    38   static uint calculate_work_chunk_size(uint num_workers, uint num_regions);

    37   // wrapper methods are provided that use uints.

    38 

    39   uint regions_length()          { return (uint) _regions.length(); }

    40   HeapRegion* regions_at(uint i) { return _regions.at((int) i);     }

    41   void regions_at_put(uint i, HeapRegion* hr) {

    42     _regions.at_put((int) i, hr);

    43   }

    44   void regions_at_put_grow(uint i, HeapRegion* hr) {

    45     _regions.at_put_grow((int) i, hr);

    46   }

    47   void regions_trunc_to(uint i)  { _regions.trunc_to((uint) i); }

    48 

    49   // The index of the next candidate old region to be considered for

    50   // addition to the CSet.

    51   uint _front;

    52 

    53   // The index of the last candidate old region

    54   uint _end;

    55 

    56   // Keeps track of the start of the next array chunk to be claimed by

    57   // parallel GC workers.

    58   uint _first_par_unreserved_idx;

    59 

    60   // If a region has more live bytes than this threshold, it will not

    61   // be added to the CSet chooser and will not be a candidate for

    62   // collection.

    63   size_t _region_live_threshold_bytes;

    64 

    65   // The sum of reclaimable bytes over all the regions in the CSet chooser.

    66   size_t _remaining_reclaimable_bytes;

    67 

    68   // Calculate and return chunk size (in number of regions) for parallel

    69   // addition of regions

    70   uint calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const;

   108   static bool region_occupancy_low_enough_for_evac(size_t live_bytes);

    45   static bool region_occupancy_low_enough_for_evac(size_t live_bytes) {

    46     return live_bytes < mixed_gc_live_threshold_bytes();

    47   }

   110   void sort_regions();

    49   // Determine whether to add the given region to the collection set candidates or

   111 

   112   // Determine whether to add the given region to the CSet chooser or

   116   bool should_add(HeapRegion* hr) const;

    53   static bool should_add(HeapRegion* hr);

   118   // Returns the number candidate old regions added

    55   // Build and return set of collection set candidates sorted by decreasing gc

   119   uint length() { return _end; }

    56   // efficiency.

   120 

    57   static G1CollectionSetCandidates* build(WorkGang* workers, uint max_num_regions);

   121   // Serial version.

   122   void add_region(HeapRegion *hr);

   123 

   124   // Must be called before calls to claim_array_chunk().

   125   // n_regions is the number of regions, chunk_size the chunk size.

   126   void prepare_for_par_region_addition(uint n_threads, uint n_regions, uint chunk_size);

   127   // Returns the first index in a contiguous chunk of chunk_size indexes

   128   // that the calling thread has reserved.  These must be set by the

   129   // calling thread using set_region() (to NULL if necessary).

   130   uint claim_array_chunk(uint chunk_size);

   131   // Set the marked array entry at index to hr.  Careful to claim the index

   132   // first if in parallel.

   133   void set_region(uint index, HeapRegion* hr);

   134   // Atomically increment the number of added regions by region_num

   135   // and the amount of reclaimable bytes by reclaimable_bytes.

   136   void update_totals(uint region_num, size_t reclaimable_bytes);

   137 

   138   // Iterate over all collection set candidate regions.

   139   void iterate(HeapRegionClosure* cl);

   140 

   141   void clear();

   142 

   143   void rebuild(WorkGang* workers, uint n_regions);

   144 

   145   // Return the number of candidate regions that remain to be collected.

   146   uint remaining_regions() { return _end - _front; }

   147 

   148   // Determine whether the CSet chooser has more candidate regions or not.

   149   bool is_empty() { return remaining_regions() == 0; }

   150 

   151   // Return the reclaimable bytes that remain to be collected on

   152   // all the candidate regions in the CSet chooser.

   153   size_t remaining_reclaimable_bytes() { return _remaining_reclaimable_bytes; }

   154 

   155   // Returns true if the used portion of "_regions" is properly

   156   // sorted, otherwise asserts false.

   157   void verify() PRODUCT_RETURN;

   158 };

   159 

   160 class CSetChooserParUpdater : public StackObj {

   161 private:

   162   CollectionSetChooser* _chooser;

   163   bool _parallel;

   164   uint _chunk_size;

   165   uint _cur_chunk_idx;

   166   uint _cur_chunk_end;

   167   uint _regions_added;

   168   size_t _reclaimable_bytes_added;

   169 

   170 public:

   171   CSetChooserParUpdater(CollectionSetChooser* chooser,

   172                         bool parallel, uint chunk_size) :

   173     _chooser(chooser), _parallel(parallel), _chunk_size(chunk_size),

   174     _cur_chunk_idx(0), _cur_chunk_end(0),

   175     _regions_added(0), _reclaimable_bytes_added(0) { }

   176 

   177   ~CSetChooserParUpdater() {

   178     if (_parallel && _regions_added > 0) {

   179       _chooser->update_totals(_regions_added, _reclaimable_bytes_added);

   180     }

   181   }

   182 

   183   void add_region(HeapRegion* hr) {

   184     if (_parallel) {

   185       if (_cur_chunk_idx == _cur_chunk_end) {

   186         _cur_chunk_idx = _chooser->claim_array_chunk(_chunk_size);

   187         _cur_chunk_end = _cur_chunk_idx + _chunk_size;

   188       }

   189       assert(_cur_chunk_idx < _cur_chunk_end, "invariant");

   190       _chooser->set_region(_cur_chunk_idx, hr);

   191       _cur_chunk_idx += 1;

   192     } else {

   193       _chooser->add_region(hr);

   194     }

   195     _regions_added += 1;

   196     _reclaimable_bytes_added += hr->reclaimable_bytes();

   197   }

   198 

   199   bool should_add(HeapRegion* hr) { return _chooser->should_add(hr); }