--- old/src/hotspot/share/gc/shenandoah/shenandoahHeuristics.cpp 2020-05-11 14:08:33.721908336 +0200 +++ /dev/null 2020-05-03 11:24:07.618862528 +0200 @@ -1,302 +0,0 @@ -/* - * Copyright (c) 2018, 2020, Red Hat, Inc. 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. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" - -#include "gc/shared/gcCause.hpp" -#include "gc/shenandoah/shenandoahCollectionSet.inline.hpp" -#include "gc/shenandoah/shenandoahCollectorPolicy.hpp" -#include "gc/shenandoah/shenandoahHeap.inline.hpp" -#include "gc/shenandoah/shenandoahHeapRegion.inline.hpp" -#include "gc/shenandoah/shenandoahHeuristics.hpp" -#include "gc/shenandoah/shenandoahMarkingContext.inline.hpp" -#include "logging/log.hpp" -#include "logging/logTag.hpp" - -int ShenandoahHeuristics::compare_by_garbage(RegionData a, RegionData b) { - if (a._garbage > b._garbage) - return -1; - else if (a._garbage < b._garbage) - return 1; - else return 0; -} - -ShenandoahHeuristics::ShenandoahHeuristics() : - _region_data(NULL), - _degenerated_cycles_in_a_row(0), - _successful_cycles_in_a_row(0), - _cycle_start(os::elapsedTime()), - _last_cycle_end(0), - _gc_times_learned(0), - _gc_time_penalties(0), - _gc_time_history(new TruncatedSeq(5)), - _metaspace_oom() -{ - // No unloading during concurrent mark? Communicate that to heuristics - if (!ClassUnloadingWithConcurrentMark) { - FLAG_SET_DEFAULT(ShenandoahUnloadClassesFrequency, 0); - } - - size_t num_regions = ShenandoahHeap::heap()->num_regions(); - assert(num_regions > 0, "Sanity"); - - _region_data = NEW_C_HEAP_ARRAY(RegionData, num_regions, mtGC); -} - -ShenandoahHeuristics::~ShenandoahHeuristics() { - FREE_C_HEAP_ARRAY(RegionGarbage, _region_data); -} - -void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { - assert(collection_set->count() == 0, "Must be empty"); - - ShenandoahHeap* heap = ShenandoahHeap::heap(); - - // Check all pinned regions have updated status before choosing the collection set. - heap->assert_pinned_region_status(); - - // Step 1. Build up the region candidates we care about, rejecting losers and accepting winners right away. - - size_t num_regions = heap->num_regions(); - - RegionData* candidates = _region_data; - - size_t cand_idx = 0; - - size_t total_garbage = 0; - - size_t immediate_garbage = 0; - size_t immediate_regions = 0; - - size_t free = 0; - size_t free_regions = 0; - - ShenandoahMarkingContext* const ctx = heap->complete_marking_context(); - - for (size_t i = 0; i < num_regions; i++) { - ShenandoahHeapRegion* region = heap->get_region(i); - - size_t garbage = region->garbage(); - total_garbage += garbage; - - if (region->is_empty()) { - free_regions++; - free += ShenandoahHeapRegion::region_size_bytes(); - } else if (region->is_regular()) { - if (!region->has_live()) { - // We can recycle it right away and put it in the free set. - immediate_regions++; - immediate_garbage += garbage; - region->make_trash_immediate(); - } else { - // This is our candidate for later consideration. - candidates[cand_idx]._region = region; - candidates[cand_idx]._garbage = garbage; - cand_idx++; - } - } else if (region->is_humongous_start()) { - // Reclaim humongous regions here, and count them as the immediate garbage -#ifdef ASSERT - bool reg_live = region->has_live(); - bool bm_live = ctx->is_marked(oop(region->bottom())); - assert(reg_live == bm_live, - "Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: " SIZE_FORMAT, - BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words()); -#endif - if (!region->has_live()) { - heap->trash_humongous_region_at(region); - - // Count only the start. Continuations would be counted on "trash" path - immediate_regions++; - immediate_garbage += garbage; - } - } else if (region->is_trash()) { - // Count in just trashed collection set, during coalesced CM-with-UR - immediate_regions++; - immediate_garbage += garbage; - } - } - - // Step 2. Look back at garbage statistics, and decide if we want to collect anything, - // given the amount of immediately reclaimable garbage. If we do, figure out the collection set. - - assert (immediate_garbage <= total_garbage, - "Cannot have more immediate garbage than total garbage: " SIZE_FORMAT "%s vs " SIZE_FORMAT "%s", - byte_size_in_proper_unit(immediate_garbage), proper_unit_for_byte_size(immediate_garbage), - byte_size_in_proper_unit(total_garbage), proper_unit_for_byte_size(total_garbage)); - - size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage); - - if (immediate_percent <= ShenandoahImmediateThreshold) { - choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free); - } - - size_t cset_percent = (total_garbage == 0) ? 0 : (collection_set->garbage() * 100 / total_garbage); - - size_t collectable_garbage = collection_set->garbage() + immediate_garbage; - size_t collectable_garbage_percent = (total_garbage == 0) ? 0 : (collectable_garbage * 100 / total_garbage); - - log_info(gc, ergo)("Collectable Garbage: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " - "Immediate: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " - "CSet: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%)", - - byte_size_in_proper_unit(collectable_garbage), - proper_unit_for_byte_size(collectable_garbage), - collectable_garbage_percent, - - byte_size_in_proper_unit(immediate_garbage), - proper_unit_for_byte_size(immediate_garbage), - immediate_percent, - - byte_size_in_proper_unit(collection_set->garbage()), - proper_unit_for_byte_size(collection_set->garbage()), - cset_percent); -} - -void ShenandoahHeuristics::record_cycle_start() { - _cycle_start = os::elapsedTime(); -} - -void ShenandoahHeuristics::record_cycle_end() { - _last_cycle_end = os::elapsedTime(); -} - -bool ShenandoahHeuristics::should_start_gc() const { - // Perform GC to cleanup metaspace - if (has_metaspace_oom()) { - // Some of vmTestbase/metaspace tests depend on following line to count GC cycles - log_info(gc)("Trigger: %s", GCCause::to_string(GCCause::_metadata_GC_threshold)); - return true; - } - - if (ShenandoahGuaranteedGCInterval > 0) { - double last_time_ms = (os::elapsedTime() - _last_cycle_end) * 1000; - if (last_time_ms > ShenandoahGuaranteedGCInterval) { - log_info(gc)("Trigger: Time since last GC (%.0f ms) is larger than guaranteed interval (" UINTX_FORMAT " ms)", - last_time_ms, ShenandoahGuaranteedGCInterval); - return true; - } - } - - return false; -} - -bool ShenandoahHeuristics::should_degenerate_cycle() { - return _degenerated_cycles_in_a_row <= ShenandoahFullGCThreshold; -} - -void ShenandoahHeuristics::adjust_penalty(intx step) { - assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100, - "In range before adjustment: " INTX_FORMAT, _gc_time_penalties); - - intx new_val = _gc_time_penalties + step; - if (new_val < 0) { - new_val = 0; - } - if (new_val > 100) { - new_val = 100; - } - _gc_time_penalties = new_val; - - assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100, - "In range after adjustment: " INTX_FORMAT, _gc_time_penalties); -} - -void ShenandoahHeuristics::record_success_concurrent() { - _degenerated_cycles_in_a_row = 0; - _successful_cycles_in_a_row++; - - _gc_time_history->add(time_since_last_gc()); - _gc_times_learned++; - - adjust_penalty(Concurrent_Adjust); -} - -void ShenandoahHeuristics::record_success_degenerated() { - _degenerated_cycles_in_a_row++; - _successful_cycles_in_a_row = 0; - - adjust_penalty(Degenerated_Penalty); -} - -void ShenandoahHeuristics::record_success_full() { - _degenerated_cycles_in_a_row = 0; - _successful_cycles_in_a_row++; - - adjust_penalty(Full_Penalty); -} - -void ShenandoahHeuristics::record_allocation_failure_gc() { - // Do nothing. -} - -void ShenandoahHeuristics::record_requested_gc() { - // Assume users call System.gc() when external state changes significantly, - // which forces us to re-learn the GC timings and allocation rates. - _gc_times_learned = 0; -} - -bool ShenandoahHeuristics::can_process_references() { - if (ShenandoahRefProcFrequency == 0) return false; - return true; -} - -bool ShenandoahHeuristics::should_process_references() { - if (!can_process_references()) return false; - size_t cycle = ShenandoahHeap::heap()->shenandoah_policy()->cycle_counter(); - // Process references every Nth GC cycle. - return cycle % ShenandoahRefProcFrequency == 0; -} - -bool ShenandoahHeuristics::can_unload_classes() { - if (!ClassUnloading) return false; - return true; -} - -bool ShenandoahHeuristics::can_unload_classes_normal() { - if (!can_unload_classes()) return false; - if (has_metaspace_oom()) return true; - if (!ClassUnloadingWithConcurrentMark) return false; - if (ShenandoahUnloadClassesFrequency == 0) return false; - return true; -} - -bool ShenandoahHeuristics::should_unload_classes() { - if (!can_unload_classes_normal()) return false; - if (has_metaspace_oom()) return true; - size_t cycle = ShenandoahHeap::heap()->shenandoah_policy()->cycle_counter(); - // Unload classes every Nth GC cycle. - // This should not happen in the same cycle as process_references to amortize costs. - // Offsetting by one is enough to break the rendezvous when periods are equal. - // When periods are not equal, offsetting by one is just as good as any other guess. - return (cycle + 1) % ShenandoahUnloadClassesFrequency == 0; -} - -void ShenandoahHeuristics::initialize() { - // Nothing to do by default. -} - -double ShenandoahHeuristics::time_since_last_gc() const { - return os::elapsedTime() - _cycle_start; -} --- /dev/null 2020-05-03 11:24:07.618862528 +0200 +++ new/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp 2020-05-11 14:08:33.337908407 +0200 @@ -0,0 +1,302 @@ +/* + * Copyright (c) 2018, 2020, Red Hat, Inc. 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" + +#include "gc/shared/gcCause.hpp" +#include "gc/shenandoah/shenandoahCollectionSet.inline.hpp" +#include "gc/shenandoah/shenandoahCollectorPolicy.hpp" +#include "gc/shenandoah/shenandoahHeap.inline.hpp" +#include "gc/shenandoah/shenandoahHeapRegion.inline.hpp" +#include "gc/shenandoah/shenandoahMarkingContext.inline.hpp" +#include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp" +#include "logging/log.hpp" +#include "logging/logTag.hpp" + +int ShenandoahHeuristics::compare_by_garbage(RegionData a, RegionData b) { + if (a._garbage > b._garbage) + return -1; + else if (a._garbage < b._garbage) + return 1; + else return 0; +} + +ShenandoahHeuristics::ShenandoahHeuristics() : + _region_data(NULL), + _degenerated_cycles_in_a_row(0), + _successful_cycles_in_a_row(0), + _cycle_start(os::elapsedTime()), + _last_cycle_end(0), + _gc_times_learned(0), + _gc_time_penalties(0), + _gc_time_history(new TruncatedSeq(5)), + _metaspace_oom() +{ + // No unloading during concurrent mark? Communicate that to heuristics + if (!ClassUnloadingWithConcurrentMark) { + FLAG_SET_DEFAULT(ShenandoahUnloadClassesFrequency, 0); + } + + size_t num_regions = ShenandoahHeap::heap()->num_regions(); + assert(num_regions > 0, "Sanity"); + + _region_data = NEW_C_HEAP_ARRAY(RegionData, num_regions, mtGC); +} + +ShenandoahHeuristics::~ShenandoahHeuristics() { + FREE_C_HEAP_ARRAY(RegionGarbage, _region_data); +} + +void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) { + assert(collection_set->count() == 0, "Must be empty"); + + ShenandoahHeap* heap = ShenandoahHeap::heap(); + + // Check all pinned regions have updated status before choosing the collection set. + heap->assert_pinned_region_status(); + + // Step 1. Build up the region candidates we care about, rejecting losers and accepting winners right away. + + size_t num_regions = heap->num_regions(); + + RegionData* candidates = _region_data; + + size_t cand_idx = 0; + + size_t total_garbage = 0; + + size_t immediate_garbage = 0; + size_t immediate_regions = 0; + + size_t free = 0; + size_t free_regions = 0; + + ShenandoahMarkingContext* const ctx = heap->complete_marking_context(); + + for (size_t i = 0; i < num_regions; i++) { + ShenandoahHeapRegion* region = heap->get_region(i); + + size_t garbage = region->garbage(); + total_garbage += garbage; + + if (region->is_empty()) { + free_regions++; + free += ShenandoahHeapRegion::region_size_bytes(); + } else if (region->is_regular()) { + if (!region->has_live()) { + // We can recycle it right away and put it in the free set. + immediate_regions++; + immediate_garbage += garbage; + region->make_trash_immediate(); + } else { + // This is our candidate for later consideration. + candidates[cand_idx]._region = region; + candidates[cand_idx]._garbage = garbage; + cand_idx++; + } + } else if (region->is_humongous_start()) { + // Reclaim humongous regions here, and count them as the immediate garbage +#ifdef ASSERT + bool reg_live = region->has_live(); + bool bm_live = ctx->is_marked(oop(region->bottom())); + assert(reg_live == bm_live, + "Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: " SIZE_FORMAT, + BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words()); +#endif + if (!region->has_live()) { + heap->trash_humongous_region_at(region); + + // Count only the start. Continuations would be counted on "trash" path + immediate_regions++; + immediate_garbage += garbage; + } + } else if (region->is_trash()) { + // Count in just trashed collection set, during coalesced CM-with-UR + immediate_regions++; + immediate_garbage += garbage; + } + } + + // Step 2. Look back at garbage statistics, and decide if we want to collect anything, + // given the amount of immediately reclaimable garbage. If we do, figure out the collection set. + + assert (immediate_garbage <= total_garbage, + "Cannot have more immediate garbage than total garbage: " SIZE_FORMAT "%s vs " SIZE_FORMAT "%s", + byte_size_in_proper_unit(immediate_garbage), proper_unit_for_byte_size(immediate_garbage), + byte_size_in_proper_unit(total_garbage), proper_unit_for_byte_size(total_garbage)); + + size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage); + + if (immediate_percent <= ShenandoahImmediateThreshold) { + choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free); + } + + size_t cset_percent = (total_garbage == 0) ? 0 : (collection_set->garbage() * 100 / total_garbage); + + size_t collectable_garbage = collection_set->garbage() + immediate_garbage; + size_t collectable_garbage_percent = (total_garbage == 0) ? 0 : (collectable_garbage * 100 / total_garbage); + + log_info(gc, ergo)("Collectable Garbage: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " + "Immediate: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%), " + "CSet: " SIZE_FORMAT "%s (" SIZE_FORMAT "%%)", + + byte_size_in_proper_unit(collectable_garbage), + proper_unit_for_byte_size(collectable_garbage), + collectable_garbage_percent, + + byte_size_in_proper_unit(immediate_garbage), + proper_unit_for_byte_size(immediate_garbage), + immediate_percent, + + byte_size_in_proper_unit(collection_set->garbage()), + proper_unit_for_byte_size(collection_set->garbage()), + cset_percent); +} + +void ShenandoahHeuristics::record_cycle_start() { + _cycle_start = os::elapsedTime(); +} + +void ShenandoahHeuristics::record_cycle_end() { + _last_cycle_end = os::elapsedTime(); +} + +bool ShenandoahHeuristics::should_start_gc() const { + // Perform GC to cleanup metaspace + if (has_metaspace_oom()) { + // Some of vmTestbase/metaspace tests depend on following line to count GC cycles + log_info(gc)("Trigger: %s", GCCause::to_string(GCCause::_metadata_GC_threshold)); + return true; + } + + if (ShenandoahGuaranteedGCInterval > 0) { + double last_time_ms = (os::elapsedTime() - _last_cycle_end) * 1000; + if (last_time_ms > ShenandoahGuaranteedGCInterval) { + log_info(gc)("Trigger: Time since last GC (%.0f ms) is larger than guaranteed interval (" UINTX_FORMAT " ms)", + last_time_ms, ShenandoahGuaranteedGCInterval); + return true; + } + } + + return false; +} + +bool ShenandoahHeuristics::should_degenerate_cycle() { + return _degenerated_cycles_in_a_row <= ShenandoahFullGCThreshold; +} + +void ShenandoahHeuristics::adjust_penalty(intx step) { + assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100, + "In range before adjustment: " INTX_FORMAT, _gc_time_penalties); + + intx new_val = _gc_time_penalties + step; + if (new_val < 0) { + new_val = 0; + } + if (new_val > 100) { + new_val = 100; + } + _gc_time_penalties = new_val; + + assert(0 <= _gc_time_penalties && _gc_time_penalties <= 100, + "In range after adjustment: " INTX_FORMAT, _gc_time_penalties); +} + +void ShenandoahHeuristics::record_success_concurrent() { + _degenerated_cycles_in_a_row = 0; + _successful_cycles_in_a_row++; + + _gc_time_history->add(time_since_last_gc()); + _gc_times_learned++; + + adjust_penalty(Concurrent_Adjust); +} + +void ShenandoahHeuristics::record_success_degenerated() { + _degenerated_cycles_in_a_row++; + _successful_cycles_in_a_row = 0; + + adjust_penalty(Degenerated_Penalty); +} + +void ShenandoahHeuristics::record_success_full() { + _degenerated_cycles_in_a_row = 0; + _successful_cycles_in_a_row++; + + adjust_penalty(Full_Penalty); +} + +void ShenandoahHeuristics::record_allocation_failure_gc() { + // Do nothing. +} + +void ShenandoahHeuristics::record_requested_gc() { + // Assume users call System.gc() when external state changes significantly, + // which forces us to re-learn the GC timings and allocation rates. + _gc_times_learned = 0; +} + +bool ShenandoahHeuristics::can_process_references() { + if (ShenandoahRefProcFrequency == 0) return false; + return true; +} + +bool ShenandoahHeuristics::should_process_references() { + if (!can_process_references()) return false; + size_t cycle = ShenandoahHeap::heap()->shenandoah_policy()->cycle_counter(); + // Process references every Nth GC cycle. + return cycle % ShenandoahRefProcFrequency == 0; +} + +bool ShenandoahHeuristics::can_unload_classes() { + if (!ClassUnloading) return false; + return true; +} + +bool ShenandoahHeuristics::can_unload_classes_normal() { + if (!can_unload_classes()) return false; + if (has_metaspace_oom()) return true; + if (!ClassUnloadingWithConcurrentMark) return false; + if (ShenandoahUnloadClassesFrequency == 0) return false; + return true; +} + +bool ShenandoahHeuristics::should_unload_classes() { + if (!can_unload_classes_normal()) return false; + if (has_metaspace_oom()) return true; + size_t cycle = ShenandoahHeap::heap()->shenandoah_policy()->cycle_counter(); + // Unload classes every Nth GC cycle. + // This should not happen in the same cycle as process_references to amortize costs. + // Offsetting by one is enough to break the rendezvous when periods are equal. + // When periods are not equal, offsetting by one is just as good as any other guess. + return (cycle + 1) % ShenandoahUnloadClassesFrequency == 0; +} + +void ShenandoahHeuristics::initialize() { + // Nothing to do by default. +} + +double ShenandoahHeuristics::time_since_last_gc() const { + return os::elapsedTime() - _cycle_start; +}