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

   1 /*
   2  * Copyright (c) 2016, 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 #ifndef SHARE_VM_GC_G1_G1COLLECTIONSET_HPP
  26 #define SHARE_VM_GC_G1_G1COLLECTIONSET_HPP
  27 
  28 #include "gc/g1/collectionSetChooser.hpp"
  29 #include "memory/allocation.hpp"
  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 
--- EOF ---