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 #include "precompiled.hpp"
  26 #include "gc/g1/g1CollectedHeap.hpp"
  27 #include "gc/g1/g1HeapSizingPolicy.hpp"
  28 #include "gc/g1/g1Analytics.hpp"
  29 #include "logging/log.hpp"
  30 #include "runtime/globals.hpp"
  31 #include "utilities/globalDefinitions.hpp"
  32 
  33 void G1HeapSizingPolicy::clear_ratio_check_data() {
  34   _ratio_over_threshold_count = 0;
  35   _ratio_over_threshold_sum = 0.0;
  36   _pauses_since_start = 0;
  37 }
  38 
  39 size_t G1HeapSizingPolicy::expansion_amount() {
  40   double recent_gc_overhead = _analytics->recent_avg_pause_time_ratio() * 100.0;
  41   double last_gc_overhead = _analytics->last_pause_time_ratio() * 100.0;
  42   assert(GCTimeRatio > 0,
  43          "we should have set it to a default value set_g1_gc_flags() "
  44          "if a user set it to 0");
  45   const double gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio));
  46 
  47   double threshold = gc_overhead_perc;
  48   size_t expand_bytes = 0;
  49 
  50   // If the heap is at less than half its maximum size, scale the threshold down,
  51   // to a limit of 1. Thus the smaller the heap is, the more likely it is to expand,
  52   // though the scaling code will likely keep the increase small.
  53   if (_g1->capacity() <= _g1->max_capacity() / 2) {
  54     threshold *= (double)_g1->capacity() / (double)(_g1->max_capacity() / 2);
  55     threshold = MAX2(threshold, 1.0);
  56   }
  57 
  58   // If the last GC time ratio is over the threshold, increment the count of
  59   // times it has been exceeded, and add this ratio to the sum of exceeded
  60   // ratios.
  61   if (last_gc_overhead > threshold) {
  62     _ratio_over_threshold_count++;
  63     _ratio_over_threshold_sum += last_gc_overhead;
  64   }
  65 
  66   // Check if we've had enough GC time ratio checks that were over the
  67   // threshold to trigger an expansion. We'll also expand if we've
  68   // reached the end of the history buffer and the average of all entries
  69   // is still over the threshold. This indicates a smaller number of GCs were
  70   // long enough to make the average exceed the threshold.
  71   bool filled_history_buffer = _pauses_since_start == NumPrevPausesForHeuristics;
  72   if ((_ratio_over_threshold_count == MinOverThresholdForGrowth) ||
  73       (filled_history_buffer && (recent_gc_overhead > threshold))) {
  74     size_t min_expand_bytes = HeapRegion::GrainBytes;
  75     size_t reserved_bytes = _g1->max_capacity();
  76     size_t committed_bytes = _g1->capacity();
  77     size_t uncommitted_bytes = reserved_bytes - committed_bytes;
  78     size_t expand_bytes_via_pct =
  79       uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
  80     double scale_factor = 1.0;
  81 
  82     // If the current size is less than 1/4 of the Initial heap size, expand
  83     // by half of the delta between the current and Initial sizes. IE, grow
  84     // back quickly.
  85     //
  86     // Otherwise, take the current size, or G1ExpandByPercentOfAvailable % of
  87     // the available expansion space, whichever is smaller, as the base
  88     // expansion size. Then possibly scale this size according to how much the
  89     // threshold has (on average) been exceeded by. If the delta is small
  90     // (less than the StartScaleDownAt value), scale the size down linearly, but
  91     // not by less than MinScaleDownFactor. If the delta is large (greater than
  92     // the StartScaleUpAt value), scale up, but adding no more than MaxScaleUpFactor
  93     // times the base size. The scaling will be linear in the range from
  94     // StartScaleUpAt to (StartScaleUpAt + ScaleUpRange). In other words,
  95     // ScaleUpRange sets the rate of scaling up.
  96     if (committed_bytes < InitialHeapSize / 4) {
  97       expand_bytes = (InitialHeapSize - committed_bytes) / 2;
  98     } else {
  99       double const MinScaleDownFactor = 0.2;
 100       double const MaxScaleUpFactor = 2;
 101       double const StartScaleDownAt = gc_overhead_perc;
 102       double const StartScaleUpAt = gc_overhead_perc * 1.5;
 103       double const ScaleUpRange = gc_overhead_perc * 2.0;
 104 
 105       double ratio_delta;
 106       if (filled_history_buffer) {
 107         ratio_delta = recent_gc_overhead - threshold;
 108       } else {
 109         ratio_delta = (_ratio_over_threshold_sum/_ratio_over_threshold_count) - threshold;
 110       }
 111 
 112       expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes);
 113       if (ratio_delta < StartScaleDownAt) {
 114         scale_factor = ratio_delta / StartScaleDownAt;
 115         scale_factor = MAX2(scale_factor, MinScaleDownFactor);
 116       } else if (ratio_delta > StartScaleUpAt) {
 117         scale_factor = 1 + ((ratio_delta - StartScaleUpAt) / ScaleUpRange);
 118         scale_factor = MIN2(scale_factor, MaxScaleUpFactor);
 119       }
 120     }
 121 
 122     log_debug(gc, ergo, heap)("Attempt heap expansion (recent GC overhead higher than threshold after GC) "
 123                               "recent GC overhead: %1.2f %% threshold: %1.2f %% uncommitted: " SIZE_FORMAT "B base expansion amount and scale: " SIZE_FORMAT "B (%1.2f%%)",
 124                               recent_gc_overhead, threshold, uncommitted_bytes, expand_bytes, scale_factor * 100);
 125 
 126     expand_bytes = static_cast<size_t>(expand_bytes * scale_factor);
 127 
 128     // Ensure the expansion size is at least the minimum growth amount
 129     // and at most the remaining uncommitted byte size.
 130     expand_bytes = MAX2(expand_bytes, min_expand_bytes);
 131     expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
 132 
 133     clear_ratio_check_data();
 134   } else {
 135     // An expansion was not triggered. If we've started counting, increment
 136     // the number of checks we've made in the current window.  If we've
 137     // reached the end of the window without resizing, clear the counters to
 138     // start again the next time we see a ratio above the threshold.
 139     if (_ratio_over_threshold_count > 0) {
 140       _pauses_since_start++;
 141       if (_pauses_since_start > NumPrevPausesForHeuristics) {
 142         clear_ratio_check_data();
 143       }
 144     }
 145   }
 146 
 147   return expand_bytes;
 148 }