src/hotspot/share/gc/g1/g1HeapSizingPolicy.hpp

rev 59703 : imported patch 8238687-investigate-memory-uncommit-during-young-gc

*** 1,7 ****
  /*
!  * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 24,65 ****
  
  #ifndef SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP
  #define SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP
  
  #include "memory/allocation.hpp"
  
  class G1Analytics;
  class G1CollectedHeap;
  
  class G1HeapSizingPolicy: public CHeapObj<mtGC> {
!   // MinOverThresholdForGrowth must be less than the number of recorded
!   // pause times in G1Analytics, representing the minimum number of pause
!   // time ratios that exceed GCTimeRatio before a heap expansion will be triggered.
!   const static uint MinOverThresholdForGrowth = 4;
  
    const G1CollectedHeap* _g1h;
    const G1Analytics* _analytics;
  
!   const uint _num_prev_pauses_for_heuristics;
!   // Ratio check data for determining if heap growth is necessary.
!   uint _ratio_over_threshold_count;
!   double _ratio_over_threshold_sum;
!   uint _pauses_since_start;
  
!   // Scale "full" gc pause time threshold with heap size as we want to resize more
    // eagerly at small heap sizes.
    double scale_with_heap(double pause_time_threshold);
  
    G1HeapSizingPolicy(const G1CollectedHeap* g1h, const G1Analytics* analytics);
  public:
  
!   // If an expansion would be appropriate, because recent GC overhead had
!   // exceeded the desired limit, return an amount to expand by.
!   size_t expansion_amount();
  
!   // Clear ratio tracking data used by expansion_amount().
!   void clear_ratio_check_data();
  
    static G1HeapSizingPolicy* create(const G1CollectedHeap* g1h, const G1Analytics* analytics);
  };
  
  #endif // SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP
--- 24,109 ----
  
  #ifndef SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP
  #define SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP
  
  #include "memory/allocation.hpp"
+ #include "utilities/numberSeq.hpp"
  
  class G1Analytics;
  class G1CollectedHeap;
  
+ //
+ // Contains heuristics for heap sizing, i.e. expansion or shrinking, during operation
+ // based on gc time ratio.
+ //
+ // The heuristics tracks both short term and long term behavior to effect heap
+ // size change.
+ // 
+ // Short term tracking is based on short-term gc time ratio behavior: for this we
+ // record events for when actual gc time ratio is outside the range of
+ // [GCTimeRatio * G1MinimumPercentOfGCTimeRatio, GCTimeRatio] or not in a counter.
+ // If below that range, we decrement that counter, if above, we increment it.
+ //
+ // The intent of this mechanism is to filter short term events as heap sizing has
+ // some overhead.
+ //
+ // If that counter reaches the MinOverThresholdForExpansion we consider expansion,
+ // if that counter reaches -MinOverThresholdForShrink we consider heap shrinking.
+ //
+ // While doing so, we accumulate the difference to the midpoint of this range to
+ // guide the expansion/shrinking amount.
+ //
+ // Further, if there is no short-term based resizing event for a "long" time, we
+ // decay that counter, i.e. drop it towards zero again to avoid that previous
+ // intermediate length short term behavior followed by a quiet time and a single
+ // short term event causes unnecessary resizes.
+ //
+ // Long term behavior is solely managed by regularly comparing actual long term
+ // gc time ratio with the boundaries of above range in  regular long term
+ // intervals. If current long term gc time ratio is outside, expand or shrink
+ // respectively.
+ //
  class G1HeapSizingPolicy: public CHeapObj<mtGC> {
!   // MinOverThresholdForExpansion/Shrink define the number of actual gc time
!   // ratios over the upper and lower thresholds respectively.
!   const static int MinOverThresholdForExpansion = 4;
!   const static int MinOverThresholdForShrink = 4;
  
    const G1CollectedHeap* _g1h;
    const G1Analytics* _analytics;
  
!   const uint _long_term_interval;
!   // Number of times actual gc time ratio crossed lower and upper threshold
!   // recently; every time the upper threshold is exceeded, it is incremented,
!   // and decremented if the lower threshold is undercut.
!   int _ratio_exceeds_threshold;
!   // Recent actual gc time ratios relative to the middle of lower and upper threshold.
!   TruncatedSeq _recent_pause_ratios;
!   uint _long_term_count;
! 
!   // Clear ratio tracking data used by resize_amount().
!   void reset_ratio_tracking_data();
!   void decay_ratio_tracking_data();
  
!   // Scale "full" gc time ratio threshold with heap size as we want to resize more
    // eagerly at small heap sizes.
    double scale_with_heap(double pause_time_threshold);
  
+   // Scale the ratio delta depending on how far it exceeds the actual target gc time
+   // ratio.
+   double scale_resize_ratio_delta(double ratio_delta);
+ 
    G1HeapSizingPolicy(const G1CollectedHeap* g1h, const G1Analytics* analytics);
  public:
  
!   // Return by how many bytes the heap should be changed based on recent gc time
!   // ratio after young collection. Positive values mean expansion is desired, and
!   // negative values mean desired shrinking.
!   ssize_t resize_amount_after_young_gc();
  
!   // Calculate the target capacity based on used bytes and free ratio.
!   size_t target_heap_capacity(size_t used_bytes, uintx free_ratio) const;
  
    static G1HeapSizingPolicy* create(const G1CollectedHeap* g1h, const G1Analytics* analytics);
  };
  
  #endif // SHARE_GC_G1_G1HEAPSIZINGPOLICY_HPP