8236073: G1: Use SoftMaxHeapSize to guide GC heuristics

          --- old/src/hotspot/share/gc/g1/g1Policy.hpp
          +++ new/src/hotspot/share/gc/g1/g1Policy.hpp

   1    1  /*
   2    2   * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *
  23   23   */
  24   24  
  25   25  #ifndef SHARE_GC_G1_G1POLICY_HPP
  26   26  #define SHARE_GC_G1_G1POLICY_HPP
  27   27  
  28   28  #include "gc/g1/g1CollectorState.hpp"
  29   29  #include "gc/g1/g1GCPhaseTimes.hpp"
  30   30  #include "gc/g1/g1HeapRegionAttr.hpp"
  31   31  #include "gc/g1/g1InitialMarkToMixedTimeTracker.hpp"
  32   32  #include "gc/g1/g1MMUTracker.hpp"
  33   33  #include "gc/g1/g1RemSetTrackingPolicy.hpp"
  34   34  #include "gc/g1/g1Predictions.hpp"
  35   35  #include "gc/g1/g1YoungGenSizer.hpp"
  36   36  #include "gc/shared/gcCause.hpp"
  37   37  #include "utilities/pair.hpp"

  38   38  
  39   39  // A G1Policy makes policy decisions that determine the
  40   40  // characteristics of the collector.  Examples include:
  41   41  //   * choice of collection set.
  42   42  //   * when to collect.
  43   43  
  44   44  class HeapRegion;
  45   45  class G1CollectionSet;
  46   46  class G1CollectionSetCandidates;
  47   47  class G1CollectionSetChooser;
       48 +class G1HeapSizingPolicy;
  48   49  class G1IHOPControl;
  49   50  class G1Analytics;
  50   51  class G1SurvivorRegions;
  51   52  class G1YoungGenSizer;
  52   53  class GCPolicyCounters;
  53   54  class STWGCTimer;
  54   55  
  55   56  class G1Policy: public CHeapObj<mtGC> {
       57 + friend class G1HeapSizingPolicy;
  56   58   private:
  57   59  
  58   60    static G1IHOPControl* create_ihop_control(const G1Predictions* predictor);
  59   61    // Update the IHOP control with necessary statistics.
  60   62    void update_ihop_prediction(double mutator_time_s,
  61   63                                size_t mutator_alloc_bytes,
  62   64                                size_t young_gen_size,
  63   65                                bool this_gc_was_young_only);
  64   66    void report_ihop_statistics();
  65   67  

  66   68    G1Predictions _predictor;
  67   69    G1Analytics* _analytics;
  68   70    G1RemSetTrackingPolicy _remset_tracker;
  69   71    G1MMUTracker* _mmu_tracker;
  70   72    G1IHOPControl* _ihop_control;
  71   73  
  72   74    GCPolicyCounters* _policy_counters;
  73   75  
  74   76    double _full_collection_start_sec;
  75   77  
  76   78    jlong _collection_pause_end_millis;
  77   79  
  78   80    uint _young_list_target_length;
  79   81    uint _young_list_fixed_length;
  80   82  
  81   83    // The max number of regions we can extend the eden by while the GC
  82   84    // locker is active. This should be >= _young_list_target_length;
  83   85    uint _young_list_max_length;
  84   86  
  85   87    // The survivor rate groups below must be initialized after the predictor because they
  86   88    // indirectly use it through the "this" object passed to their constructor.
  87   89    G1SurvRateGroup* _eden_surv_rate_group;
  88   90    G1SurvRateGroup* _survivor_surv_rate_group;
  89   91  
  90   92    double _reserve_factor;
  91   93    // This will be set when the heap is expanded
  92   94    // for the first time during initialization.
  93   95    uint   _reserve_regions;
  94   96  
  95   97    G1YoungGenSizer* _young_gen_sizer;
  96   98  
  97   99    uint _free_regions_at_end_of_collection;
  98  100  
  99  101    size_t _rs_length;
 100  102  
 101  103    size_t _rs_length_prediction;
 102  104  
 103  105    size_t _pending_cards_at_gc_start;
 104  106    size_t _pending_cards_at_prev_gc_end;
 105  107    size_t _total_mutator_refined_cards;
 106  108    size_t _total_concurrent_refined_cards;
 107  109    Tickspan _total_concurrent_refinement_time;
 108  110  
 109  111    // The amount of allocated bytes in old gen during the last mutator and the following
 110  112    // young GC phase.
 111  113    size_t _bytes_allocated_in_old_since_last_gc;
 112  114  
 113  115    G1InitialMarkToMixedTimeTracker _initial_mark_to_mixed;
 114  116  
 115  117    bool should_update_surv_rate_group_predictors() {
 116  118      return collector_state()->in_young_only_phase() && !collector_state()->mark_or_rebuild_in_progress();
 117  119    }
 118  120  
 119  121    double logged_cards_processing_time() const;
 120  122  public:
 121  123    const G1Predictions& predictor() const { return _predictor; }
 122  124    const G1Analytics* analytics()   const { return const_cast<const G1Analytics*>(_analytics); }
 123  125  
 124  126    G1RemSetTrackingPolicy* remset_tracker() { return &_remset_tracker; }
 125  127  
 126  128    // Add the given number of bytes to the total number of allocated bytes in the old gen.
 127  129    void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }
 128  130  
 129  131    void set_region_eden(HeapRegion* hr) {
 130  132      hr->set_eden();
 131  133      hr->install_surv_rate_group(_eden_surv_rate_group);
 132  134    }
 133  135  
 134  136    void set_region_survivor(HeapRegion* hr) {
 135  137      assert(hr->is_survivor(), "pre-condition");
 136  138      hr->install_surv_rate_group(_survivor_surv_rate_group);
 137  139    }
 138  140  
 139  141    void record_rs_length(size_t rs_length) {
 140  142      _rs_length = rs_length;
 141  143    }
 142  144  
 143  145    double predict_base_elapsed_time_ms(size_t num_pending_cards) const;
 144  146  
 145  147  private:
 146  148    double predict_base_elapsed_time_ms(size_t num_pending_cards, size_t rs_length) const;
 147  149  
 148  150    double predict_region_copy_time_ms(HeapRegion* hr) const;
 149  151  
 150  152  public:
 151  153  
 152  154    double predict_eden_copy_time_ms(uint count, size_t* bytes_to_copy = NULL) const;
 153  155    double predict_region_non_copy_time_ms(HeapRegion* hr, bool for_young_gc) const;
 154  156    double predict_region_total_time_ms(HeapRegion* hr, bool for_young_gc) const;
 155  157  
 156  158    void cset_regions_freed() {
 157  159      bool update = should_update_surv_rate_group_predictors();
 158  160  
 159  161      _eden_surv_rate_group->all_surviving_words_recorded(predictor(), update);
 160  162      _survivor_surv_rate_group->all_surviving_words_recorded(predictor(), update);
 161  163    }
 162  164  
 163  165    G1MMUTracker* mmu_tracker() {
 164  166      return _mmu_tracker;
 165  167    }
 166  168  
 167  169    const G1MMUTracker* mmu_tracker() const {
 168  170      return _mmu_tracker;
 169  171    }
 170  172  
 171  173    double max_pause_time_ms() const {
 172  174      return _mmu_tracker->max_gc_time() * 1000.0;
 173  175    }
 174  176  
 175  177  private:
 176  178    G1CollectionSet* _collection_set;
 177  179    double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;
 178  180    double other_time_ms(double pause_time_ms) const;
 179  181  
 180  182    double young_other_time_ms() const;
 181  183    double non_young_other_time_ms() const;
 182  184    double constant_other_time_ms(double pause_time_ms) const;
 183  185  
 184  186    G1CollectionSetChooser* cset_chooser() const;
 185  187  
 186  188    // Stash a pointer to the g1 heap.
 187  189    G1CollectedHeap* _g1h;
 188  190  
 189  191    G1GCPhaseTimes* _phase_times;
 190  192  
 191  193    // This set of variables tracks the collector efficiency, in order to
 192  194    // determine whether we should initiate a new marking.
 193  195    double _mark_remark_start_sec;
 194  196    double _mark_cleanup_start_sec;
 195  197  
 196  198    // Updates the internal young list maximum and target lengths. Returns the
 197  199    // unbounded young list target length. If no rs_length parameter is passed,
 198  200    // predict the RS length using the prediction model, otherwise use the
 199  201    // given rs_length as the prediction.
 200  202    uint update_young_list_max_and_target_length();
 201  203    uint update_young_list_max_and_target_length(size_t rs_length);
 202  204  
 203  205    // Update the young list target length either by setting it to the
 204  206    // desired fixed value or by calculating it using G1's pause
 205  207    // prediction model.
 206  208    // Returns the unbounded young list target length.
 207  209    uint update_young_list_target_length(size_t rs_length);
 208  210  
 209  211    // Calculate and return the minimum desired young list target
 210  212    // length. This is the minimum desired young list length according
 211  213    // to the user's inputs.
 212  214    uint calculate_young_list_desired_min_length(uint base_min_length) const;
 213  215  
 214  216    // Calculate and return the maximum desired young list target
 215  217    // length. This is the maximum desired young list length according
 216  218    // to the user's inputs.
 217  219    uint calculate_young_list_desired_max_length() const;
 218  220  
 219  221    // Calculate and return the maximum young list target length that
 220  222    // can fit into the pause time goal. The parameters are: rs_length
 221  223    // represent the prediction of how large the young RSet lengths will
 222  224    // be, base_min_length is the already existing number of regions in
 223  225    // the young list, min_length and max_length are the desired min and
 224  226    // max young list length according to the user's inputs.
 225  227    uint calculate_young_list_target_length(size_t rs_length,
 226  228                                            uint base_min_length,
 227  229                                            uint desired_min_length,
 228  230                                            uint desired_max_length) const;
 229  231  
 230  232    // Result of the bounded_young_list_target_length() method, containing both the
 231  233    // bounded as well as the unbounded young list target lengths in this order.
 232  234    typedef Pair<uint, uint, StackObj> YoungTargetLengths;
 233  235    YoungTargetLengths young_list_target_lengths(size_t rs_length) const;
 234  236  
 235  237    void update_rs_length_prediction();
 236  238    void update_rs_length_prediction(size_t prediction);
 237  239  
 238  240    size_t predict_bytes_to_copy(HeapRegion* hr) const;
 239  241    double predict_survivor_regions_evac_time() const;
 240  242  
 241  243    // Check whether a given young length (young_length) fits into the
 242  244    // given target pause time and whether the prediction for the amount
 243  245    // of objects to be copied for the given length will fit into the
 244  246    // given free space (expressed by base_free_regions).  It is used by
 245  247    // calculate_young_list_target_length().
 246  248    bool predict_will_fit(uint young_length, double base_time_ms,
 247  249                          uint base_free_regions, double target_pause_time_ms) const;
 248  250  
 249  251  public:
 250  252    size_t pending_cards_at_gc_start() const { return _pending_cards_at_gc_start; }
 251  253  
 252  254    // Calculate the minimum number of old regions we'll add to the CSet
 253  255    // during a mixed GC.
 254  256    uint calc_min_old_cset_length() const;
 255  257  
 256  258    // Calculate the maximum number of old regions we'll add to the CSet
 257  259    // during a mixed GC.
 258  260    uint calc_max_old_cset_length() const;
 259  261  
 260  262    // Returns the given amount of reclaimable bytes (that represents
 261  263    // the amount of reclaimable space still to be collected) as a
 262  264    // percentage of the current heap capacity.
 263  265    double reclaimable_bytes_percent(size_t reclaimable_bytes) const;
 264  266  
 265  267    jlong collection_pause_end_millis() { return _collection_pause_end_millis; }
 266  268  
 267  269  private:
 268  270    void clear_collection_set_candidates();
 269  271    // Sets up marking if proper conditions are met.
 270  272    void maybe_start_marking();
 271  273  
 272  274    // The kind of STW pause.
 273  275    enum PauseKind {
 274  276      FullGC,
 275  277      YoungOnlyGC,
 276  278      MixedGC,
 277  279      LastYoungGC,
 278  280      InitialMarkGC,
 279  281      Cleanup,
 280  282      Remark
 281  283    };
 282  284  
 283  285    // Calculate PauseKind from internal state.
 284  286    PauseKind young_gc_pause_kind() const;
 285  287    // Record the given STW pause with the given start and end times (in s).
 286  288    void record_pause(PauseKind kind, double start, double end);
 287  289    // Indicate that we aborted marking before doing any mixed GCs.
 288  290    void abort_time_to_mixed_tracking();
 289  291  
 290  292    void record_concurrent_refinement_data(bool is_full_collection);
 291  293  
 292  294  public:
 293  295  
 294  296    G1Policy(STWGCTimer* gc_timer);
 295  297  
 296  298    virtual ~G1Policy();
 297  299  
 298  300    static G1Policy* create_policy(STWGCTimer* gc_timer_stw);
 299  301  
 300  302    G1CollectorState* collector_state() const;
 301  303  
 302  304    G1GCPhaseTimes* phase_times() const { return _phase_times; }
 303  305  
 304  306    // Check the current value of the young list RSet length and
 305  307    // compare it against the last prediction. If the current value is
 306  308    // higher, recalculate the young list target length prediction.
 307  309    void revise_young_list_target_length_if_necessary(size_t rs_length);
 308  310  
 309  311    // This should be called after the heap is resized.
 310  312    void record_new_heap_size(uint new_number_of_regions);
 311  313  
 312  314    virtual void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set);
 313  315  
 314  316    void note_gc_start();
 315  317  
 316  318    bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0);
 317  319  
 318  320    bool about_to_start_mixed_phase() const;
 319  321  
 320  322    // Record the start and end of an evacuation pause.
 321  323    void record_collection_pause_start(double start_time_sec);
 322  324    virtual void record_collection_pause_end(double pause_time_ms);
 323  325  
 324  326    // Record the start and end of a full collection.
 325  327    void record_full_collection_start();
 326  328    virtual void record_full_collection_end();
 327  329  
 328  330    // Must currently be called while the world is stopped.
 329  331    void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
 330  332  
 331  333    // Record start and end of remark.
 332  334    void record_concurrent_mark_remark_start();
 333  335    void record_concurrent_mark_remark_end();
 334  336  
 335  337    // Record start, end, and completion of cleanup.
 336  338    void record_concurrent_mark_cleanup_start();
 337  339    void record_concurrent_mark_cleanup_end();
 338  340  
 339  341    void print_phases();
 340  342  
 341  343    bool next_gc_should_be_mixed(const char* true_action_str,
 342  344                                 const char* false_action_str) const;
 343  345  
 344  346    // Calculate and return the number of initial and optional old gen regions from
 345  347    // the given collection set candidates and the remaining time.
 346  348    void calculate_old_collection_set_regions(G1CollectionSetCandidates* candidates,
 347  349                                              double time_remaining_ms,
 348  350                                              uint& num_initial_regions,
 349  351                                              uint& num_optional_regions);
 350  352  
 351  353    // Calculate the number of optional regions from the given collection set candidates,
 352  354    // the remaining time and the maximum number of these regions and return the number
 353  355    // of actually selected regions in num_optional_regions.
 354  356    void calculate_optional_collection_set_regions(G1CollectionSetCandidates* candidates,
 355  357                                                   uint const max_optional_regions,
 356  358                                                   double time_remaining_ms,
 357  359                                                   uint& num_optional_regions);
 358  360  
 359  361  private:
 360  362    // Set the state to start a concurrent marking cycle and clear
 361  363    // _initiate_conc_mark_if_possible because it has now been
 362  364    // acted on.
 363  365    void initiate_conc_mark();
 364  366  
 365  367  public:
 366  368    // This sets the initiate_conc_mark_if_possible() flag to start a
 367  369    // new cycle, as long as we are not already in one. It's best if it
 368  370    // is called during a safepoint when the test whether a cycle is in
 369  371    // progress or not is stable.
 370  372    bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);
 371  373  
 372  374    // This is called at the very beginning of an evacuation pause (it
 373  375    // has to be the first thing that the pause does). If
 374  376    // initiate_conc_mark_if_possible() is true, and the concurrent
 375  377    // marking thread has completed its work during the previous cycle,
 376  378    // it will set in_initial_mark_gc() to so that the pause does
 377  379    // the initial-mark work and start a marking cycle.
 378  380    void decide_on_conc_mark_initiation();
 379  381  
 380  382    size_t young_list_target_length() const { return _young_list_target_length; }
 381  383  
 382  384    bool should_allocate_mutator_region() const;
 383  385  
 384  386    bool can_expand_young_list() const;
 385  387  
 386  388    uint young_list_max_length() const {
 387  389      return _young_list_max_length;
 388  390    }
 389  391  
 390  392    bool use_adaptive_young_list_length() const;
 391  393  
 392  394    void transfer_survivors_to_cset(const G1SurvivorRegions* survivors);
 393  395  
 394  396  private:
 395  397    //
 396  398    // Survivor regions policy.
 397  399    //
 398  400  
 399  401    // Current tenuring threshold, set to 0 if the collector reaches the
 400  402    // maximum amount of survivors regions.
 401  403    uint _tenuring_threshold;
 402  404  
 403  405    // The limit on the number of regions allocated for survivors.
 404  406    uint _max_survivor_regions;
 405  407  
 406  408    AgeTable _survivors_age_table;
 407  409  
 408  410    size_t desired_survivor_size(uint max_regions) const;
 409  411  
 410  412    // Fraction used when predicting how many optional regions to include in
 411  413    // the CSet. This fraction of the available time is used for optional regions,
 412  414    // the rest is used to add old regions to the normal CSet.
 413  415    double optional_prediction_fraction() { return 0.2; }
 414  416  
 415  417  public:
 416  418    // Fraction used when evacuating the optional regions. This fraction of the
 417  419    // remaining time is used to choose what regions to include in the evacuation.
 418  420    double optional_evacuation_fraction() { return 0.75; }
 419  421  
 420  422    uint tenuring_threshold() const { return _tenuring_threshold; }
 421  423  
 422  424    uint max_survivor_regions() {
 423  425      return _max_survivor_regions;
 424  426    }
 425  427  
 426  428    void note_start_adding_survivor_regions() {
 427  429      _survivor_surv_rate_group->start_adding_regions();
 428  430    }
 429  431  
 430  432    void note_stop_adding_survivor_regions() {
 431  433      _survivor_surv_rate_group->stop_adding_regions();
 432  434    }
 433  435  
 434  436    void record_age_table(AgeTable* age_table) {
 435  437      _survivors_age_table.merge(age_table);
 436  438    }
 437  439  
 438  440    void print_age_table();
 439  441  
 440  442    void update_max_gc_locker_expansion();
 441  443  
 442  444    void update_survivors_policy();
 443  445  
 444  446    virtual bool force_upgrade_to_full() {
 445  447      return false;
 446  448    }
 447  449  };
 448  450  
 449  451  #endif // SHARE_GC_G1_G1POLICY_HPP

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX