--- old/src/hotspot/share/gc/g1/g1HeapSizingPolicy.cpp 2020-05-19 15:08:35.751760228 +0200 +++ new/src/hotspot/share/gc/g1/g1HeapSizingPolicy.cpp 2020-05-19 15:08:35.671759052 +0200 @@ -50,44 +50,46 @@ _pauses_since_start = 0; } +double G1HeapSizingPolicy::scale_with_heap(double pause_time_threshold) { + double threshold = pause_time_threshold; + // If the heap is at less than half its maximum size, scale the threshold down, + // to a limit of 1%. Thus the smaller the heap is, the more likely it is to expand, + // though the scaling code will likely keep the increase small. + if (_g1h->capacity() <= _g1h->max_capacity() / 2) { + threshold *= (double)_g1h->capacity() / (double)(_g1h->max_capacity() / 2); + threshold = MAX2(threshold, 0.01); + } + + return threshold; +} + size_t G1HeapSizingPolicy::expansion_amount() { - assert(GCTimeRatio > 0, - "we should have set it to a default value set_g1_gc_flags() " - "if a user set it to 0"); + assert(GCTimeRatio > 0, "must be"); - double long_term_gc_overhead = _analytics->long_term_pause_time_ratio() * 100.0; - double short_term_gc_overhead = _analytics->short_term_pause_time_ratio() * 100.0; + double long_term_pause_time_ratio = _analytics->long_term_pause_time_ratio(); + double short_term_pause_time_ratio = _analytics->short_term_pause_time_ratio(); size_t expand_bytes = 0; if (_g1h->capacity() == _g1h->max_capacity()) { - log_trace(gc, ergo, heap)("Can not expand (heap already fully expanded) " - "long term GC overhead: %1.2f %% committed: " SIZE_FORMAT "B", - long_term_gc_overhead, _g1h->capacity()); + log_trace(gc, ergo, heap)("Cannot expand (heap already fully expanded) " + "long term GC overhead: %1.2f%% committed: " SIZE_FORMAT "B", + long_term_pause_time_ratio * 100.0, _g1h->capacity()); clear_ratio_check_data(); return expand_bytes; } - const double gc_overhead_percent = 100.0 * (1.0 / (1.0 + GCTimeRatio)); + const double pause_time_threshold = 1.0 / (1.0 + GCTimeRatio); - double threshold = gc_overhead_percent; - - // If the heap is at less than half its maximum size, scale the threshold down, - // to a limit of 1. Thus the smaller the heap is, the more likely it is to expand, - // though the scaling code will likely keep the increase small. - if (_g1h->capacity() <= _g1h->max_capacity() / 2) { - threshold *= (double)_g1h->capacity() / (double)(_g1h->max_capacity() / 2); - threshold = MAX2(threshold, 1.0); - } + double threshold = scale_with_heap(pause_time_threshold); // If the last GC time ratio is over the threshold, increment the count of // times it has been exceeded, and add this ratio to the sum of exceeded // ratios. - if (short_term_gc_overhead > threshold) { + if (short_term_pause_time_ratio > threshold) { _ratio_over_threshold_count++; - _ratio_over_threshold_sum += short_term_gc_overhead; + _ratio_over_threshold_sum += short_term_pause_time_ratio; } - // Check if we've had enough GC time ratio checks that were over the // threshold to trigger an expansion. We'll also expand if we've // reached the end of the history buffer and the average of all entries @@ -95,7 +97,7 @@ // long enough to make the average exceed the threshold. bool filled_history_buffer = _pauses_since_start == _num_prev_pauses_for_heuristics; if ((_ratio_over_threshold_count == MinOverThresholdForGrowth) || - (filled_history_buffer && (long_term_gc_overhead > threshold))) { + (filled_history_buffer && (long_term_pause_time_ratio > threshold))) { size_t min_expand_bytes = HeapRegion::GrainBytes; size_t reserved_bytes = _g1h->max_capacity(); size_t committed_bytes = _g1h->capacity(); @@ -123,15 +125,15 @@ } else { double const MinScaleDownFactor = 0.2; double const MaxScaleUpFactor = 2; - double const StartScaleDownAt = gc_overhead_percent; - double const StartScaleUpAt = gc_overhead_percent * 1.5; - double const ScaleUpRange = gc_overhead_percent * 2.0; + double const StartScaleDownAt = pause_time_threshold; + double const StartScaleUpAt = pause_time_threshold * 1.5; + double const ScaleUpRange = pause_time_threshold * 2.0; double ratio_delta; if (filled_history_buffer) { - ratio_delta = long_term_gc_overhead - threshold; + ratio_delta = long_term_pause_time_ratio - threshold; } else { - ratio_delta = (_ratio_over_threshold_sum/_ratio_over_threshold_count) - threshold; + ratio_delta = (_ratio_over_threshold_sum / _ratio_over_threshold_count) - threshold; } expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); @@ -145,8 +147,10 @@ } log_debug(gc, ergo, heap)("Attempt heap expansion (recent GC overhead higher than threshold after GC) " - "long term GC overhead: %1.2f %% threshold: %1.2f %% uncommitted: " SIZE_FORMAT "B base expansion amount and scale: " SIZE_FORMAT "B (%1.2f%%)", - long_term_gc_overhead, threshold, uncommitted_bytes, expand_bytes, scale_factor * 100); + "long term GC overhead: %1.2f%% threshold: %1.2f%% uncommitted: " SIZE_FORMAT "B " + "base expansion amount and scale: " SIZE_FORMAT "B (%1.2f%%)", + long_term_pause_time_ratio * 100.0, threshold * 100.0, + uncommitted_bytes, expand_bytes, scale_factor * 100.0); expand_bytes = static_cast(expand_bytes * scale_factor); --- old/src/hotspot/share/gc/g1/g1HeapSizingPolicy.hpp 2020-05-19 15:08:36.175766460 +0200 +++ new/src/hotspot/share/gc/g1/g1HeapSizingPolicy.hpp 2020-05-19 15:08:36.091765224 +0200 @@ -45,14 +45,16 @@ 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); -protected: 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. - virtual size_t expansion_amount(); + size_t expansion_amount(); // Clear ratio tracking data used by expansion_amount(). void clear_ratio_check_data();