1 /*

     2  * Copyright (c) 2016, 2017, 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_G1DEFAULTPOLICY_HPP

    26 #define SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP

    27 

    28 #include "gc/g1/g1CollectorState.hpp"

    29 #include "gc/g1/g1GCPhaseTimes.hpp"

    30 #include "gc/g1/g1InCSetState.hpp"

    31 #include "gc/g1/g1InitialMarkToMixedTimeTracker.hpp"

    32 #include "gc/g1/g1MMUTracker.hpp"

    33 #include "gc/g1/g1Predictions.hpp"

    34 #include "gc/g1/g1Policy.hpp"

    35 #include "gc/g1/g1YoungGenSizer.hpp"

    36 #include "gc/shared/gcCause.hpp"

    37 #include "utilities/pair.hpp"

    38 

    39 class HeapRegion;

    40 class G1CollectionSet;

    41 class CollectionSetChooser;

    42 class G1IHOPControl;

    43 class G1Analytics;

    44 class G1SurvivorRegions;

    45 class G1YoungGenSizer;

    46 class GCPolicyCounters;

    47 class STWGCTimer;

    48 

    49 class G1DefaultPolicy: public G1Policy {

    50  private:

    51 

    52   static G1IHOPControl* create_ihop_control(const G1Predictions* predictor);

    53   // Update the IHOP control with necessary statistics.

    54   void update_ihop_prediction(double mutator_time_s,

    55                               size_t mutator_alloc_bytes,

    56                               size_t young_gen_size);

    57   void report_ihop_statistics();

    58 

    59   G1Predictions _predictor;

    60   G1Analytics* _analytics;

    61   G1MMUTracker* _mmu_tracker;

    62   G1IHOPControl* _ihop_control;

    63 

    64   GCPolicyCounters* _policy_counters;

    65 

    66   double _full_collection_start_sec;

    67 

    68   jlong _collection_pause_end_millis;

    69 

    70   uint _young_list_target_length;

    71   uint _young_list_fixed_length;

    72 

    73   // The max number of regions we can extend the eden by while the GC

    74   // locker is active. This should be >= _young_list_target_length;

    75   uint _young_list_max_length;

    76 

    77   // SurvRateGroups below must be initialized after the predictor because they

    78   // indirectly use it through this object passed to their constructor.

    79   SurvRateGroup* _short_lived_surv_rate_group;

    80   SurvRateGroup* _survivor_surv_rate_group;

    81 

    82   double _reserve_factor;

    83   // This will be set when the heap is expanded

    84   // for the first time during initialization.

    85   uint   _reserve_regions;

    86 

    87   G1YoungGenSizer _young_gen_sizer;

    88 

    89   uint _free_regions_at_end_of_collection;

    90 

    91   size_t _max_rs_lengths;

    92 

    93   size_t _rs_lengths_prediction;

    94 

    95   size_t _pending_cards;

    96 

    97   // The amount of allocated bytes in old gen during the last mutator and the following

    98   // young GC phase.

    99   size_t _bytes_allocated_in_old_since_last_gc;

   100 

   101   G1InitialMarkToMixedTimeTracker _initial_mark_to_mixed;

   102 public:

   103   const G1Predictions& predictor() const { return _predictor; }

   104   const G1Analytics* analytics()   const { return const_cast<const G1Analytics*>(_analytics); }

   105 

   106   void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }

   107 

   108   void set_region_eden(HeapRegion* hr) {

   109     hr->set_eden();

   110     hr->install_surv_rate_group(_short_lived_surv_rate_group);

   111   }

   112 

   113   void set_region_survivor(HeapRegion* hr) {

   114     assert(hr->is_survivor(), "pre-condition");

   115     hr->install_surv_rate_group(_survivor_surv_rate_group);

   116   }

   117 

   118   void record_max_rs_lengths(size_t rs_lengths) {

   119     _max_rs_lengths = rs_lengths;

   120   }

   121 

   122 

   123   double predict_base_elapsed_time_ms(size_t pending_cards) const;

   124   double predict_base_elapsed_time_ms(size_t pending_cards,

   125                                       size_t scanned_cards) const;

   126   size_t predict_bytes_to_copy(HeapRegion* hr) const;

   127   double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const;

   128 

   129   double predict_survivor_regions_evac_time() const;

   130 

   131   bool should_update_surv_rate_group_predictors() {

   132     return collector_state()->last_gc_was_young() && !collector_state()->in_marking_window();

   133   }

   134 

   135   void cset_regions_freed() {

   136     bool update = should_update_surv_rate_group_predictors();

   137 

   138     _short_lived_surv_rate_group->all_surviving_words_recorded(predictor(), update);

   139     _survivor_surv_rate_group->all_surviving_words_recorded(predictor(), update);

   140   }

   141 

   142   G1MMUTracker* mmu_tracker() {

   143     return _mmu_tracker;

   144   }

   145 

   146   const G1MMUTracker* mmu_tracker() const {

   147     return _mmu_tracker;

   148   }

   149 

   150   double max_pause_time_ms() const {

   151     return _mmu_tracker->max_gc_time() * 1000.0;

   152   }

   153 

   154   double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const;

   155 

   156   double predict_yg_surv_rate(int age) const;

   157 

   158   double accum_yg_surv_rate_pred(int age) const;

   159 

   160 protected:

   161   G1CollectionSet* _collection_set;

   162   virtual double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;

   163   virtual double other_time_ms(double pause_time_ms) const;

   164 

   165   double young_other_time_ms() const;

   166   double non_young_other_time_ms() const;

   167   double constant_other_time_ms(double pause_time_ms) const;

   168 

   169   CollectionSetChooser* cset_chooser() const;

   170 private:

   171 

   172   // The number of bytes copied during the GC.

   173   size_t _bytes_copied_during_gc;

   174 

   175   // Stash a pointer to the g1 heap.

   176   G1CollectedHeap* _g1;

   177 

   178   G1GCPhaseTimes* _phase_times;

   179 

   180   // This set of variables tracks the collector efficiency, in order to

   181   // determine whether we should initiate a new marking.

   182   double _mark_remark_start_sec;

   183   double _mark_cleanup_start_sec;

   184 

   185   // Updates the internal young list maximum and target lengths. Returns the

   186   // unbounded young list target length.

   187   uint update_young_list_max_and_target_length();

   188   uint update_young_list_max_and_target_length(size_t rs_lengths);

   189 

   190   // Update the young list target length either by setting it to the

   191   // desired fixed value or by calculating it using G1's pause

   192   // prediction model. If no rs_lengths parameter is passed, predict

   193   // the RS lengths using the prediction model, otherwise use the

   194   // given rs_lengths as the prediction.

   195   // Returns the unbounded young list target length.

   196   uint update_young_list_target_length(size_t rs_lengths);

   197 

   198   // Calculate and return the minimum desired young list target

   199   // length. This is the minimum desired young list length according

   200   // to the user's inputs.

   201   uint calculate_young_list_desired_min_length(uint base_min_length) const;

   202 

   203   // Calculate and return the maximum desired young list target

   204   // length. This is the maximum desired young list length according

   205   // to the user's inputs.

   206   uint calculate_young_list_desired_max_length() const;

   207 

   208   // Calculate and return the maximum young list target length that

   209   // can fit into the pause time goal. The parameters are: rs_lengths

   210   // represent the prediction of how large the young RSet lengths will

   211   // be, base_min_length is the already existing number of regions in

   212   // the young list, min_length and max_length are the desired min and

   213   // max young list length according to the user's inputs.

   214   uint calculate_young_list_target_length(size_t rs_lengths,

   215                                           uint base_min_length,

   216                                           uint desired_min_length,

   217                                           uint desired_max_length) const;

   218 

   219   // Result of the bounded_young_list_target_length() method, containing both the

   220   // bounded as well as the unbounded young list target lengths in this order.

   221   typedef Pair<uint, uint, StackObj> YoungTargetLengths;

   222   YoungTargetLengths young_list_target_lengths(size_t rs_lengths) const;

   223 

   224   void update_rs_lengths_prediction();

   225   void update_rs_lengths_prediction(size_t prediction);

   226 

   227   // Check whether a given young length (young_length) fits into the

   228   // given target pause time and whether the prediction for the amount

   229   // of objects to be copied for the given length will fit into the

   230   // given free space (expressed by base_free_regions).  It is used by

   231   // calculate_young_list_target_length().

   232   bool predict_will_fit(uint young_length, double base_time_ms,

   233                         uint base_free_regions, double target_pause_time_ms) const;

   234 

   235 public:

   236   size_t pending_cards() const { return _pending_cards; }

   237 

   238   uint calc_min_old_cset_length() const;

   239   uint calc_max_old_cset_length() const;

   240 

   241   // Returns the given amount of reclaimable bytes (that represents

   242   // the amount of reclaimable space still to be collected) as a

   243   // percentage of the current heap capacity.

   244   double reclaimable_bytes_percent(size_t reclaimable_bytes) const;

   245 

   246   jlong collection_pause_end_millis() { return _collection_pause_end_millis; }

   247 

   248 private:

   249   // Sets up marking if proper conditions are met.

   250   void maybe_start_marking();

   251 

   252   // The kind of STW pause.

   253   enum PauseKind {

   254     FullGC,

   255     YoungOnlyGC,

   256     MixedGC,

   257     LastYoungGC,

   258     InitialMarkGC,

   259     Cleanup,

   260     Remark

   261   };

   262 

   263   // Calculate PauseKind from internal state.

   264   PauseKind young_gc_pause_kind() const;

   265   // Record the given STW pause with the given start and end times (in s).

   266   void record_pause(PauseKind kind, double start, double end);

   267   // Indicate that we aborted marking before doing any mixed GCs.

   268   void abort_time_to_mixed_tracking();

   269 public:

   270 

   271   G1DefaultPolicy(STWGCTimer* gc_timer);

   272 

   273   virtual ~G1DefaultPolicy();

   274 

   275   G1CollectorState* collector_state() const;

   276 

   277   G1GCPhaseTimes* phase_times() const { return _phase_times; }

   278 

   279   void revise_young_list_target_length_if_necessary(size_t rs_lengths);

   280 

   281   void record_new_heap_size(uint new_number_of_regions);

   282 

   283   void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set);

   284 

   285   virtual void note_gc_start();

   286 

   287   bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0);

   288 

   289   bool about_to_start_mixed_phase() const;

   290 

   291   void record_collection_pause_start(double start_time_sec);

   292   void record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc);

   293 

   294   void record_full_collection_start();

   295   void record_full_collection_end();

   296 

   297   void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);

   298 

   299   void record_concurrent_mark_remark_start();

   300   void record_concurrent_mark_remark_end();

   301 

   302   void record_concurrent_mark_cleanup_start();

   303   void record_concurrent_mark_cleanup_end();

   304   void record_concurrent_mark_cleanup_completed();

   305 

   306   virtual void print_phases();

   307 

   308   void record_bytes_copied_during_gc(size_t bytes) {

   309     _bytes_copied_during_gc += bytes;

   310   }

   311 

   312   size_t bytes_copied_during_gc() const {

   313     return _bytes_copied_during_gc;

   314   }

   315 

   316   bool next_gc_should_be_mixed(const char* true_action_str,

   317                                const char* false_action_str) const;

   318 

   319   virtual void finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor);

   320 private:

   321   // Set the state to start a concurrent marking cycle and clear

   322   // _initiate_conc_mark_if_possible because it has now been

   323   // acted on.

   324   void initiate_conc_mark();

   325 

   326 public:

   327   bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);

   328 

   329   void decide_on_conc_mark_initiation();

   330 

   331   void finished_recalculating_age_indexes(bool is_survivors) {

   332     if (is_survivors) {

   333       _survivor_surv_rate_group->finished_recalculating_age_indexes();

   334     } else {

   335       _short_lived_surv_rate_group->finished_recalculating_age_indexes();

   336     }

   337   }

   338 

   339   size_t young_list_target_length() const { return _young_list_target_length; }

   340 

   341   bool should_allocate_mutator_region() const;

   342 

   343   bool can_expand_young_list() const;

   344 

   345   uint young_list_max_length() const {

   346     return _young_list_max_length;

   347   }

   348 

   349   bool adaptive_young_list_length() const;

   350 

   351   virtual bool should_process_references() const {

   352     return true;

   353   }

   354 

   355   void transfer_survivors_to_cset(const G1SurvivorRegions* survivors);

   356 

   357 private:

   358   //

   359   // Survivor regions policy.

   360   //

   361 

   362   // Current tenuring threshold, set to 0 if the collector reaches the

   363   // maximum amount of survivors regions.

   364   uint _tenuring_threshold;

   365 

   366   // The limit on the number of regions allocated for survivors.

   367   uint _max_survivor_regions;

   368 

   369   AgeTable _survivors_age_table;

   370 

   371 protected:

   372   size_t desired_survivor_size() const;

   373 public:

   374   uint tenuring_threshold() const { return _tenuring_threshold; }

   375 

   376   uint max_survivor_regions() {

   377     return _max_survivor_regions;

   378   }

   379 

   380   void note_start_adding_survivor_regions() {

   381     _survivor_surv_rate_group->start_adding_regions();

   382   }

   383 

   384   void note_stop_adding_survivor_regions() {

   385     _survivor_surv_rate_group->stop_adding_regions();

   386   }

   387 

   388   void record_age_table(AgeTable* age_table) {

   389     _survivors_age_table.merge(age_table);

   390   }

   391 

   392   void print_age_table();

   393 

   394   void update_max_gc_locker_expansion();

   395 

   396   void update_survivors_policy();

   397 };

   398 

   399 #endif // SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP