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/debug.hpp" 32 #include "utilities/globalDefinitions.hpp" 33 34 G1HeapSizingPolicy* G1HeapSizingPolicy::create(const G1CollectedHeap* g1h, const G1Analytics* analytics) { 35 return new G1HeapSizingPolicy(g1h, analytics); 36 } 37 38 G1HeapSizingPolicy::G1HeapSizingPolicy(const G1CollectedHeap* g1h, const G1Analytics* analytics) : 39 _g1h(g1h), 40 _analytics(analytics), 41 _num_prev_pauses_for_heuristics(analytics->number_of_recorded_pause_times()) { 42 43 assert(MinOverThresholdForGrowth < _num_prev_pauses_for_heuristics, "Threshold must be less than %u", _num_prev_pauses_for_heuristics); 44 clear_ratio_check_data(); 45 } 46 47 void G1HeapSizingPolicy::clear_ratio_check_data() { 48 _ratio_over_threshold_count = 0; 49 _ratio_over_threshold_sum = 0.0; 50 _pauses_since_start = 0; 51 } 52 53 double G1HeapSizingPolicy::scale_with_heap(double pause_time_threshold) { 54 double threshold = pause_time_threshold; 55 // If the heap is at less than half its maximum size, scale the threshold down, 56 // to a limit of 1%. Thus the smaller the heap is, the more likely it is to expand, 57 // though the scaling code will likely keep the increase small. 58 if (_g1h->capacity() <= _g1h->max_capacity() / 2) { 59 threshold *= (double)_g1h->capacity() / (double)(_g1h->max_capacity() / 2); 60 threshold = MAX2(threshold, 0.01); 61 } 62 63 return threshold; 64 } 65 66 static void log_expansion(double short_term_pause_time_ratio, 67 double long_term_pause_time_ratio, 68 double threshold, 69 double pause_time_ratio, 70 bool fully_expanded, 71 size_t resize_bytes) { 72 73 log_debug(gc, ergo, heap)("Heap expansion: " 74 "short term pause time ratio %1.2f%% long term pause time ratio %1.2f%% " 75 "threshold %1.2f%% pause time ratio %1.2f%% fully expanded %s " 76 "resize by " SIZE_FORMAT "B", 77 short_term_pause_time_ratio * 100.0, 78 long_term_pause_time_ratio * 100.0, 79 threshold * 100.0, 80 pause_time_ratio * 100.0, 81 BOOL_TO_STR(fully_expanded), 82 resize_bytes); 83 } 84 85 size_t G1HeapSizingPolicy::expansion_amount() { 86 assert(GCTimeRatio > 0, "must be"); 87 88 double long_term_pause_time_ratio = _analytics->long_term_pause_time_ratio(); 89 double short_term_pause_time_ratio = _analytics->short_term_pause_time_ratio(); 90 const double pause_time_threshold = 1.0 / (1.0 + GCTimeRatio); 91 double threshold = scale_with_heap(pause_time_threshold); 92 93 size_t expand_bytes = 0; 94 95 if (_g1h->capacity() == _g1h->max_capacity()) { 96 log_expansion(short_term_pause_time_ratio, long_term_pause_time_ratio, 97 threshold, pause_time_threshold, true, 0); 98 clear_ratio_check_data(); 99 return expand_bytes; 100 } 101 102 // If the last GC time ratio is over the threshold, increment the count of 103 // times it has been exceeded, and add this ratio to the sum of exceeded 104 // ratios. 105 if (short_term_pause_time_ratio > threshold) { 106 _ratio_over_threshold_count++; 107 _ratio_over_threshold_sum += short_term_pause_time_ratio; 108 } 109 110 log_trace(gc, ergo, heap)("Heap expansion triggers: pauses since start: %u " 111 "num prev pauses for heuristics: %u " 112 "ratio over threshold count: %u", 113 _pauses_since_start, 114 _num_prev_pauses_for_heuristics, 115 _ratio_over_threshold_count); 116 117 // Check if we've had enough GC time ratio checks that were over the 118 // threshold to trigger an expansion. We'll also expand if we've 119 // reached the end of the history buffer and the average of all entries 120 // is still over the threshold. This indicates a smaller number of GCs were 121 // long enough to make the average exceed the threshold. 122 bool filled_history_buffer = _pauses_since_start == _num_prev_pauses_for_heuristics; 123 if ((_ratio_over_threshold_count == MinOverThresholdForGrowth) || 124 (filled_history_buffer && (long_term_pause_time_ratio > threshold))) { 125 size_t min_expand_bytes = HeapRegion::GrainBytes; 126 size_t reserved_bytes = _g1h->max_capacity(); 127 size_t committed_bytes = _g1h->capacity(); 128 size_t uncommitted_bytes = reserved_bytes - committed_bytes; 129 size_t expand_bytes_via_pct = 130 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; 131 double scale_factor = 1.0; 132 133 // If the current size is less than 1/4 of the Initial heap size, expand 134 // by half of the delta between the current and Initial sizes. IE, grow 135 // back quickly. 136 // 137 // Otherwise, take the current size, or G1ExpandByPercentOfAvailable % of 138 // the available expansion space, whichever is smaller, as the base 139 // expansion size. Then possibly scale this size according to how much the 140 // threshold has (on average) been exceeded by. If the delta is small 141 // (less than the StartScaleDownAt value), scale the size down linearly, but 142 // not by less than MinScaleDownFactor. If the delta is large (greater than 143 // the StartScaleUpAt value), scale up, but adding no more than MaxScaleUpFactor 144 // times the base size. The scaling will be linear in the range from 145 // StartScaleUpAt to (StartScaleUpAt + ScaleUpRange). In other words, 146 // ScaleUpRange sets the rate of scaling up. 147 if (committed_bytes < InitialHeapSize / 4) { 148 expand_bytes = (InitialHeapSize - committed_bytes) / 2; 149 } else { 150 double const MinScaleDownFactor = 0.2; 151 double const MaxScaleUpFactor = 2; 152 double const StartScaleDownAt = pause_time_threshold; 153 double const StartScaleUpAt = pause_time_threshold * 1.5; 154 double const ScaleUpRange = pause_time_threshold * 2.0; 155 156 double ratio_delta; 157 if (filled_history_buffer) { 158 ratio_delta = long_term_pause_time_ratio - threshold; 159 } else { 160 ratio_delta = (_ratio_over_threshold_sum / _ratio_over_threshold_count) - threshold; 161 } 162 163 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); 164 if (ratio_delta < StartScaleDownAt) { 165 scale_factor = ratio_delta / StartScaleDownAt; 166 scale_factor = MAX2(scale_factor, MinScaleDownFactor); 167 } else if (ratio_delta > StartScaleUpAt) { 168 scale_factor = 1 + ((ratio_delta - StartScaleUpAt) / ScaleUpRange); 169 scale_factor = MIN2(scale_factor, MaxScaleUpFactor); 170 } 171 } 172 173 expand_bytes = static_cast<size_t>(expand_bytes * scale_factor); 174 175 // Ensure the expansion size is at least the minimum growth amount 176 // and at most the remaining uncommitted byte size. 177 expand_bytes = clamp(expand_bytes, min_expand_bytes, uncommitted_bytes); 178 179 clear_ratio_check_data(); 180 } else { 181 // An expansion was not triggered. If we've started counting, increment 182 // the number of checks we've made in the current window. If we've 183 // reached the end of the window without resizing, clear the counters to 184 // start again the next time we see a ratio above the threshold. 185 if (_ratio_over_threshold_count > 0) { 186 _pauses_since_start++; 187 if (_pauses_since_start > _num_prev_pauses_for_heuristics) { 188 clear_ratio_check_data(); 189 } 190 } 191 } 192 193 log_expansion(short_term_pause_time_ratio, long_term_pause_time_ratio, 194 threshold, pause_time_threshold, false, expand_bytes); 195 196 return expand_bytes; 197 }