< prev index next >

src/share/vm/gc/g1/g1CollectionSet.hpp

Print this page
rev 11552 : imported patch 8159978-collection-set-as-array
rev 11553 : imported patch 8159978-erikh-review
rev 11554 : imported patch 8159978-jmasa-review


  30 #include "utilities/debug.hpp"
  31 #include "utilities/globalDefinitions.hpp"
  32 
  33 class G1CollectedHeap;
  34 class G1CollectorState;
  35 class G1GCPhaseTimes;
  36 class G1Policy;
  37 class G1SurvivorRegions;
  38 class HeapRegion;
  39 
  40 class G1CollectionSet VALUE_OBJ_CLASS_SPEC {
  41   G1CollectedHeap* _g1;
  42   G1Policy* _policy;
  43 
  44   CollectionSetChooser* _cset_chooser;
  45 
  46   uint _eden_region_length;
  47   uint _survivor_region_length;
  48   uint _old_region_length;
  49 
  50   // The head of the list (via "next_in_collection_set()") representing the
  51   // current collection set. Set from the incrementally built collection
  52   // set at the start of the pause.
  53   HeapRegion* _head;





  54 
  55   // The number of bytes in the collection set before the pause. Set from
  56   // the incrementally built collection set at the start of an evacuation
  57   // pause, and incremented in finalize_old_part() when adding old regions
  58   // (if any) to the collection set.
  59   size_t _bytes_used_before;
  60 
  61   size_t _recorded_rs_lengths;
  62 
  63   // The associated information that is maintained while the incremental
  64   // collection set is being built with young regions. Used to populate
  65   // the recorded info for the evacuation pause.
  66 
  67   enum CSetBuildType {
  68     Active,             // We are actively building the collection set
  69     Inactive            // We are not actively building the collection set
  70   };
  71 
  72   CSetBuildType _inc_build_state;
  73 
  74   // The head of the incrementally built collection set.
  75   HeapRegion* _inc_head;
  76 
  77   // The tail of the incrementally built collection set.
  78   HeapRegion* _inc_tail;
  79 
  80   // The number of bytes in the incrementally built collection set.
  81   // Used to set _collection_set_bytes_used_before at the start of
  82   // an evacuation pause.
  83   size_t _inc_bytes_used_before;
  84 
  85   // The RSet lengths recorded for regions in the CSet. It is updated
  86   // by the thread that adds a new region to the CSet. We assume that
  87   // only one thread can be allocating a new CSet region (currently,
  88   // it does so after taking the Heap_lock) hence no need to
  89   // synchronize updates to this field.
  90   size_t _inc_recorded_rs_lengths;
  91 
  92   // A concurrent refinement thread periodically samples the young
  93   // region RSets and needs to update _inc_recorded_rs_lengths as
  94   // the RSets grow. Instead of having to synchronize updates to that
  95   // field we accumulate them in this field and add it to
  96   // _inc_recorded_rs_lengths_diffs at the start of a GC.
  97   ssize_t _inc_recorded_rs_lengths_diffs;
  98 
  99   // The predicted elapsed time it will take to collect the regions in
 100   // the CSet. This is updated by the thread that adds a new region to
 101   // the CSet. See the comment for _inc_recorded_rs_lengths about
 102   // MT-safety assumptions.
 103   double _inc_predicted_elapsed_time_ms;
 104 
 105   // See the comment for _inc_recorded_rs_lengths_diffs.
 106   double _inc_predicted_elapsed_time_ms_diffs;
 107 
 108   uint _inc_region_length;
 109 
 110   G1CollectorState* collector_state();
 111   G1GCPhaseTimes* phase_times();
 112 
 113   double predict_region_elapsed_time_ms(HeapRegion* hr);
 114 
 115   void verify_young_cset_indices() const NOT_DEBUG_RETURN;
 116 public:
 117   G1CollectionSet(G1CollectedHeap* g1h, G1Policy* policy);
 118   ~G1CollectionSet();
 119 



 120   CollectionSetChooser* cset_chooser();
 121 
 122   void init_region_lengths(uint eden_cset_region_length,
 123                            uint survivor_cset_region_length);
 124 
 125   void set_recorded_rs_lengths(size_t rs_lengths);
 126 
 127   uint region_length() const       { return young_region_length() +
 128                                             old_region_length(); }
 129   uint young_region_length() const { return eden_region_length() +
 130                                             survivor_region_length(); }
 131 
 132   uint eden_region_length() const     { return _eden_region_length;     }
 133   uint survivor_region_length() const { return _survivor_region_length; }
 134   uint old_region_length() const      { return _old_region_length;      }
 135 
 136   // Incremental CSet Support
 137 
 138   // The head of the incrementally built collection set.
 139   HeapRegion* inc_head() { return _inc_head; }
 140 
 141   // The tail of the incrementally built collection set.
 142   HeapRegion* inc_tail() { return _inc_tail; }
 143 
 144   // Initialize incremental collection set info.
 145   void start_incremental_building();
 146 
 147   // Perform any final calculations on the incremental CSet fields
 148   // before we can use them.
 149   void finalize_incremental_building();
 150 
 151   void clear_incremental() {
 152     _inc_head = NULL;
 153     _inc_tail = NULL;
 154     _inc_region_length = 0;
 155   }
 156 
 157   // Stop adding regions to the incremental collection set
 158   void stop_incremental_building() { _inc_build_state = Inactive; }
 159 
 160   // The head of the list (via "next_in_collection_set()") representing the
 161   // current collection set.
 162   HeapRegion* head() { return _head; }






 163 
 164   void clear_head() { _head = NULL; }

 165 
 166   size_t recorded_rs_lengths() { return _recorded_rs_lengths; }
 167 
 168   size_t bytes_used_before() const {
 169     return _bytes_used_before;
 170   }
 171 
 172   void reset_bytes_used_before() {
 173     _bytes_used_before = 0;
 174   }
 175 
 176   // Choose a new collection set.  Marks the chosen regions as being
 177   // "in_collection_set", and links them together.  The head and number of
 178   // the collection set are available via access methods.
 179   double finalize_young_part(double target_pause_time_ms, G1SurvivorRegions* survivors);
 180   void finalize_old_part(double time_remaining_ms);
 181 
 182   // Add old region "hr" to the CSet.
 183   void add_old_region(HeapRegion* hr);
 184 
 185   // Update information about hr in the aggregated information for
 186   // the incrementally built collection set.
 187   void update_young_region_prediction(HeapRegion* hr, size_t new_rs_length);
 188 
 189   // Add hr to the LHS of the incremental collection set.
 190   void add_eden_region(HeapRegion* hr);
 191 
 192   // Add hr to the RHS of the incremental collection set.
 193   void add_survivor_regions(HeapRegion* hr);
 194 
 195 #ifndef PRODUCT
 196   void print(HeapRegion* list_head, outputStream* st);


 197 #endif // !PRODUCT
 198 
 199 private:
 200   // Update the incremental cset information when adding a region
 201   // (should not be called directly).
 202   void add_young_region_common(HeapRegion* hr);
 203 
 204 };
 205 
 206 #endif // SHARE_VM_GC_G1_G1COLLECTIONSET_HPP
 207 


  30 #include "utilities/debug.hpp"
  31 #include "utilities/globalDefinitions.hpp"
  32 
  33 class G1CollectedHeap;
  34 class G1CollectorState;
  35 class G1GCPhaseTimes;
  36 class G1Policy;
  37 class G1SurvivorRegions;
  38 class HeapRegion;
  39 
  40 class G1CollectionSet VALUE_OBJ_CLASS_SPEC {
  41   G1CollectedHeap* _g1;
  42   G1Policy* _policy;
  43 
  44   CollectionSetChooser* _cset_chooser;
  45 
  46   uint _eden_region_length;
  47   uint _survivor_region_length;
  48   uint _old_region_length;
  49 
  50   // The actual collection set as a set of region indices.
  51   // All entries in _collection_set_regions below _collection_set_cur_length are
  52   // assumed to be valid entries.
  53   // We assume that at any time there is at most only one writer and (one or more)
  54   // concurrent readers. This means we are good with using storestore and loadload
  55   // barriers on the writer and reader respectively only.
  56   uint* _collection_set_regions;
  57   volatile size_t _collection_set_cur_length;
  58   size_t _collection_set_max_length;
  59 
  60   // The number of bytes in the collection set before the pause. Set from
  61   // the incrementally built collection set at the start of an evacuation
  62   // pause, and incremented in finalize_old_part() when adding old regions
  63   // (if any) to the collection set.
  64   size_t _bytes_used_before;
  65 
  66   size_t _recorded_rs_lengths;
  67 
  68   // The associated information that is maintained while the incremental
  69   // collection set is being built with young regions. Used to populate
  70   // the recorded info for the evacuation pause.
  71 
  72   enum CSetBuildType {
  73     Active,             // We are actively building the collection set
  74     Inactive            // We are not actively building the collection set
  75   };
  76 
  77   CSetBuildType _inc_build_state;
  78  






  79   // The number of bytes in the incrementally built collection set.
  80   // Used to set _collection_set_bytes_used_before at the start of
  81   // an evacuation pause.
  82   size_t _inc_bytes_used_before;
  83 
  84   // The RSet lengths recorded for regions in the CSet. It is updated
  85   // by the thread that adds a new region to the CSet. We assume that
  86   // only one thread can be allocating a new CSet region (currently,
  87   // it does so after taking the Heap_lock) hence no need to
  88   // synchronize updates to this field.
  89   size_t _inc_recorded_rs_lengths;
  90 
  91   // A concurrent refinement thread periodically samples the young
  92   // region RSets and needs to update _inc_recorded_rs_lengths as
  93   // the RSets grow. Instead of having to synchronize updates to that
  94   // field we accumulate them in this field and add it to
  95   // _inc_recorded_rs_lengths_diffs at the start of a GC.
  96   ssize_t _inc_recorded_rs_lengths_diffs;
  97 
  98   // The predicted elapsed time it will take to collect the regions in
  99   // the CSet. This is updated by the thread that adds a new region to
 100   // the CSet. See the comment for _inc_recorded_rs_lengths about
 101   // MT-safety assumptions.
 102   double _inc_predicted_elapsed_time_ms;
 103 
 104   // See the comment for _inc_recorded_rs_lengths_diffs.
 105   double _inc_predicted_elapsed_time_ms_diffs;
 106 


 107   G1CollectorState* collector_state();
 108   G1GCPhaseTimes* phase_times();
 109 
 110   double predict_region_elapsed_time_ms(HeapRegion* hr);
 111 
 112   void verify_young_cset_indices() const NOT_DEBUG_RETURN;
 113 public:
 114   G1CollectionSet(G1CollectedHeap* g1h, G1Policy* policy);
 115   ~G1CollectionSet();
 116 
 117   // Initializes the collection set giving the maximum possible length of the collection set.
 118   void initialize(uint max_region_length);
 119 
 120   CollectionSetChooser* cset_chooser();
 121 
 122   void init_region_lengths(uint eden_cset_region_length,
 123                            uint survivor_cset_region_length);
 124 
 125   void set_recorded_rs_lengths(size_t rs_lengths);
 126 
 127   uint region_length() const       { return young_region_length() +
 128                                             old_region_length(); }
 129   uint young_region_length() const { return eden_region_length() +
 130                                             survivor_region_length(); }
 131 
 132   uint eden_region_length() const     { return _eden_region_length;     }
 133   uint survivor_region_length() const { return _survivor_region_length; }
 134   uint old_region_length() const      { return _old_region_length;      }
 135 
 136   // Incremental collection set support






 137 
 138   // Initialize incremental collection set info.
 139   void start_incremental_building();
 140 
 141   // Perform any final calculations on the incremental collection set fields
 142   // before we can use them.
 143   void finalize_incremental_building();
 144 
 145   // Reset the contents of the collection set.
 146   void clear();






 147 
 148   // Iterate over the collection set, applying the given HeapRegionClosure on all of them.
 149   // If may_be_aborted is true, iteration may be aborted using the return value of the
 150   // called closure method.
 151   void iterate(HeapRegionClosure* cl) const;
 152 
 153   // Iterate over the collection set, applying the given HeapRegionClosure on all of them,
 154   // trying to optimally spread out starting position of total_workers workers given the
 155   // caller's worker_id.
 156   void iterate_from(HeapRegionClosure* cl, uint worker_id, uint total_workers) const;
 157   
 158   // Stop adding regions to the incremental collection set.
 159   void stop_incremental_building() { _inc_build_state = Inactive; }
 160 
 161   size_t recorded_rs_lengths() { return _recorded_rs_lengths; }
 162 
 163   size_t bytes_used_before() const {
 164     return _bytes_used_before;
 165   }
 166 
 167   void reset_bytes_used_before() {
 168     _bytes_used_before = 0;
 169   }
 170 
 171   // Choose a new collection set.  Marks the chosen regions as being
 172   // "in_collection_set".

 173   double finalize_young_part(double target_pause_time_ms, G1SurvivorRegions* survivors);
 174   void finalize_old_part(double time_remaining_ms);
 175 
 176   // Add old region "hr" to the collection set.
 177   void add_old_region(HeapRegion* hr);
 178 
 179   // Update information about hr in the aggregated information for
 180   // the incrementally built collection set.
 181   void update_young_region_prediction(HeapRegion* hr, size_t new_rs_length);
 182 
 183   // Add eden region to the collection set.
 184   void add_eden_region(HeapRegion* hr);
 185 
 186   // Add survivor region to the collection set.
 187   void add_survivor_regions(HeapRegion* hr);
 188 
 189 #ifndef PRODUCT
 190   bool verify_young_ages();
 191 
 192   void print(outputStream* st);
 193 #endif // !PRODUCT
 194 
 195 private:
 196   // Update the incremental collection set information when adding a region.

 197   void add_young_region_common(HeapRegion* hr);

 198 };
 199 
 200 #endif // SHARE_VM_GC_G1_G1COLLECTIONSET_HPP
 201 
< prev index next >