< prev index next >
src/share/vm/gc_implementation/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp
Print this page
rev 10519 : [backport] Adaptive CSet selection selects excessively when memory is tight
rev 10544 : [backport] Adaptive CSet selection overshoots max-CSet
rev 10584 : [backport] Move periodic GC decision making to GC heuristics base class
rev 10598 : [backport] Shenandoah changes to allow enabling -Wreorder
rev 10604 : [backport] Comprehensible GC trigger logging
rev 10606 : [backport] Adaptive/Traversal heuristics rewrite for allocation rate
rev 10620 : [backport] Evac reserve: make sure GC has untouchable space to move the objects into
*** 29,43 ****
#include "gc_implementation/shenandoah/shenandoahLogging.hpp"
#include "utilities/quickSort.hpp"
ShenandoahAdaptiveHeuristics::ShenandoahAdaptiveHeuristics() :
ShenandoahHeuristics(),
! _free_threshold(ShenandoahInitFreeThreshold),
! _peak_occupancy(0),
_conc_mark_duration_history(new TruncatedSeq(5)),
! _conc_uprefs_duration_history(new TruncatedSeq(5)),
! _cycle_gap_history(new TruncatedSeq(5)) {
}
ShenandoahAdaptiveHeuristics::~ShenandoahAdaptiveHeuristics() {}
void ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
--- 29,41 ----
#include "gc_implementation/shenandoah/shenandoahLogging.hpp"
#include "utilities/quickSort.hpp"
ShenandoahAdaptiveHeuristics::ShenandoahAdaptiveHeuristics() :
ShenandoahHeuristics(),
! _cycle_gap_history(new TruncatedSeq(5)),
_conc_mark_duration_history(new TruncatedSeq(5)),
! _conc_uprefs_duration_history(new TruncatedSeq(5)) {
}
ShenandoahAdaptiveHeuristics::~ShenandoahAdaptiveHeuristics() {}
void ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
*** 53,138 ****
// available space. In non-overloaded heap, max_cset would contain all plausible candidates
// over garbage threshold.
//
// 2. We should not get cset too low so that free threshold would not be met right
// after the cycle. Otherwise we get back-to-back cycles for no reason if heap is
! // too fragmented. In non-overloaded non-fragmented heap min_cset would be around zero.
//
// Therefore, we start by sorting the regions by garbage. Then we unconditionally add the best candidates
! // before we meet min_cset. Then we add all candidates that fit with a garbage threshold before
// we hit max_cset. When max_cset is hit, we terminate the cset selection. Note that in this scheme,
! // ShenandoahGarbageThreshold is the soft threshold which would be ignored until min_cset is hit.
! size_t free_target = MIN2<size_t>(_free_threshold + MaxNormalStep, 100) * ShenandoahHeap::heap()->capacity() / 100;
! size_t min_cset = free_target > actual_free ? (free_target - actual_free) : 0;
! size_t max_cset = actual_free * 3 / 4;
! min_cset = MIN2(min_cset, max_cset);
log_info(gc, ergo)("Adaptive CSet Selection. Target Free: " SIZE_FORMAT "M, Actual Free: "
! SIZE_FORMAT "M, Target CSet: [" SIZE_FORMAT "M, " SIZE_FORMAT "M]",
! free_target / M, actual_free / M, min_cset / M, max_cset / M);
// Better select garbage-first regions
QuickSort::sort<RegionData>(data, (int)size, compare_by_garbage, false);
! size_t live_cset = 0;
_bytes_in_cset = 0;
for (size_t idx = 0; idx < size; idx++) {
ShenandoahHeapRegion* r = data[idx]._region;
! size_t new_cset = live_cset + r->get_live_data_bytes();
! if (new_cset < min_cset) {
! cset->add_region(r);
! _bytes_in_cset += r->used();
! live_cset = new_cset;
! } else if (new_cset <= max_cset) {
! if (r->garbage() > garbage_threshold) {
! cset->add_region(r);
! _bytes_in_cset += r->used();
! live_cset = new_cset;
! }
! } else {
break;
}
- }
- }
! void ShenandoahAdaptiveHeuristics::handle_cycle_success() {
! ShenandoahHeap* heap = ShenandoahHeap::heap();
! size_t capacity = heap->capacity();
!
! size_t current_threshold = (capacity - _peak_occupancy) * 100 / capacity;
! size_t min_threshold = ShenandoahMinFreeThreshold;
! intx step = min_threshold - current_threshold;
! step = MAX2(step, (intx) -MaxNormalStep);
! step = MIN2(step, (intx) MaxNormalStep);
!
! log_info(gc, ergo)("Capacity: " SIZE_FORMAT "M, Peak Occupancy: " SIZE_FORMAT
! "M, Lowest Free: " SIZE_FORMAT "M, Free Threshold: " UINTX_FORMAT "M",
! capacity / M, _peak_occupancy / M,
! (capacity - _peak_occupancy) / M, ShenandoahMinFreeThreshold * capacity / 100 / M);
!
! if (step > 0) {
! // Pessimize
! adjust_free_threshold(step);
! } else if (step < 0) {
! // Optimize, if enough happy cycles happened
! if (_successful_cycles_in_a_row > ShenandoahHappyCyclesThreshold &&
! _free_threshold > 0) {
! adjust_free_threshold(step);
! _successful_cycles_in_a_row = 0;
}
- } else {
- // do nothing
}
- _peak_occupancy = 0;
}
void ShenandoahAdaptiveHeuristics::record_cycle_start() {
ShenandoahHeuristics::record_cycle_start();
! double last_cycle_gap = (os::elapsedTime() - _last_cycle_end);
_cycle_gap_history->add(last_cycle_gap);
}
void ShenandoahAdaptiveHeuristics::record_phase_time(ShenandoahPhaseTimings::Phase phase, double secs) {
if (phase == ShenandoahPhaseTimings::conc_mark) {
--- 51,105 ----
// available space. In non-overloaded heap, max_cset would contain all plausible candidates
// over garbage threshold.
//
// 2. We should not get cset too low so that free threshold would not be met right
// after the cycle. Otherwise we get back-to-back cycles for no reason if heap is
! // too fragmented. In non-overloaded non-fragmented heap min_garbage would be around zero.
//
// Therefore, we start by sorting the regions by garbage. Then we unconditionally add the best candidates
! // before we meet min_garbage. Then we add all candidates that fit with a garbage threshold before
// we hit max_cset. When max_cset is hit, we terminate the cset selection. Note that in this scheme,
! // ShenandoahGarbageThreshold is the soft threshold which would be ignored until min_garbage is hit.
! size_t capacity = ShenandoahHeap::heap()->capacity();
! size_t free_target = ShenandoahMinFreeThreshold * capacity / 100;
! size_t min_garbage = free_target > actual_free ? (free_target - actual_free) : 0;
! size_t max_cset = (size_t)(1.0 * ShenandoahEvacReserve * capacity / 100 / ShenandoahEvacWaste);
log_info(gc, ergo)("Adaptive CSet Selection. Target Free: " SIZE_FORMAT "M, Actual Free: "
! SIZE_FORMAT "M, Max CSet: " SIZE_FORMAT "M, Min Garbage: " SIZE_FORMAT "M",
! free_target / M, actual_free / M, max_cset / M, min_garbage / M);
// Better select garbage-first regions
QuickSort::sort<RegionData>(data, (int)size, compare_by_garbage, false);
! size_t cur_cset = 0;
! size_t cur_garbage = 0;
_bytes_in_cset = 0;
+
for (size_t idx = 0; idx < size; idx++) {
ShenandoahHeapRegion* r = data[idx]._region;
! size_t new_cset = cur_cset + r->get_live_data_bytes();
! size_t new_garbage = cur_garbage + r->garbage();
! if (new_cset > max_cset) {
break;
}
! if ((new_garbage < min_garbage) || (r->garbage() > garbage_threshold)) {
! cset->add_region(r);
! _bytes_in_cset += r->used();
! cur_cset = new_cset;
! cur_garbage = new_garbage;
}
}
}
void ShenandoahAdaptiveHeuristics::record_cycle_start() {
ShenandoahHeuristics::record_cycle_start();
! double last_cycle_gap = (_cycle_start - _last_cycle_end);
_cycle_gap_history->add(last_cycle_gap);
}
void ShenandoahAdaptiveHeuristics::record_phase_time(ShenandoahPhaseTimings::Phase phase, double secs) {
if (phase == ShenandoahPhaseTimings::conc_mark) {
*** 140,211 ****
} else if (phase == ShenandoahPhaseTimings::conc_update_refs) {
_conc_uprefs_duration_history->add(secs);
} // Else ignore
}
! void ShenandoahAdaptiveHeuristics::adjust_free_threshold(intx adj) {
! intx new_value = adj + _free_threshold;
! uintx new_threshold = (uintx)MAX2<intx>(new_value, 0);
! new_threshold = MAX2(new_threshold, ShenandoahMinFreeThreshold);
! new_threshold = MIN2(new_threshold, ShenandoahMaxFreeThreshold);
! if (new_threshold != _free_threshold) {
! _free_threshold = new_threshold;
! log_info(gc, ergo)("Adjusting free threshold to: " UINTX_FORMAT "%% (" SIZE_FORMAT "M)",
! _free_threshold, _free_threshold * ShenandoahHeap::heap()->capacity() / 100 / M);
}
- }
! void ShenandoahAdaptiveHeuristics::record_success_concurrent() {
! ShenandoahHeuristics::record_success_concurrent();
! handle_cycle_success();
! }
! void ShenandoahAdaptiveHeuristics::record_success_degenerated() {
! ShenandoahHeuristics::record_success_degenerated();
! adjust_free_threshold(DegeneratedGC_Hit);
! }
! void ShenandoahAdaptiveHeuristics::record_success_full() {
! ShenandoahHeuristics::record_success_full();
! adjust_free_threshold(AllocFailure_Hit);
! }
! void ShenandoahAdaptiveHeuristics::record_explicit_gc() {
! ShenandoahHeuristics::record_explicit_gc();
! adjust_free_threshold(UserRequested_Hit);
! }
! void ShenandoahAdaptiveHeuristics::record_peak_occupancy() {
! _peak_occupancy = MAX2(_peak_occupancy, ShenandoahHeap::heap()->used());
! }
! bool ShenandoahAdaptiveHeuristics::should_start_normal_gc() const {
! ShenandoahHeap* heap = ShenandoahHeap::heap();
! size_t capacity = heap->capacity();
! size_t available = heap->free_set()->available();
! double last_time_ms = (os::elapsedTime() - _last_cycle_end) * 1000;
! bool periodic_gc = (last_time_ms > ShenandoahGuaranteedGCInterval);
! size_t threshold_available = (capacity * _free_threshold) / 100;
! size_t bytes_allocated = heap->bytes_allocated_since_gc_start();
! size_t threshold_bytes_allocated = heap->capacity() * ShenandoahAllocationThreshold / 100;
!
! if (available < threshold_available &&
! bytes_allocated > threshold_bytes_allocated) {
! log_info(gc,ergo)("Concurrent marking triggered. Free: " SIZE_FORMAT "M, Free Threshold: " SIZE_FORMAT
! "M; Allocated: " SIZE_FORMAT "M, Alloc Threshold: " SIZE_FORMAT "M",
! available / M, threshold_available / M, bytes_allocated / M, threshold_bytes_allocated / M);
! // Need to check that an appropriate number of regions have
! // been allocated since last concurrent mark too.
! return true;
! } else if (periodic_gc) {
! log_info(gc,ergo)("Periodic GC triggered. Time since last GC: %.0f ms, Guaranteed Interval: " UINTX_FORMAT " ms",
! last_time_ms, ShenandoahGuaranteedGCInterval);
return true;
}
! return false;
}
bool ShenandoahAdaptiveHeuristics::should_start_update_refs() {
if (! _update_refs_adaptive) {
return _update_refs_early;
--- 107,168 ----
} else if (phase == ShenandoahPhaseTimings::conc_update_refs) {
_conc_uprefs_duration_history->add(secs);
} // Else ignore
}
! bool ShenandoahAdaptiveHeuristics::should_start_normal_gc() const {
! ShenandoahHeap* heap = ShenandoahHeap::heap();
! size_t capacity = heap->capacity();
! size_t available = heap->free_set()->available();
!
! // Check if we are falling below the worst limit, time to trigger the GC, regardless of
! // anything else.
! size_t min_threshold = ShenandoahMinFreeThreshold * heap->capacity() / 100;
! if (available < min_threshold) {
! log_info(gc)("Trigger: Free (" SIZE_FORMAT "M) is below minimum threshold (" SIZE_FORMAT "M)",
! available / M, min_threshold / M);
! return true;
}
! // Check if are need to learn a bit about the application
! const size_t max_learn = ShenandoahLearningSteps;
! if (_gc_times_learned < max_learn) {
! size_t init_threshold = ShenandoahInitFreeThreshold * heap->capacity() / 100;
! if (available < init_threshold) {
! log_info(gc)("Trigger: Learning " SIZE_FORMAT " of " SIZE_FORMAT ". Free (" SIZE_FORMAT "M) is below initial threshold (" SIZE_FORMAT "M)",
! _gc_times_learned + 1, max_learn, available / M, init_threshold / M);
! return true;
! }
! }
! // Check if allocation headroom is still okay. This also factors in:
! // 1. Some space to absorb allocation spikes
! // 2. Accumulated penalties from Degenerated and Full GC
! size_t allocation_headroom = available;
! size_t spike_headroom = ShenandoahAllocSpikeFactor * capacity / 100;
! size_t penalties = _gc_time_penalties * capacity / 100;
! allocation_headroom -= MIN2(allocation_headroom, spike_headroom);
! allocation_headroom -= MIN2(allocation_headroom, penalties);
! // TODO: Allocation rate is way too averaged to be useful during state changes
! double average_gc = _gc_time_history->avg();
! double time_since_last = os::elapsedTime() - _cycle_start;
! double allocation_rate = heap->bytes_allocated_since_gc_start() / time_since_last;
!
! if (average_gc > allocation_headroom / allocation_rate) {
! log_info(gc)("Trigger: Average GC time (%.2f ms) is above the time for allocation rate (%.2f MB/s) to deplete free headroom (" SIZE_FORMAT "M)",
! average_gc * 1000, allocation_rate / M, allocation_headroom / M);
! log_info(gc, ergo)("Free headroom: " SIZE_FORMAT "M (free) - " SIZE_FORMAT "M (spike) - " SIZE_FORMAT "M (penalties) = " SIZE_FORMAT "M",
! available / M, spike_headroom / M, penalties / M, allocation_headroom / M);
return true;
}
! return ShenandoahHeuristics::should_start_normal_gc();
}
bool ShenandoahAdaptiveHeuristics::should_start_update_refs() {
if (! _update_refs_adaptive) {
return _update_refs_early;
< prev index next >