infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-07 14:40:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

8154753: Turn G1Policy into an interface

Browse Source 
Reviewed-by: sjohanss, mgerdin
This commit is contained in:
Erik Helin 2016-04-20 15:24:18 +02:00
parent 9ca6318ece
commit 63484cce64
4 changed files with 571 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
hotspot/src/share/vm/gc/g1/g1CollectedHeap_ext.cpp
View File

@ -24,6 +24,7 @@
#include "precompiled.hpp"
#include "gc/g1/g1CollectedHeap.hpp"
#include "gc/g1/g1DefaultPolicy.hpp"
#include "gc/g1/g1ParScanThreadState.hpp"
#include "gc/g1/heapRegion.inline.hpp"
@ -40,5 +41,5 @@ HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index,
}
G1Policy* G1CollectedHeap::create_g1_policy() {
return new G1Policy;
return new G1DefaultPolicy();
}

147
hotspot/src/share/vm/gc/g1/g1Policy.cpp → hotspot/src/share/vm/gc/g1/g1DefaultPolicy.cpp
View File

@ -29,6 +29,7 @@
#include "gc/g1/g1CollectedHeap.inline.hpp"
#include "gc/g1/g1CollectionSet.hpp"
#include "gc/g1/g1ConcurrentMark.hpp"
#include "gc/g1/g1DefaultPolicy.hpp"
#include "gc/g1/g1IHOPControl.hpp"
#include "gc/g1/g1GCPhaseTimes.hpp"
#include "gc/g1/g1Policy.hpp"
@ -42,7 +43,7 @@
#include "utilities/debug.hpp"
#include "utilities/pair.hpp"
G1Policy::G1Policy() :
G1DefaultPolicy::G1DefaultPolicy() :
_predictor(G1ConfidencePercent / 100.0),
_analytics(new G1Analytics(&_predictor)),
_mmu_tracker(new G1MMUTrackerQueue(GCPauseIntervalMillis / 1000.0, MaxGCPauseMillis / 1000.0)),
@ -63,13 +64,13 @@ G1Policy::G1Policy() :
_max_survivor_regions(0),
_survivors_age_table(true) { }
G1Policy::~G1Policy() {
G1DefaultPolicy::~G1DefaultPolicy() {
delete _ihop_control;
}
G1CollectorState* G1Policy::collector_state() const { return _g1->collector_state(); }
G1CollectorState* G1DefaultPolicy::collector_state() const { return _g1->collector_state(); }
void G1Policy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
void G1DefaultPolicy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
_g1 = g1h;
_collection_set = collection_set;
@ -88,14 +89,14 @@ void G1Policy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
_collection_set->start_incremental_building();
}
void G1Policy::note_gc_start() {
void G1DefaultPolicy::note_gc_start() {
phase_times()->note_gc_start();
}
bool G1Policy::predict_will_fit(uint young_length,
double base_time_ms,
uint base_free_regions,
double target_pause_time_ms) const {
bool G1DefaultPolicy::predict_will_fit(uint young_length,
double base_time_ms,
uint base_free_regions,
double target_pause_time_ms) const {
if (young_length >= base_free_regions) {
// end condition 1: not enough space for the young regions
return false;
@ -134,7 +135,7 @@ bool G1Policy::predict_will_fit(uint young_length,
return true;
}
void G1Policy::record_new_heap_size(uint new_number_of_regions) {
void G1DefaultPolicy::record_new_heap_size(uint new_number_of_regions) {
// re-calculate the necessary reserve
double reserve_regions_d = (double) new_number_of_regions * _reserve_factor;
// We use ceiling so that if reserve_regions_d is > 0.0 (but
@ -146,7 +147,7 @@ void G1Policy::record_new_heap_size(uint new_number_of_regions) {
_ihop_control->update_target_occupancy(new_number_of_regions * HeapRegion::GrainBytes);
}
uint G1Policy::calculate_young_list_desired_min_length(uint base_min_length) const {
uint G1DefaultPolicy::calculate_young_list_desired_min_length(uint base_min_length) const {
uint desired_min_length = 0;
if (adaptive_young_list_length()) {
if (_analytics->num_alloc_rate_ms() > 3) {
@ -163,30 +164,30 @@ uint G1Policy::calculate_young_list_desired_min_length(uint base_min_length) con
return MAX2(_young_gen_sizer.min_desired_young_length(), desired_min_length);
}
uint G1Policy::calculate_young_list_desired_max_length() const {
uint G1DefaultPolicy::calculate_young_list_desired_max_length() const {
// Here, we might want to also take into account any additional
// constraints (i.e., user-defined minimum bound). Currently, we
// effectively don't set this bound.
return _young_gen_sizer.max_desired_young_length();
}
uint G1Policy::update_young_list_max_and_target_length() {
uint G1DefaultPolicy::update_young_list_max_and_target_length() {
return update_young_list_max_and_target_length(_analytics->predict_rs_lengths());
}
uint G1Policy::update_young_list_max_and_target_length(size_t rs_lengths) {
uint G1DefaultPolicy::update_young_list_max_and_target_length(size_t rs_lengths) {
uint unbounded_target_length = update_young_list_target_length(rs_lengths);
update_max_gc_locker_expansion();
return unbounded_target_length;
}
uint G1Policy::update_young_list_target_length(size_t rs_lengths) {
uint G1DefaultPolicy::update_young_list_target_length(size_t rs_lengths) {
YoungTargetLengths young_lengths = young_list_target_lengths(rs_lengths);
_young_list_target_length = young_lengths.first;
return young_lengths.second;
}
G1Policy::YoungTargetLengths G1Policy::young_list_target_lengths(size_t rs_lengths) const {
G1DefaultPolicy::YoungTargetLengths G1DefaultPolicy::young_list_target_lengths(size_t rs_lengths) const {
YoungTargetLengths result;
// Calculate the absolute and desired min bounds first.
@ -252,10 +253,10 @@ G1Policy::YoungTargetLengths G1Policy::young_list_target_lengths(size_t rs_lengt
}
uint
G1Policy::calculate_young_list_target_length(size_t rs_lengths,
uint base_min_length,
uint desired_min_length,
uint desired_max_length) const {
G1DefaultPolicy::calculate_young_list_target_length(size_t rs_lengths,
uint base_min_length,
uint desired_min_length,
uint desired_max_length) const {
assert(adaptive_young_list_length(), "pre-condition");
assert(collector_state()->gcs_are_young(), "only call this for young GCs");
@ -355,7 +356,7 @@ G1Policy::calculate_young_list_target_length(size_t rs_lengths,
return base_min_length + min_young_length;
}
double G1Policy::predict_survivor_regions_evac_time() const {
double G1DefaultPolicy::predict_survivor_regions_evac_time() const {
double survivor_regions_evac_time = 0.0;
for (HeapRegion * r = _g1->young_list()->first_survivor_region();
r != NULL && r != _g1->young_list()->last_survivor_region()->get_next_young_region();
@ -365,7 +366,7 @@ double G1Policy::predict_survivor_regions_evac_time() const {
return survivor_regions_evac_time;
}
void G1Policy::revise_young_list_target_length_if_necessary(size_t rs_lengths) {
void G1DefaultPolicy::revise_young_list_target_length_if_necessary(size_t rs_lengths) {
guarantee( adaptive_young_list_length(), "should not call this otherwise" );
if (rs_lengths > _rs_lengths_prediction) {
@ -377,25 +378,25 @@ void G1Policy::revise_young_list_target_length_if_necessary(size_t rs_lengths) {
}
}
void G1Policy::update_rs_lengths_prediction() {
void G1DefaultPolicy::update_rs_lengths_prediction() {
update_rs_lengths_prediction(_analytics->predict_rs_lengths());
}
void G1Policy::update_rs_lengths_prediction(size_t prediction) {
void G1DefaultPolicy::update_rs_lengths_prediction(size_t prediction) {
if (collector_state()->gcs_are_young() && adaptive_young_list_length()) {
_rs_lengths_prediction = prediction;
}
}
#ifndef PRODUCT
bool G1Policy::verify_young_ages() {
bool G1DefaultPolicy::verify_young_ages() {
HeapRegion* head = _g1->young_list()->first_region();
return
verify_young_ages(head, _short_lived_surv_rate_group);
// also call verify_young_ages on any additional surv rate groups
}
bool G1Policy::verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group) {
bool G1DefaultPolicy::verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group) {
guarantee( surv_rate_group != NULL, "pre-condition" );
const char* name = surv_rate_group->name();
@ -431,13 +432,13 @@ bool G1Policy::verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_grou
}
#endif // PRODUCT
void G1Policy::record_full_collection_start() {
void G1DefaultPolicy::record_full_collection_start() {
_full_collection_start_sec = os::elapsedTime();
// Release the future to-space so that it is available for compaction into.
collector_state()->set_full_collection(true);
}
void G1Policy::record_full_collection_end() {
void G1DefaultPolicy::record_full_collection_end() {
// Consider this like a collection pause for the purposes of allocation
// since last pause.
double end_sec = os::elapsedTime();
@ -472,7 +473,7 @@ void G1Policy::record_full_collection_end() {
record_pause(FullGC, _full_collection_start_sec, end_sec);
}
void G1Policy::record_collection_pause_start(double start_time_sec) {
void G1DefaultPolicy::record_collection_pause_start(double start_time_sec) {
// We only need to do this here as the policy will only be applied
// to the GC we're about to start. so, no point is calculating this
// every time we calculate / recalculate the target young length.
@ -497,18 +498,18 @@ void G1Policy::record_collection_pause_start(double start_time_sec) {
assert( verify_young_ages(), "region age verification" );
}
void G1Policy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) {
void G1DefaultPolicy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) {
collector_state()->set_during_marking(true);
assert(!collector_state()->initiate_conc_mark_if_possible(), "we should have cleared it by now");
collector_state()->set_during_initial_mark_pause(false);
}
void G1Policy::record_concurrent_mark_remark_start() {
void G1DefaultPolicy::record_concurrent_mark_remark_start() {
_mark_remark_start_sec = os::elapsedTime();
collector_state()->set_during_marking(false);
}
void G1Policy::record_concurrent_mark_remark_end() {
void G1DefaultPolicy::record_concurrent_mark_remark_end() {
double end_time_sec = os::elapsedTime();
double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;
_analytics->report_concurrent_mark_remark_times_ms(elapsed_time_ms);
@ -517,11 +518,11 @@ void G1Policy::record_concurrent_mark_remark_end() {
record_pause(Remark, _mark_remark_start_sec, end_time_sec);
}
void G1Policy::record_concurrent_mark_cleanup_start() {
void G1DefaultPolicy::record_concurrent_mark_cleanup_start() {
_mark_cleanup_start_sec = os::elapsedTime();
}
void G1Policy::record_concurrent_mark_cleanup_completed() {
void G1DefaultPolicy::record_concurrent_mark_cleanup_completed() {
bool should_continue_with_reclaim = next_gc_should_be_mixed("request last young-only gc",
"skip last young-only gc");
collector_state()->set_last_young_gc(should_continue_with_reclaim);
@ -532,22 +533,22 @@ void G1Policy::record_concurrent_mark_cleanup_completed() {
collector_state()->set_in_marking_window(false);
}
double G1Policy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const {
double G1DefaultPolicy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const {
return phase_times()->average_time_ms(phase);
}
double G1Policy::young_other_time_ms() const {
double G1DefaultPolicy::young_other_time_ms() const {
return phase_times()->young_cset_choice_time_ms() +
phase_times()->young_free_cset_time_ms();
}
double G1Policy::non_young_other_time_ms() const {
double G1DefaultPolicy::non_young_other_time_ms() const {
return phase_times()->non_young_cset_choice_time_ms() +
phase_times()->non_young_free_cset_time_ms();
}
double G1Policy::other_time_ms(double pause_time_ms) const {
double G1DefaultPolicy::other_time_ms(double pause_time_ms) const {
return pause_time_ms -
average_time_ms(G1GCPhaseTimes::UpdateRS) -
average_time_ms(G1GCPhaseTimes::ScanRS) -
@ -555,19 +556,19 @@ double G1Policy::other_time_ms(double pause_time_ms) const {
average_time_ms(G1GCPhaseTimes::Termination);
}
double G1Policy::constant_other_time_ms(double pause_time_ms) const {
double G1DefaultPolicy::constant_other_time_ms(double pause_time_ms) const {
return other_time_ms(pause_time_ms) - young_other_time_ms() - non_young_other_time_ms();
}
CollectionSetChooser* G1Policy::cset_chooser() const {
CollectionSetChooser* G1DefaultPolicy::cset_chooser() const {
return _collection_set->cset_chooser();
}
bool G1Policy::about_to_start_mixed_phase() const {
bool G1DefaultPolicy::about_to_start_mixed_phase() const {
return _g1->concurrent_mark()->cmThread()->during_cycle() || collector_state()->last_young_gc();
}
bool G1Policy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
bool G1DefaultPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
if (about_to_start_mixed_phase()) {
return false;
}
@ -592,7 +593,7 @@ bool G1Policy::need_to_start_conc_mark(const char* source, size_t alloc_word_siz
// Anything below that is considered to be zero
#define MIN_TIMER_GRANULARITY 0.0000001
void G1Policy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) {
void G1DefaultPolicy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) {
double end_time_sec = os::elapsedTime();
size_t cur_used_bytes = _g1->used();
@ -778,7 +779,7 @@ void G1Policy::record_collection_pause_end(double pause_time_ms, size_t cards_sc
cset_chooser()->verify();
}
G1IHOPControl* G1Policy::create_ihop_control(const G1Predictions* predictor){
G1IHOPControl* G1DefaultPolicy::create_ihop_control(const G1Predictions* predictor){
if (G1UseAdaptiveIHOP) {
return new G1AdaptiveIHOPControl(InitiatingHeapOccupancyPercent,
predictor,
@ -789,7 +790,7 @@ G1IHOPControl* G1Policy::create_ihop_control(const G1Predictions* predictor){
}
}
void G1Policy::update_ihop_prediction(double mutator_time_s,
void G1DefaultPolicy::update_ihop_prediction(double mutator_time_s,
size_t mutator_alloc_bytes,
size_t young_gen_size) {
// Always try to update IHOP prediction. Even evacuation failures give information
@ -827,15 +828,15 @@ void G1Policy::update_ihop_prediction(double mutator_time_s,
}
}
void G1Policy::report_ihop_statistics() {
void G1DefaultPolicy::report_ihop_statistics() {
_ihop_control->print();
}
void G1Policy::print_phases() {
void G1DefaultPolicy::print_phases() {
phase_times()->print();
}
double G1Policy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const {
double G1DefaultPolicy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const {
TruncatedSeq* seq = surv_rate_group->get_seq(age);
guarantee(seq->num() > 0, "There should be some young gen survivor samples available. Tried to access with age %d", age);
double pred = _predictor.get_new_prediction(seq);
@ -845,15 +846,15 @@ double G1Policy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) c
return pred;
}
double G1Policy::predict_yg_surv_rate(int age) const {
double G1DefaultPolicy::predict_yg_surv_rate(int age) const {
return predict_yg_surv_rate(age, _short_lived_surv_rate_group);
}
double G1Policy::accum_yg_surv_rate_pred(int age) const {
double G1DefaultPolicy::accum_yg_surv_rate_pred(int age) const {
return _short_lived_surv_rate_group->accum_surv_rate_pred(age);
}
double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards,
double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
size_t scanned_cards) const {
return
_analytics->predict_rs_update_time_ms(pending_cards) +
@ -861,13 +862,13 @@ double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards,
_analytics->predict_constant_other_time_ms();
}
double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards) const {
double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards) const {
size_t rs_length = _analytics->predict_rs_lengths() + _analytics->predict_rs_length_diff();
size_t card_num = _analytics->predict_card_num(rs_length, collector_state()->gcs_are_young());
return predict_base_elapsed_time_ms(pending_cards, card_num);
}
size_t G1Policy::predict_bytes_to_copy(HeapRegion* hr) const {
size_t G1DefaultPolicy::predict_bytes_to_copy(HeapRegion* hr) const {
size_t bytes_to_copy;
if (hr->is_marked())
bytes_to_copy = hr->max_live_bytes();
@ -880,7 +881,7 @@ size_t G1Policy::predict_bytes_to_copy(HeapRegion* hr) const {
return bytes_to_copy;
}
double G1Policy::predict_region_elapsed_time_ms(HeapRegion* hr,
double G1DefaultPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
bool for_young_gc) const {
size_t rs_length = hr->rem_set()->occupied();
// Predicting the number of cards is based on which type of GC
@ -903,30 +904,30 @@ double G1Policy::predict_region_elapsed_time_ms(HeapRegion* hr,
}
void G1Policy::print_yg_surv_rate_info() const {
void G1DefaultPolicy::print_yg_surv_rate_info() const {
#ifndef PRODUCT
_short_lived_surv_rate_group->print_surv_rate_summary();
// add this call for any other surv rate groups
#endif // PRODUCT
}
bool G1Policy::is_young_list_full() const {
bool G1DefaultPolicy::is_young_list_full() const {
uint young_list_length = _g1->young_list()->length();
uint young_list_target_length = _young_list_target_length;
return young_list_length >= young_list_target_length;
}
bool G1Policy::can_expand_young_list() const {
bool G1DefaultPolicy::can_expand_young_list() const {
uint young_list_length = _g1->young_list()->length();
uint young_list_max_length = _young_list_max_length;
return young_list_length < young_list_max_length;
}
bool G1Policy::adaptive_young_list_length() const {
bool G1DefaultPolicy::adaptive_young_list_length() const {
return _young_gen_sizer.adaptive_young_list_length();
}
void G1Policy::update_max_gc_locker_expansion() {
void G1DefaultPolicy::update_max_gc_locker_expansion() {
uint expansion_region_num = 0;
if (GCLockerEdenExpansionPercent > 0) {
double perc = (double) GCLockerEdenExpansionPercent / 100.0;
@ -942,7 +943,7 @@ void G1Policy::update_max_gc_locker_expansion() {
}
// Calculates survivor space parameters.
void G1Policy::update_survivors_policy() {
void G1DefaultPolicy::update_survivors_policy() {
double max_survivor_regions_d =
(double) _young_list_target_length / (double) SurvivorRatio;
// We use ceiling so that if max_survivor_regions_d is > 0.0 (but
@ -953,7 +954,7 @@ void G1Policy::update_survivors_policy() {
HeapRegion::GrainWords * _max_survivor_regions, _policy_counters);
}
bool G1Policy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
bool G1DefaultPolicy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
// We actually check whether we are marking here and not if we are in a
// reclamation phase. This means that we will schedule a concurrent mark
// even while we are still in the process of reclaiming memory.
@ -968,12 +969,12 @@ bool G1Policy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
}
}
void G1Policy::initiate_conc_mark() {
void G1DefaultPolicy::initiate_conc_mark() {
collector_state()->set_during_initial_mark_pause(true);
collector_state()->set_initiate_conc_mark_if_possible(false);
}
void G1Policy::decide_on_conc_mark_initiation() {
void G1DefaultPolicy::decide_on_conc_mark_initiation() {
// We are about to decide on whether this pause will be an
// initial-mark pause.
@ -1019,7 +1020,7 @@ void G1Policy::decide_on_conc_mark_initiation() {
}
}
void G1Policy::record_concurrent_mark_cleanup_end() {
void G1DefaultPolicy::record_concurrent_mark_cleanup_end() {
cset_chooser()->rebuild(_g1->workers(), _g1->num_regions());
double end_sec = os::elapsedTime();
@ -1030,7 +1031,7 @@ void G1Policy::record_concurrent_mark_cleanup_end() {
record_pause(Cleanup, _mark_cleanup_start_sec, end_sec);
}
double G1Policy::reclaimable_bytes_perc(size_t reclaimable_bytes) const {
double G1DefaultPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) const {
// Returns the given amount of reclaimable bytes (that represents
// the amount of reclaimable space still to be collected) as a
// percentage of the current heap capacity.
@ -1038,7 +1039,7 @@ double G1Policy::reclaimable_bytes_perc(size_t reclaimable_bytes) const {
return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes;
}
void G1Policy::maybe_start_marking() {
void G1DefaultPolicy::maybe_start_marking() {
if (need_to_start_conc_mark("end of GC")) {
// Note: this might have already been set, if during the last
// pause we decided to start a cycle but at the beginning of
@ -1047,7 +1048,7 @@ void G1Policy::maybe_start_marking() {
}
}
G1Policy::PauseKind G1Policy::young_gc_pause_kind() const {
G1DefaultPolicy::PauseKind G1DefaultPolicy::young_gc_pause_kind() const {
assert(!collector_state()->full_collection(), "must be");
if (collector_state()->during_initial_mark_pause()) {
assert(collector_state()->last_gc_was_young(), "must be");
@ -1069,7 +1070,7 @@ G1Policy::PauseKind G1Policy::young_gc_pause_kind() const {
}
}
void G1Policy::record_pause(PauseKind kind, double start, double end) {
void G1DefaultPolicy::record_pause(PauseKind kind, double start, double end) {
// Manage the MMU tracker. For some reason it ignores Full GCs.
if (kind != FullGC) {
_mmu_tracker->add_pause(start, end);
@ -1096,11 +1097,11 @@ void G1Policy::record_pause(PauseKind kind, double start, double end) {
}
}
void G1Policy::abort_time_to_mixed_tracking() {
void G1DefaultPolicy::abort_time_to_mixed_tracking() {
_initial_mark_to_mixed.reset();
}
bool G1Policy::next_gc_should_be_mixed(const char* true_action_str,
bool G1DefaultPolicy::next_gc_should_be_mixed(const char* true_action_str,
const char* false_action_str) const {
if (cset_chooser()->is_empty()) {
log_debug(gc, ergo)("%s (candidate old regions not available)", false_action_str);
@ -1121,7 +1122,7 @@ bool G1Policy::next_gc_should_be_mixed(const char* true_action_str,
return true;
}
uint G1Policy::calc_min_old_cset_length() const {
uint G1DefaultPolicy::calc_min_old_cset_length() const {
// The min old CSet region bound is based on the maximum desired
// number of mixed GCs after a cycle. I.e., even if some old regions
// look expensive, we should add them to the CSet anyway to make
@ -1142,7 +1143,7 @@ uint G1Policy::calc_min_old_cset_length() const {
return (uint) result;
}
uint G1Policy::calc_max_old_cset_length() const {
uint G1DefaultPolicy::calc_max_old_cset_length() const {
// The max old CSet region bound is based on the threshold expressed
// as a percentage of the heap size. I.e., it should bound the
// number of old regions added to the CSet irrespective of how many
@ -1159,7 +1160,7 @@ uint G1Policy::calc_max_old_cset_length() const {
return (uint) result;
}
void G1Policy::finalize_collection_set(double target_pause_time_ms) {
void G1DefaultPolicy::finalize_collection_set(double target_pause_time_ms) {
double time_remaining_ms = _collection_set->finalize_young_part(target_pause_time_ms);
_collection_set->finalize_old_part(time_remaining_ms);
}

440
hotspot/src/share/vm/gc/g1/g1DefaultPolicy.hpp Normal file
View File

@ -0,0 +1,440 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. 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.
*
*/
#ifndef SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP
#define SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP
#include "gc/g1/g1CollectorState.hpp"
#include "gc/g1/g1GCPhaseTimes.hpp"
#include "gc/g1/g1InCSetState.hpp"
#include "gc/g1/g1InitialMarkToMixedTimeTracker.hpp"
#include "gc/g1/g1MMUTracker.hpp"
#include "gc/g1/g1Predictions.hpp"
#include "gc/g1/g1Policy.hpp"
#include "gc/g1/g1YoungGenSizer.hpp"
#include "gc/shared/gcCause.hpp"
#include "utilities/pair.hpp"
// A G1Policy makes policy decisions that determine the
// characteristics of the collector. Examples include:
// * choice of collection set.
// * when to collect.
class HeapRegion;
class G1CollectionSet;
class CollectionSetChooser;
class G1IHOPControl;
class G1Analytics;
class G1YoungGenSizer;
class GCPolicyCounters;
class G1DefaultPolicy: public G1Policy {
private:
static G1IHOPControl* create_ihop_control(const G1Predictions* predictor);
// Update the IHOP control with necessary statistics.
void update_ihop_prediction(double mutator_time_s,
size_t mutator_alloc_bytes,
size_t young_gen_size);
void report_ihop_statistics();
G1Predictions _predictor;
G1Analytics* _analytics;
G1MMUTracker* _mmu_tracker;
G1IHOPControl* _ihop_control;
GCPolicyCounters* _policy_counters;
double _full_collection_start_sec;
uint _young_list_target_length;
uint _young_list_fixed_length;
// The max number of regions we can extend the eden by while the GC
// locker is active. This should be >= _young_list_target_length;
uint _young_list_max_length;
// SurvRateGroups below must be initialized after the predictor because they
// indirectly use it through this object passed to their constructor.
SurvRateGroup* _short_lived_surv_rate_group;
SurvRateGroup* _survivor_surv_rate_group;
double _reserve_factor;
// This will be set when the heap is expanded
// for the first time during initialization.
uint _reserve_regions;
G1YoungGenSizer _young_gen_sizer;
uint _free_regions_at_end_of_collection;
size_t _max_rs_lengths;
size_t _rs_lengths_prediction;
#ifndef PRODUCT
bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group);
#endif // PRODUCT
size_t _pending_cards;
// The amount of allocated bytes in old gen during the last mutator and the following
// young GC phase.
size_t _bytes_allocated_in_old_since_last_gc;
G1InitialMarkToMixedTimeTracker _initial_mark_to_mixed;
public:
const G1Predictions& predictor() const { return _predictor; }
const G1Analytics* analytics() const { return const_cast<const G1Analytics*>(_analytics); }
// Add the given number of bytes to the total number of allocated bytes in the old gen.
void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }
// Accessors
void set_region_eden(HeapRegion* hr, int young_index_in_cset) {
hr->set_eden();
hr->install_surv_rate_group(_short_lived_surv_rate_group);
hr->set_young_index_in_cset(young_index_in_cset);
}
void set_region_survivor(HeapRegion* hr, int young_index_in_cset) {
assert(hr->is_survivor(), "pre-condition");
hr->install_surv_rate_group(_survivor_surv_rate_group);
hr->set_young_index_in_cset(young_index_in_cset);
}
#ifndef PRODUCT
bool verify_young_ages();
#endif // PRODUCT
void record_max_rs_lengths(size_t rs_lengths) {
_max_rs_lengths = rs_lengths;
}
double predict_base_elapsed_time_ms(size_t pending_cards) const;
double predict_base_elapsed_time_ms(size_t pending_cards,
size_t scanned_cards) const;
size_t predict_bytes_to_copy(HeapRegion* hr) const;
double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const;
double predict_survivor_regions_evac_time() const;
bool should_update_surv_rate_group_predictors() {
return collector_state()->last_gc_was_young() && !collector_state()->in_marking_window();
}
void cset_regions_freed() {
bool update = should_update_surv_rate_group_predictors();
_short_lived_surv_rate_group->all_surviving_words_recorded(update);
_survivor_surv_rate_group->all_surviving_words_recorded(update);
}
G1MMUTracker* mmu_tracker() {
return _mmu_tracker;
}
const G1MMUTracker* mmu_tracker() const {
return _mmu_tracker;
}
double max_pause_time_ms() const {
return _mmu_tracker->max_gc_time() * 1000.0;
}
// Returns an estimate of the survival rate of the region at yg-age
// "yg_age".
double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const;
double predict_yg_surv_rate(int age) const;
double accum_yg_surv_rate_pred(int age) const;
protected:
G1CollectionSet* _collection_set;
virtual double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;
virtual double other_time_ms(double pause_time_ms) const;
double young_other_time_ms() const;
double non_young_other_time_ms() const;
double constant_other_time_ms(double pause_time_ms) const;
CollectionSetChooser* cset_chooser() const;
private:
// The number of bytes copied during the GC.
size_t _bytes_copied_during_gc;
// Stash a pointer to the g1 heap.
G1CollectedHeap* _g1;
G1GCPhaseTimes* _phase_times;
// This set of variables tracks the collector efficiency, in order to
// determine whether we should initiate a new marking.
double _mark_remark_start_sec;
double _mark_cleanup_start_sec;
// Updates the internal young list maximum and target lengths. Returns the
// unbounded young list target length.
uint update_young_list_max_and_target_length();
uint update_young_list_max_and_target_length(size_t rs_lengths);
// Update the young list target length either by setting it to the
// desired fixed value or by calculating it using G1's pause
// prediction model. If no rs_lengths parameter is passed, predict
// the RS lengths using the prediction model, otherwise use the
// given rs_lengths as the prediction.
// Returns the unbounded young list target length.
uint update_young_list_target_length(size_t rs_lengths);
// Calculate and return the minimum desired young list target
// length. This is the minimum desired young list length according
// to the user's inputs.
uint calculate_young_list_desired_min_length(uint base_min_length) const;
// Calculate and return the maximum desired young list target
// length. This is the maximum desired young list length according
// to the user's inputs.
uint calculate_young_list_desired_max_length() const;
// Calculate and return the maximum young list target length that
// can fit into the pause time goal. The parameters are: rs_lengths
// represent the prediction of how large the young RSet lengths will
// be, base_min_length is the already existing number of regions in
// the young list, min_length and max_length are the desired min and
// max young list length according to the user's inputs.
uint calculate_young_list_target_length(size_t rs_lengths,
uint base_min_length,
uint desired_min_length,
uint desired_max_length) const;
// Result of the bounded_young_list_target_length() method, containing both the
// bounded as well as the unbounded young list target lengths in this order.
typedef Pair<uint, uint, StackObj> YoungTargetLengths;
YoungTargetLengths young_list_target_lengths(size_t rs_lengths) const;
void update_rs_lengths_prediction();
void update_rs_lengths_prediction(size_t prediction);
// Check whether a given young length (young_length) fits into the
// given target pause time and whether the prediction for the amount
// of objects to be copied for the given length will fit into the
// given free space (expressed by base_free_regions). It is used by
// calculate_young_list_target_length().
bool predict_will_fit(uint young_length, double base_time_ms,
uint base_free_regions, double target_pause_time_ms) const;
public:
size_t pending_cards() const { return _pending_cards; }
// Calculate the minimum number of old regions we'll add to the CSet
// during a mixed GC.
uint calc_min_old_cset_length() const;
// Calculate the maximum number of old regions we'll add to the CSet
// during a mixed GC.
uint calc_max_old_cset_length() const;
// Returns the given amount of uncollected reclaimable space
// as a percentage of the current heap capacity.
double reclaimable_bytes_perc(size_t reclaimable_bytes) const;
private:
// Sets up marking if proper conditions are met.
void maybe_start_marking();
// The kind of STW pause.
enum PauseKind {
FullGC,
YoungOnlyGC,
MixedGC,
LastYoungGC,
InitialMarkGC,
Cleanup,
Remark
};
// Calculate PauseKind from internal state.
PauseKind young_gc_pause_kind() const;
// Record the given STW pause with the given start and end times (in s).
void record_pause(PauseKind kind, double start, double end);
// Indicate that we aborted marking before doing any mixed GCs.
void abort_time_to_mixed_tracking();
public:
G1DefaultPolicy();
virtual ~G1DefaultPolicy();
G1CollectorState* collector_state() const;
G1GCPhaseTimes* phase_times() const { return _phase_times; }
// Check the current value of the young list RSet lengths and
// compare it against the last prediction. If the current value is
// higher, recalculate the young list target length prediction.
void revise_young_list_target_length_if_necessary(size_t rs_lengths);
// This should be called after the heap is resized.
void record_new_heap_size(uint new_number_of_regions);
void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set);
virtual void note_gc_start();
bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0);
bool about_to_start_mixed_phase() const;
// Record the start and end of an evacuation pause.
void record_collection_pause_start(double start_time_sec);
void record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc);
// Record the start and end of a full collection.
void record_full_collection_start();
void record_full_collection_end();
// Must currently be called while the world is stopped.
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
// Record start and end of remark.
void record_concurrent_mark_remark_start();
void record_concurrent_mark_remark_end();
// Record start, end, and completion of cleanup.
void record_concurrent_mark_cleanup_start();
void record_concurrent_mark_cleanup_end();
void record_concurrent_mark_cleanup_completed();
virtual void print_phases();
// Record how much space we copied during a GC. This is typically
// called when a GC alloc region is being retired.
void record_bytes_copied_during_gc(size_t bytes) {
_bytes_copied_during_gc += bytes;
}
// The amount of space we copied during a GC.
size_t bytes_copied_during_gc() const {
return _bytes_copied_during_gc;
}
// Determine whether there are candidate regions so that the
// next GC should be mixed. The two action strings are used
// in the ergo output when the method returns true or false.
bool next_gc_should_be_mixed(const char* true_action_str,
const char* false_action_str) const;
virtual void finalize_collection_set(double target_pause_time_ms);
private:
// Set the state to start a concurrent marking cycle and clear
// _initiate_conc_mark_if_possible because it has now been
// acted on.
void initiate_conc_mark();
public:
// This sets the initiate_conc_mark_if_possible() flag to start a
// new cycle, as long as we are not already in one. It's best if it
// is called during a safepoint when the test whether a cycle is in
// progress or not is stable.
bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);
// This is called at the very beginning of an evacuation pause (it
// has to be the first thing that the pause does). If
// initiate_conc_mark_if_possible() is true, and the concurrent
// marking thread has completed its work during the previous cycle,
// it will set during_initial_mark_pause() to so that the pause does
// the initial-mark work and start a marking cycle.
void decide_on_conc_mark_initiation();
// Print stats on young survival ratio
void print_yg_surv_rate_info() const;
void finished_recalculating_age_indexes(bool is_survivors) {
if (is_survivors) {
_survivor_surv_rate_group->finished_recalculating_age_indexes();
} else {
_short_lived_surv_rate_group->finished_recalculating_age_indexes();
}
}
size_t young_list_target_length() const { return _young_list_target_length; }
bool is_young_list_full() const;
bool can_expand_young_list() const;
uint young_list_max_length() const {
return _young_list_max_length;
}
bool adaptive_young_list_length() const;
virtual bool should_process_references() const {
return true;
}
private:
//
// Survivor regions policy.
//
// Current tenuring threshold, set to 0 if the collector reaches the
// maximum amount of survivors regions.
uint _tenuring_threshold;
// The limit on the number of regions allocated for survivors.
uint _max_survivor_regions;
AgeTable _survivors_age_table;
public:
uint tenuring_threshold() const { return _tenuring_threshold; }
uint max_survivor_regions() {
return _max_survivor_regions;
}
void note_start_adding_survivor_regions() {
_survivor_surv_rate_group->start_adding_regions();
}
void note_stop_adding_survivor_regions() {
_survivor_surv_rate_group->stop_adding_regions();
}
void record_age_table(AgeTable* age_table) {
_survivors_age_table.merge(age_table);
}
void update_max_gc_locker_expansion();
// Calculates survivor space parameters.
void update_survivors_policy();
};
#endif // SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP

364
hotspot/src/share/vm/gc/g1/g1Policy.hpp
View File

@ -46,321 +46,106 @@ class CollectionSetChooser;
class G1IHOPControl;
class G1Analytics;
class G1YoungGenSizer;
class GCPolicyCounters;
class G1Policy: public CHeapObj<mtGC> {
private:
static G1IHOPControl* create_ihop_control(const G1Predictions* predictor);
// Update the IHOP control with necessary statistics.
void update_ihop_prediction(double mutator_time_s,
size_t mutator_alloc_bytes,
size_t young_gen_size);
void report_ihop_statistics();
G1Predictions _predictor;
G1Analytics* _analytics;
G1MMUTracker* _mmu_tracker;
G1IHOPControl* _ihop_control;
GCPolicyCounters* _policy_counters;
double _full_collection_start_sec;
uint _young_list_target_length;
uint _young_list_fixed_length;
// The max number of regions we can extend the eden by while the GC
// locker is active. This should be >= _young_list_target_length;
uint _young_list_max_length;
// SurvRateGroups below must be initialized after the predictor because they
// indirectly use it through this object passed to their constructor.
SurvRateGroup* _short_lived_surv_rate_group;
SurvRateGroup* _survivor_surv_rate_group;
double _reserve_factor;
// This will be set when the heap is expanded
// for the first time during initialization.
uint _reserve_regions;
G1YoungGenSizer _young_gen_sizer;
uint _free_regions_at_end_of_collection;
size_t _max_rs_lengths;
size_t _rs_lengths_prediction;
#ifndef PRODUCT
bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group);
#endif // PRODUCT
size_t _pending_cards;
// The amount of allocated bytes in old gen during the last mutator and the following
// young GC phase.
size_t _bytes_allocated_in_old_since_last_gc;
G1InitialMarkToMixedTimeTracker _initial_mark_to_mixed;
public:
const G1Predictions& predictor() const { return _predictor; }
const G1Analytics* analytics() const { return const_cast<const G1Analytics*>(_analytics); }
virtual const G1Predictions& predictor() const = 0;
virtual const G1Analytics* analytics() const = 0;
// Add the given number of bytes to the total number of allocated bytes in the old gen.
void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }
virtual void add_bytes_allocated_in_old_since_last_gc(size_t bytes) = 0;
// Accessors
void set_region_eden(HeapRegion* hr, int young_index_in_cset) {
hr->set_eden();
hr->install_surv_rate_group(_short_lived_surv_rate_group);
hr->set_young_index_in_cset(young_index_in_cset);
}
virtual void set_region_eden(HeapRegion* hr, int young_index_in_cset) = 0;
virtual void set_region_survivor(HeapRegion* hr, int young_index_in_cset) = 0;
void set_region_survivor(HeapRegion* hr, int young_index_in_cset) {
assert(hr->is_survivor(), "pre-condition");
hr->install_surv_rate_group(_survivor_surv_rate_group);
hr->set_young_index_in_cset(young_index_in_cset);
}
virtual void record_max_rs_lengths(size_t rs_lengths) = 0;
#ifndef PRODUCT
bool verify_young_ages();
#endif // PRODUCT
virtual double predict_base_elapsed_time_ms(size_t pending_cards) const = 0;
virtual double predict_base_elapsed_time_ms(size_t pending_cards,
size_t scanned_cards) const = 0;
void record_max_rs_lengths(size_t rs_lengths) {
_max_rs_lengths = rs_lengths;
}
virtual double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const = 0;
virtual void cset_regions_freed() = 0;
double predict_base_elapsed_time_ms(size_t pending_cards) const;
double predict_base_elapsed_time_ms(size_t pending_cards,
size_t scanned_cards) const;
size_t predict_bytes_to_copy(HeapRegion* hr) const;
double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const;
virtual G1MMUTracker* mmu_tracker() = 0;
double predict_survivor_regions_evac_time() const;
virtual const G1MMUTracker* mmu_tracker() const = 0;
bool should_update_surv_rate_group_predictors() {
return collector_state()->last_gc_was_young() && !collector_state()->in_marking_window();
}
virtual double max_pause_time_ms() const = 0;
void cset_regions_freed() {
bool update = should_update_surv_rate_group_predictors();
_short_lived_surv_rate_group->all_surviving_words_recorded(update);
_survivor_surv_rate_group->all_surviving_words_recorded(update);
}
G1MMUTracker* mmu_tracker() {
return _mmu_tracker;
}
const G1MMUTracker* mmu_tracker() const {
return _mmu_tracker;
}
double max_pause_time_ms() const {
return _mmu_tracker->max_gc_time() * 1000.0;
}
// Returns an estimate of the survival rate of the region at yg-age
// "yg_age".
double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const;
double predict_yg_surv_rate(int age) const;
double accum_yg_surv_rate_pred(int age) const;
protected:
G1CollectionSet* _collection_set;
virtual double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;
virtual double other_time_ms(double pause_time_ms) const;
double young_other_time_ms() const;
double non_young_other_time_ms() const;
double constant_other_time_ms(double pause_time_ms) const;
CollectionSetChooser* cset_chooser() const;
private:
// The number of bytes copied during the GC.
size_t _bytes_copied_during_gc;
// Stash a pointer to the g1 heap.
G1CollectedHeap* _g1;
G1GCPhaseTimes* _phase_times;
// This set of variables tracks the collector efficiency, in order to
// determine whether we should initiate a new marking.
double _mark_remark_start_sec;
double _mark_cleanup_start_sec;
// Updates the internal young list maximum and target lengths. Returns the
// unbounded young list target length.
uint update_young_list_max_and_target_length();
uint update_young_list_max_and_target_length(size_t rs_lengths);
// Update the young list target length either by setting it to the
// desired fixed value or by calculating it using G1's pause
// prediction model. If no rs_lengths parameter is passed, predict
// the RS lengths using the prediction model, otherwise use the
// given rs_lengths as the prediction.
// Returns the unbounded young list target length.
uint update_young_list_target_length(size_t rs_lengths);
// Calculate and return the minimum desired young list target
// length. This is the minimum desired young list length according
// to the user's inputs.
uint calculate_young_list_desired_min_length(uint base_min_length) const;
// Calculate and return the maximum desired young list target
// length. This is the maximum desired young list length according
// to the user's inputs.
uint calculate_young_list_desired_max_length() const;
// Calculate and return the maximum young list target length that
// can fit into the pause time goal. The parameters are: rs_lengths
// represent the prediction of how large the young RSet lengths will
// be, base_min_length is the already existing number of regions in
// the young list, min_length and max_length are the desired min and
// max young list length according to the user's inputs.
uint calculate_young_list_target_length(size_t rs_lengths,
uint base_min_length,
uint desired_min_length,
uint desired_max_length) const;
// Result of the bounded_young_list_target_length() method, containing both the
// bounded as well as the unbounded young list target lengths in this order.
typedef Pair<uint, uint, StackObj> YoungTargetLengths;
YoungTargetLengths young_list_target_lengths(size_t rs_lengths) const;
void update_rs_lengths_prediction();
void update_rs_lengths_prediction(size_t prediction);
// Check whether a given young length (young_length) fits into the
// given target pause time and whether the prediction for the amount
// of objects to be copied for the given length will fit into the
// given free space (expressed by base_free_regions). It is used by
// calculate_young_list_target_length().
bool predict_will_fit(uint young_length, double base_time_ms,
uint base_free_regions, double target_pause_time_ms) const;
public:
size_t pending_cards() const { return _pending_cards; }
virtual size_t pending_cards() const = 0;
// Calculate the minimum number of old regions we'll add to the CSet
// during a mixed GC.
uint calc_min_old_cset_length() const;
virtual uint calc_min_old_cset_length() const = 0;
// Calculate the maximum number of old regions we'll add to the CSet
// during a mixed GC.
uint calc_max_old_cset_length() const;
virtual uint calc_max_old_cset_length() const = 0;
// Returns the given amount of uncollected reclaimable space
// as a percentage of the current heap capacity.
double reclaimable_bytes_perc(size_t reclaimable_bytes) const;
virtual double reclaimable_bytes_perc(size_t reclaimable_bytes) const = 0;
private:
// Sets up marking if proper conditions are met.
void maybe_start_marking();
virtual ~G1Policy() {}
// The kind of STW pause.
enum PauseKind {
FullGC,
YoungOnlyGC,
MixedGC,
LastYoungGC,
InitialMarkGC,
Cleanup,
Remark
};
virtual G1CollectorState* collector_state() const = 0;
// Calculate PauseKind from internal state.
PauseKind young_gc_pause_kind() const;
// Record the given STW pause with the given start and end times (in s).
void record_pause(PauseKind kind, double start, double end);
// Indicate that we aborted marking before doing any mixed GCs.
void abort_time_to_mixed_tracking();
public:
G1Policy();
virtual ~G1Policy();
G1CollectorState* collector_state() const;
G1GCPhaseTimes* phase_times() const { return _phase_times; }
virtual G1GCPhaseTimes* phase_times() const = 0;
// Check the current value of the young list RSet lengths and
// compare it against the last prediction. If the current value is
// higher, recalculate the young list target length prediction.
void revise_young_list_target_length_if_necessary(size_t rs_lengths);
virtual void revise_young_list_target_length_if_necessary(size_t rs_lengths) = 0;
// This should be called after the heap is resized.
void record_new_heap_size(uint new_number_of_regions);
virtual void record_new_heap_size(uint new_number_of_regions) = 0;
void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set);
virtual void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) = 0;
virtual void note_gc_start();
virtual void note_gc_start() = 0;
bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0);
bool about_to_start_mixed_phase() const;
virtual bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0) = 0;
// Record the start and end of an evacuation pause.
void record_collection_pause_start(double start_time_sec);
void record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc);
virtual void record_collection_pause_start(double start_time_sec) = 0;
virtual void record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) = 0;
// Record the start and end of a full collection.
void record_full_collection_start();
void record_full_collection_end();
virtual void record_full_collection_start() = 0;
virtual void record_full_collection_end() = 0;
// Must currently be called while the world is stopped.
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
virtual void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) = 0;
// Record start and end of remark.
void record_concurrent_mark_remark_start();
void record_concurrent_mark_remark_end();
virtual void record_concurrent_mark_remark_start() = 0;
virtual void record_concurrent_mark_remark_end() = 0;
// Record start, end, and completion of cleanup.
void record_concurrent_mark_cleanup_start();
void record_concurrent_mark_cleanup_end();
void record_concurrent_mark_cleanup_completed();
virtual void record_concurrent_mark_cleanup_start() = 0;
virtual void record_concurrent_mark_cleanup_end() = 0;
virtual void record_concurrent_mark_cleanup_completed() = 0;
virtual void print_phases();
virtual void print_phases() = 0;
// Record how much space we copied during a GC. This is typically
// called when a GC alloc region is being retired.
void record_bytes_copied_during_gc(size_t bytes) {
_bytes_copied_during_gc += bytes;
}
virtual void record_bytes_copied_during_gc(size_t bytes) = 0;
// The amount of space we copied during a GC.
size_t bytes_copied_during_gc() const {
return _bytes_copied_during_gc;
}
virtual size_t bytes_copied_during_gc() const = 0;
// Determine whether there are candidate regions so that the
// next GC should be mixed. The two action strings are used
// in the ergo output when the method returns true or false.
bool next_gc_should_be_mixed(const char* true_action_str,
const char* false_action_str) const;
virtual void finalize_collection_set(double target_pause_time_ms) = 0;
virtual void finalize_collection_set(double target_pause_time_ms);
private:
// Set the state to start a concurrent marking cycle and clear
// _initiate_conc_mark_if_possible because it has now been
// acted on.
void initiate_conc_mark();
public:
// This sets the initiate_conc_mark_if_possible() flag to start a
// new cycle, as long as we are not already in one. It's best if it
// is called during a safepoint when the test whether a cycle is in
// progress or not is stable.
bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);
virtual bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) = 0;
// This is called at the very beginning of an evacuation pause (it
// has to be the first thing that the pause does). If
@ -368,72 +153,33 @@ public:
// marking thread has completed its work during the previous cycle,
// it will set during_initial_mark_pause() to so that the pause does
// the initial-mark work and start a marking cycle.
void decide_on_conc_mark_initiation();
virtual void decide_on_conc_mark_initiation() = 0;
// Print stats on young survival ratio
void print_yg_surv_rate_info() const;
virtual void print_yg_surv_rate_info() const = 0;
void finished_recalculating_age_indexes(bool is_survivors) {
if (is_survivors) {
_survivor_surv_rate_group->finished_recalculating_age_indexes();
} else {
_short_lived_surv_rate_group->finished_recalculating_age_indexes();
}
}
virtual void finished_recalculating_age_indexes(bool is_survivors) = 0;
size_t young_list_target_length() const { return _young_list_target_length; }
virtual size_t young_list_target_length() const = 0;
bool is_young_list_full() const;
virtual bool is_young_list_full() const = 0;
bool can_expand_young_list() const;
virtual bool can_expand_young_list() const = 0;
uint young_list_max_length() const {
return _young_list_max_length;
}
virtual uint young_list_max_length() const = 0;
bool adaptive_young_list_length() const;
virtual bool adaptive_young_list_length() const = 0;
virtual bool should_process_references() const {
return true;
}
virtual bool should_process_references() const = 0;
private:
//
// Survivor regions policy.
//
virtual uint tenuring_threshold() const = 0;
virtual uint max_survivor_regions() = 0;
// Current tenuring threshold, set to 0 if the collector reaches the
// maximum amount of survivors regions.
uint _tenuring_threshold;
virtual void note_start_adding_survivor_regions() = 0;
// The limit on the number of regions allocated for survivors.
uint _max_survivor_regions;
virtual void note_stop_adding_survivor_regions() = 0;
AgeTable _survivors_age_table;
public:
uint tenuring_threshold() const { return _tenuring_threshold; }
uint max_survivor_regions() {
return _max_survivor_regions;
}
void note_start_adding_survivor_regions() {
_survivor_surv_rate_group->start_adding_regions();
}
void note_stop_adding_survivor_regions() {
_survivor_surv_rate_group->stop_adding_regions();
}
void record_age_table(AgeTable* age_table) {
_survivors_age_table.merge(age_table);
}
void update_max_gc_locker_expansion();
// Calculates survivor space parameters.
void update_survivors_policy();
virtual void record_age_table(AgeTable* age_table) = 0;
};
#endif // SHARE_VM_GC_G1_G1POLICY_HPP