mirror of
https://github.com/openjdk/jdk.git
synced 2026-02-15 04:45:25 +00:00
8197852: Move G1DefaultPolicy into G1Policy
Reviewed-by: sjohanss, tschatzl
This commit is contained in:
Erik Helin
parent
779fef0b10
commit
f82bcaba53
@ -37,7 +37,6 @@
|
||||
#include "gc/g1/g1CollectorState.hpp"
|
||||
#include "gc/g1/g1ConcurrentRefine.hpp"
|
||||
#include "gc/g1/g1ConcurrentRefineThread.hpp"
|
||||
#include "gc/g1/g1DefaultPolicy.hpp"
|
||||
#include "gc/g1/g1EvacStats.inline.hpp"
|
||||
#include "gc/g1/g1FullCollector.hpp"
|
||||
#include "gc/g1/g1GCPhaseTimes.hpp"
|
||||
@ -1460,7 +1459,7 @@ G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* collector_policy) :
|
||||
_old_pool(NULL),
|
||||
_gc_timer_stw(new (ResourceObj::C_HEAP, mtGC) STWGCTimer()),
|
||||
_gc_tracer_stw(new (ResourceObj::C_HEAP, mtGC) G1NewTracer()),
|
||||
_g1_policy(new G1DefaultPolicy(_gc_timer_stw)),
|
||||
_g1_policy(new G1Policy(_gc_timer_stw)),
|
||||
_collection_set(this, _g1_policy),
|
||||
_dirty_card_queue_set(false),
|
||||
_is_alive_closure_cm(this),
|
||||
|
||||
@ -1,399 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2016, 2017, 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"
|
||||
|
||||
class HeapRegion;
|
||||
class G1CollectionSet;
|
||||
class CollectionSetChooser;
|
||||
class G1IHOPControl;
|
||||
class G1Analytics;
|
||||
class G1SurvivorRegions;
|
||||
class G1YoungGenSizer;
|
||||
class GCPolicyCounters;
|
||||
class STWGCTimer;
|
||||
|
||||
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;
|
||||
|
||||
jlong _collection_pause_end_millis;
|
||||
|
||||
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;
|
||||
|
||||
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); }
|
||||
|
||||
void add_bytes_allocated_in_old_since_last_gc(size_t bytes) { _bytes_allocated_in_old_since_last_gc += bytes; }
|
||||
|
||||
void set_region_eden(HeapRegion* hr) {
|
||||
hr->set_eden();
|
||||
hr->install_surv_rate_group(_short_lived_surv_rate_group);
|
||||
}
|
||||
|
||||
void set_region_survivor(HeapRegion* hr) {
|
||||
assert(hr->is_survivor(), "pre-condition");
|
||||
hr->install_surv_rate_group(_survivor_surv_rate_group);
|
||||
}
|
||||
|
||||
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(predictor(), update);
|
||||
_survivor_surv_rate_group->all_surviving_words_recorded(predictor(), 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;
|
||||
}
|
||||
|
||||
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; }
|
||||
|
||||
uint calc_min_old_cset_length() const;
|
||||
uint calc_max_old_cset_length() 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.
|
||||
double reclaimable_bytes_percent(size_t reclaimable_bytes) const;
|
||||
|
||||
jlong collection_pause_end_millis() { return _collection_pause_end_millis; }
|
||||
|
||||
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(STWGCTimer* gc_timer);
|
||||
|
||||
virtual ~G1DefaultPolicy();
|
||||
|
||||
G1CollectorState* collector_state() const;
|
||||
|
||||
G1GCPhaseTimes* phase_times() const { return _phase_times; }
|
||||
|
||||
void revise_young_list_target_length_if_necessary(size_t rs_lengths);
|
||||
|
||||
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;
|
||||
|
||||
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);
|
||||
|
||||
void record_full_collection_start();
|
||||
void record_full_collection_end();
|
||||
|
||||
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
|
||||
|
||||
void record_concurrent_mark_remark_start();
|
||||
void record_concurrent_mark_remark_end();
|
||||
|
||||
void record_concurrent_mark_cleanup_start();
|
||||
void record_concurrent_mark_cleanup_end();
|
||||
void record_concurrent_mark_cleanup_completed();
|
||||
|
||||
virtual void print_phases();
|
||||
|
||||
void record_bytes_copied_during_gc(size_t bytes) {
|
||||
_bytes_copied_during_gc += bytes;
|
||||
}
|
||||
|
||||
size_t bytes_copied_during_gc() const {
|
||||
return _bytes_copied_during_gc;
|
||||
}
|
||||
|
||||
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, G1SurvivorRegions* survivor);
|
||||
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:
|
||||
bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause);
|
||||
|
||||
void decide_on_conc_mark_initiation();
|
||||
|
||||
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 should_allocate_mutator_region() 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;
|
||||
}
|
||||
|
||||
void transfer_survivors_to_cset(const G1SurvivorRegions* survivors);
|
||||
|
||||
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;
|
||||
|
||||
protected:
|
||||
size_t desired_survivor_size() const;
|
||||
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 print_age_table();
|
||||
|
||||
void update_max_gc_locker_expansion();
|
||||
|
||||
void update_survivors_policy();
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_G1_G1DEFAULTPOLICY_HPP
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2001, 2017, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2001, 2018, 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
|
||||
@ -29,7 +29,6 @@
|
||||
#include "gc/g1/g1CollectionSet.hpp"
|
||||
#include "gc/g1/g1ConcurrentMark.hpp"
|
||||
#include "gc/g1/g1ConcurrentRefine.hpp"
|
||||
#include "gc/g1/g1DefaultPolicy.hpp"
|
||||
#include "gc/g1/g1HotCardCache.hpp"
|
||||
#include "gc/g1/g1IHOPControl.hpp"
|
||||
#include "gc/g1/g1GCPhaseTimes.hpp"
|
||||
@ -47,7 +46,7 @@
|
||||
#include "utilities/growableArray.hpp"
|
||||
#include "utilities/pair.hpp"
|
||||
|
||||
G1DefaultPolicy::G1DefaultPolicy(STWGCTimer* gc_timer) :
|
||||
G1Policy::G1Policy(STWGCTimer* gc_timer) :
|
||||
_predictor(G1ConfidencePercent / 100.0),
|
||||
_analytics(new G1Analytics(&_predictor)),
|
||||
_mmu_tracker(new G1MMUTrackerQueue(GCPauseIntervalMillis / 1000.0, MaxGCPauseMillis / 1000.0)),
|
||||
@ -69,13 +68,13 @@ G1DefaultPolicy::G1DefaultPolicy(STWGCTimer* gc_timer) :
|
||||
_survivors_age_table(true),
|
||||
_collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC) { }
|
||||
|
||||
G1DefaultPolicy::~G1DefaultPolicy() {
|
||||
G1Policy::~G1Policy() {
|
||||
delete _ihop_control;
|
||||
}
|
||||
|
||||
G1CollectorState* G1DefaultPolicy::collector_state() const { return _g1->collector_state(); }
|
||||
G1CollectorState* G1Policy::collector_state() const { return _g1->collector_state(); }
|
||||
|
||||
void G1DefaultPolicy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
|
||||
void G1Policy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
|
||||
_g1 = g1h;
|
||||
_collection_set = collection_set;
|
||||
|
||||
@ -94,7 +93,7 @@ void G1DefaultPolicy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set
|
||||
_collection_set->start_incremental_building();
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::note_gc_start() {
|
||||
void G1Policy::note_gc_start() {
|
||||
phase_times()->note_gc_start();
|
||||
}
|
||||
|
||||
@ -103,14 +102,14 @@ class G1YoungLengthPredictor VALUE_OBJ_CLASS_SPEC {
|
||||
const double _base_time_ms;
|
||||
const double _base_free_regions;
|
||||
const double _target_pause_time_ms;
|
||||
const G1DefaultPolicy* const _policy;
|
||||
const G1Policy* const _policy;
|
||||
|
||||
public:
|
||||
G1YoungLengthPredictor(bool during_cm,
|
||||
double base_time_ms,
|
||||
double base_free_regions,
|
||||
double target_pause_time_ms,
|
||||
const G1DefaultPolicy* policy) :
|
||||
const G1Policy* policy) :
|
||||
_during_cm(during_cm),
|
||||
_base_time_ms(base_time_ms),
|
||||
_base_free_regions(base_free_regions),
|
||||
@ -157,7 +156,7 @@ class G1YoungLengthPredictor VALUE_OBJ_CLASS_SPEC {
|
||||
}
|
||||
};
|
||||
|
||||
void G1DefaultPolicy::record_new_heap_size(uint new_number_of_regions) {
|
||||
void G1Policy::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
|
||||
@ -169,7 +168,7 @@ void G1DefaultPolicy::record_new_heap_size(uint new_number_of_regions) {
|
||||
_ihop_control->update_target_occupancy(new_number_of_regions * HeapRegion::GrainBytes);
|
||||
}
|
||||
|
||||
uint G1DefaultPolicy::calculate_young_list_desired_min_length(uint base_min_length) const {
|
||||
uint G1Policy::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) {
|
||||
@ -186,30 +185,30 @@ uint G1DefaultPolicy::calculate_young_list_desired_min_length(uint base_min_leng
|
||||
return MAX2(_young_gen_sizer.min_desired_young_length(), desired_min_length);
|
||||
}
|
||||
|
||||
uint G1DefaultPolicy::calculate_young_list_desired_max_length() const {
|
||||
uint G1Policy::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 G1DefaultPolicy::update_young_list_max_and_target_length() {
|
||||
uint G1Policy::update_young_list_max_and_target_length() {
|
||||
return update_young_list_max_and_target_length(_analytics->predict_rs_lengths());
|
||||
}
|
||||
|
||||
uint G1DefaultPolicy::update_young_list_max_and_target_length(size_t rs_lengths) {
|
||||
uint G1Policy::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 G1DefaultPolicy::update_young_list_target_length(size_t rs_lengths) {
|
||||
uint G1Policy::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;
|
||||
}
|
||||
|
||||
G1DefaultPolicy::YoungTargetLengths G1DefaultPolicy::young_list_target_lengths(size_t rs_lengths) const {
|
||||
G1Policy::YoungTargetLengths G1Policy::young_list_target_lengths(size_t rs_lengths) const {
|
||||
YoungTargetLengths result;
|
||||
|
||||
// Calculate the absolute and desired min bounds first.
|
||||
@ -275,7 +274,7 @@ G1DefaultPolicy::YoungTargetLengths G1DefaultPolicy::young_list_target_lengths(s
|
||||
}
|
||||
|
||||
uint
|
||||
G1DefaultPolicy::calculate_young_list_target_length(size_t rs_lengths,
|
||||
G1Policy::calculate_young_list_target_length(size_t rs_lengths,
|
||||
uint base_min_length,
|
||||
uint desired_min_length,
|
||||
uint desired_max_length) const {
|
||||
@ -376,7 +375,7 @@ G1DefaultPolicy::calculate_young_list_target_length(size_t rs_lengths,
|
||||
return base_min_length + min_young_length;
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::predict_survivor_regions_evac_time() const {
|
||||
double G1Policy::predict_survivor_regions_evac_time() const {
|
||||
double survivor_regions_evac_time = 0.0;
|
||||
const GrowableArray<HeapRegion*>* survivor_regions = _g1->survivor()->regions();
|
||||
|
||||
@ -388,7 +387,7 @@ double G1DefaultPolicy::predict_survivor_regions_evac_time() const {
|
||||
return survivor_regions_evac_time;
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::revise_young_list_target_length_if_necessary(size_t rs_lengths) {
|
||||
void G1Policy::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) {
|
||||
@ -400,23 +399,23 @@ void G1DefaultPolicy::revise_young_list_target_length_if_necessary(size_t rs_len
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::update_rs_lengths_prediction() {
|
||||
void G1Policy::update_rs_lengths_prediction() {
|
||||
update_rs_lengths_prediction(_analytics->predict_rs_lengths());
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::update_rs_lengths_prediction(size_t prediction) {
|
||||
void G1Policy::update_rs_lengths_prediction(size_t prediction) {
|
||||
if (collector_state()->gcs_are_young() && adaptive_young_list_length()) {
|
||||
_rs_lengths_prediction = prediction;
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_full_collection_start() {
|
||||
void G1Policy::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 G1DefaultPolicy::record_full_collection_end() {
|
||||
void G1Policy::record_full_collection_end() {
|
||||
// Consider this like a collection pause for the purposes of allocation
|
||||
// since last pause.
|
||||
double end_sec = os::elapsedTime();
|
||||
@ -451,7 +450,7 @@ void G1DefaultPolicy::record_full_collection_end() {
|
||||
record_pause(FullGC, _full_collection_start_sec, end_sec);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_collection_pause_start(double start_time_sec) {
|
||||
void G1Policy::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.
|
||||
@ -476,18 +475,18 @@ void G1DefaultPolicy::record_collection_pause_start(double start_time_sec) {
|
||||
assert(_g1->collection_set()->verify_young_ages(), "region age verification failed");
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) {
|
||||
void G1Policy::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 G1DefaultPolicy::record_concurrent_mark_remark_start() {
|
||||
void G1Policy::record_concurrent_mark_remark_start() {
|
||||
_mark_remark_start_sec = os::elapsedTime();
|
||||
collector_state()->set_during_marking(false);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_concurrent_mark_remark_end() {
|
||||
void G1Policy::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);
|
||||
@ -496,11 +495,11 @@ void G1DefaultPolicy::record_concurrent_mark_remark_end() {
|
||||
record_pause(Remark, _mark_remark_start_sec, end_time_sec);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_concurrent_mark_cleanup_start() {
|
||||
void G1Policy::record_concurrent_mark_cleanup_start() {
|
||||
_mark_cleanup_start_sec = os::elapsedTime();
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_concurrent_mark_cleanup_completed() {
|
||||
void G1Policy::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);
|
||||
@ -511,37 +510,37 @@ void G1DefaultPolicy::record_concurrent_mark_cleanup_completed() {
|
||||
collector_state()->set_in_marking_window(false);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const {
|
||||
double G1Policy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const {
|
||||
return phase_times()->average_time_ms(phase);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::young_other_time_ms() const {
|
||||
double G1Policy::young_other_time_ms() const {
|
||||
return phase_times()->young_cset_choice_time_ms() +
|
||||
phase_times()->average_time_ms(G1GCPhaseTimes::YoungFreeCSet);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::non_young_other_time_ms() const {
|
||||
double G1Policy::non_young_other_time_ms() const {
|
||||
return phase_times()->non_young_cset_choice_time_ms() +
|
||||
phase_times()->average_time_ms(G1GCPhaseTimes::NonYoungFreeCSet);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::other_time_ms(double pause_time_ms) const {
|
||||
double G1Policy::other_time_ms(double pause_time_ms) const {
|
||||
return pause_time_ms - phase_times()->cur_collection_par_time_ms();
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::constant_other_time_ms(double pause_time_ms) const {
|
||||
double G1Policy::constant_other_time_ms(double pause_time_ms) const {
|
||||
return other_time_ms(pause_time_ms) - phase_times()->total_free_cset_time_ms();
|
||||
}
|
||||
|
||||
CollectionSetChooser* G1DefaultPolicy::cset_chooser() const {
|
||||
CollectionSetChooser* G1Policy::cset_chooser() const {
|
||||
return _collection_set->cset_chooser();
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::about_to_start_mixed_phase() const {
|
||||
bool G1Policy::about_to_start_mixed_phase() const {
|
||||
return _g1->concurrent_mark()->cm_thread()->during_cycle() || collector_state()->last_young_gc();
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
|
||||
bool G1Policy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
|
||||
if (about_to_start_mixed_phase()) {
|
||||
return false;
|
||||
}
|
||||
@ -566,7 +565,7 @@ bool G1DefaultPolicy::need_to_start_conc_mark(const char* source, size_t alloc_w
|
||||
// Anything below that is considered to be zero
|
||||
#define MIN_TIMER_GRANULARITY 0.0000001
|
||||
|
||||
void G1DefaultPolicy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) {
|
||||
void G1Policy::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();
|
||||
@ -752,7 +751,7 @@ void G1DefaultPolicy::record_collection_pause_end(double pause_time_ms, size_t c
|
||||
cset_chooser()->verify();
|
||||
}
|
||||
|
||||
G1IHOPControl* G1DefaultPolicy::create_ihop_control(const G1Predictions* predictor){
|
||||
G1IHOPControl* G1Policy::create_ihop_control(const G1Predictions* predictor){
|
||||
if (G1UseAdaptiveIHOP) {
|
||||
return new G1AdaptiveIHOPControl(InitiatingHeapOccupancyPercent,
|
||||
predictor,
|
||||
@ -763,7 +762,7 @@ G1IHOPControl* G1DefaultPolicy::create_ihop_control(const G1Predictions* predict
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::update_ihop_prediction(double mutator_time_s,
|
||||
void G1Policy::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
|
||||
@ -801,15 +800,15 @@ void G1DefaultPolicy::update_ihop_prediction(double mutator_time_s,
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::report_ihop_statistics() {
|
||||
void G1Policy::report_ihop_statistics() {
|
||||
_ihop_control->print();
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::print_phases() {
|
||||
void G1Policy::print_phases() {
|
||||
phase_times()->print();
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const {
|
||||
double G1Policy::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);
|
||||
@ -819,11 +818,11 @@ double G1DefaultPolicy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_g
|
||||
return pred;
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::accum_yg_surv_rate_pred(int age) const {
|
||||
double G1Policy::accum_yg_surv_rate_pred(int age) const {
|
||||
return _short_lived_surv_rate_group->accum_surv_rate_pred(age);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
|
||||
double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards,
|
||||
size_t scanned_cards) const {
|
||||
return
|
||||
_analytics->predict_rs_update_time_ms(pending_cards) +
|
||||
@ -831,13 +830,13 @@ double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
|
||||
_analytics->predict_constant_other_time_ms();
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::predict_base_elapsed_time_ms(size_t pending_cards) const {
|
||||
double G1Policy::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 G1DefaultPolicy::predict_bytes_to_copy(HeapRegion* hr) const {
|
||||
size_t G1Policy::predict_bytes_to_copy(HeapRegion* hr) const {
|
||||
size_t bytes_to_copy;
|
||||
if (hr->is_marked())
|
||||
bytes_to_copy = hr->max_live_bytes();
|
||||
@ -850,7 +849,7 @@ size_t G1DefaultPolicy::predict_bytes_to_copy(HeapRegion* hr) const {
|
||||
return bytes_to_copy;
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
|
||||
double G1Policy::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
|
||||
@ -872,32 +871,32 @@ double G1DefaultPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
|
||||
return region_elapsed_time_ms;
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::should_allocate_mutator_region() const {
|
||||
bool G1Policy::should_allocate_mutator_region() const {
|
||||
uint young_list_length = _g1->young_regions_count();
|
||||
uint young_list_target_length = _young_list_target_length;
|
||||
return young_list_length < young_list_target_length;
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::can_expand_young_list() const {
|
||||
bool G1Policy::can_expand_young_list() const {
|
||||
uint young_list_length = _g1->young_regions_count();
|
||||
uint young_list_max_length = _young_list_max_length;
|
||||
return young_list_length < young_list_max_length;
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::adaptive_young_list_length() const {
|
||||
bool G1Policy::adaptive_young_list_length() const {
|
||||
return _young_gen_sizer.adaptive_young_list_length();
|
||||
}
|
||||
|
||||
size_t G1DefaultPolicy::desired_survivor_size() const {
|
||||
size_t G1Policy::desired_survivor_size() const {
|
||||
size_t const survivor_capacity = HeapRegion::GrainWords * _max_survivor_regions;
|
||||
return (size_t)((((double)survivor_capacity) * TargetSurvivorRatio) / 100);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::print_age_table() {
|
||||
void G1Policy::print_age_table() {
|
||||
_survivors_age_table.print_age_table(_tenuring_threshold);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::update_max_gc_locker_expansion() {
|
||||
void G1Policy::update_max_gc_locker_expansion() {
|
||||
uint expansion_region_num = 0;
|
||||
if (GCLockerEdenExpansionPercent > 0) {
|
||||
double perc = (double) GCLockerEdenExpansionPercent / 100.0;
|
||||
@ -913,7 +912,7 @@ void G1DefaultPolicy::update_max_gc_locker_expansion() {
|
||||
}
|
||||
|
||||
// Calculates survivor space parameters.
|
||||
void G1DefaultPolicy::update_survivors_policy() {
|
||||
void G1Policy::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
|
||||
@ -927,7 +926,7 @@ void G1DefaultPolicy::update_survivors_policy() {
|
||||
}
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
|
||||
bool G1Policy::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.
|
||||
@ -942,12 +941,12 @@ bool G1DefaultPolicy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_caus
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::initiate_conc_mark() {
|
||||
void G1Policy::initiate_conc_mark() {
|
||||
collector_state()->set_during_initial_mark_pause(true);
|
||||
collector_state()->set_initiate_conc_mark_if_possible(false);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::decide_on_conc_mark_initiation() {
|
||||
void G1Policy::decide_on_conc_mark_initiation() {
|
||||
// We are about to decide on whether this pause will be an
|
||||
// initial-mark pause.
|
||||
|
||||
@ -993,7 +992,7 @@ void G1DefaultPolicy::decide_on_conc_mark_initiation() {
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_concurrent_mark_cleanup_end() {
|
||||
void G1Policy::record_concurrent_mark_cleanup_end() {
|
||||
cset_chooser()->rebuild(_g1->workers(), _g1->num_regions());
|
||||
|
||||
double end_sec = os::elapsedTime();
|
||||
@ -1004,11 +1003,11 @@ void G1DefaultPolicy::record_concurrent_mark_cleanup_end() {
|
||||
record_pause(Cleanup, _mark_cleanup_start_sec, end_sec);
|
||||
}
|
||||
|
||||
double G1DefaultPolicy::reclaimable_bytes_percent(size_t reclaimable_bytes) const {
|
||||
double G1Policy::reclaimable_bytes_percent(size_t reclaimable_bytes) const {
|
||||
return percent_of(reclaimable_bytes, _g1->capacity());
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::maybe_start_marking() {
|
||||
void G1Policy::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
|
||||
@ -1017,7 +1016,7 @@ void G1DefaultPolicy::maybe_start_marking() {
|
||||
}
|
||||
}
|
||||
|
||||
G1DefaultPolicy::PauseKind G1DefaultPolicy::young_gc_pause_kind() const {
|
||||
G1Policy::PauseKind G1Policy::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");
|
||||
@ -1039,7 +1038,7 @@ G1DefaultPolicy::PauseKind G1DefaultPolicy::young_gc_pause_kind() const {
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::record_pause(PauseKind kind, double start, double end) {
|
||||
void G1Policy::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);
|
||||
@ -1066,11 +1065,11 @@ void G1DefaultPolicy::record_pause(PauseKind kind, double start, double end) {
|
||||
}
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::abort_time_to_mixed_tracking() {
|
||||
void G1Policy::abort_time_to_mixed_tracking() {
|
||||
_initial_mark_to_mixed.reset();
|
||||
}
|
||||
|
||||
bool G1DefaultPolicy::next_gc_should_be_mixed(const char* true_action_str,
|
||||
bool G1Policy::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);
|
||||
@ -1091,7 +1090,7 @@ bool G1DefaultPolicy::next_gc_should_be_mixed(const char* true_action_str,
|
||||
return true;
|
||||
}
|
||||
|
||||
uint G1DefaultPolicy::calc_min_old_cset_length() const {
|
||||
uint G1Policy::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
|
||||
@ -1112,7 +1111,7 @@ uint G1DefaultPolicy::calc_min_old_cset_length() const {
|
||||
return (uint) result;
|
||||
}
|
||||
|
||||
uint G1DefaultPolicy::calc_max_old_cset_length() const {
|
||||
uint G1Policy::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
|
||||
@ -1129,12 +1128,12 @@ uint G1DefaultPolicy::calc_max_old_cset_length() const {
|
||||
return (uint) result;
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor) {
|
||||
void G1Policy::finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor) {
|
||||
double time_remaining_ms = _collection_set->finalize_young_part(target_pause_time_ms, survivor);
|
||||
_collection_set->finalize_old_part(time_remaining_ms);
|
||||
}
|
||||
|
||||
void G1DefaultPolicy::transfer_survivors_to_cset(const G1SurvivorRegions* survivors) {
|
||||
void G1Policy::transfer_survivors_to_cset(const G1SurvivorRegions* survivors) {
|
||||
|
||||
// Add survivor regions to SurvRateGroup.
|
||||
note_start_adding_survivor_regions();
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2016, 2018, 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
|
||||
@ -47,108 +47,309 @@ class G1IHOPControl;
|
||||
class G1Analytics;
|
||||
class G1SurvivorRegions;
|
||||
class G1YoungGenSizer;
|
||||
class GCPolicyCounters;
|
||||
class STWGCTimer;
|
||||
|
||||
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;
|
||||
|
||||
jlong _collection_pause_end_millis;
|
||||
|
||||
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;
|
||||
|
||||
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:
|
||||
virtual const G1Predictions& predictor() const = 0;
|
||||
virtual const G1Analytics* analytics() const = 0;
|
||||
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.
|
||||
virtual void add_bytes_allocated_in_old_since_last_gc(size_t bytes) = 0;
|
||||
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) {
|
||||
hr->set_eden();
|
||||
hr->install_surv_rate_group(_short_lived_surv_rate_group);
|
||||
}
|
||||
|
||||
virtual void set_region_eden(HeapRegion* hr) = 0;
|
||||
virtual void set_region_survivor(HeapRegion* hr) = 0;
|
||||
void set_region_survivor(HeapRegion* hr) {
|
||||
assert(hr->is_survivor(), "pre-condition");
|
||||
hr->install_surv_rate_group(_survivor_surv_rate_group);
|
||||
}
|
||||
|
||||
virtual void record_max_rs_lengths(size_t rs_lengths) = 0;
|
||||
void record_max_rs_lengths(size_t rs_lengths) {
|
||||
_max_rs_lengths = rs_lengths;
|
||||
}
|
||||
|
||||
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;
|
||||
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 double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const = 0;
|
||||
double predict_survivor_regions_evac_time() const;
|
||||
|
||||
virtual void cset_regions_freed() = 0;
|
||||
bool should_update_surv_rate_group_predictors() {
|
||||
return collector_state()->last_gc_was_young() && !collector_state()->in_marking_window();
|
||||
}
|
||||
|
||||
virtual G1MMUTracker* mmu_tracker() = 0;
|
||||
void cset_regions_freed() {
|
||||
bool update = should_update_surv_rate_group_predictors();
|
||||
|
||||
virtual const G1MMUTracker* mmu_tracker() const = 0;
|
||||
_short_lived_surv_rate_group->all_surviving_words_recorded(predictor(), update);
|
||||
_survivor_surv_rate_group->all_surviving_words_recorded(predictor(), update);
|
||||
}
|
||||
|
||||
virtual double max_pause_time_ms() const = 0;
|
||||
G1MMUTracker* mmu_tracker() {
|
||||
return _mmu_tracker;
|
||||
}
|
||||
|
||||
virtual size_t pending_cards() const = 0;
|
||||
const G1MMUTracker* mmu_tracker() const {
|
||||
return _mmu_tracker;
|
||||
}
|
||||
|
||||
double max_pause_time_ms() const {
|
||||
return _mmu_tracker->max_gc_time() * 1000.0;
|
||||
}
|
||||
|
||||
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;
|
||||
double average_time_ms(G1GCPhaseTimes::GCParPhases phase) const;
|
||||
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.
|
||||
virtual uint calc_min_old_cset_length() const = 0;
|
||||
uint calc_min_old_cset_length() const;
|
||||
|
||||
// Calculate the maximum number of old regions we'll add to the CSet
|
||||
// during a mixed GC.
|
||||
virtual uint calc_max_old_cset_length() const = 0;
|
||||
uint calc_max_old_cset_length() const;
|
||||
|
||||
// Returns the given amount of uncollected reclaimable space
|
||||
// as a percentage of the current heap capacity.
|
||||
virtual double reclaimable_bytes_percent(size_t reclaimable_bytes) const = 0;
|
||||
// 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.
|
||||
double reclaimable_bytes_percent(size_t reclaimable_bytes) const;
|
||||
|
||||
virtual ~G1Policy() {}
|
||||
jlong collection_pause_end_millis() { return _collection_pause_end_millis; }
|
||||
|
||||
virtual G1CollectorState* collector_state() const = 0;
|
||||
private:
|
||||
// Sets up marking if proper conditions are met.
|
||||
void maybe_start_marking();
|
||||
|
||||
virtual G1GCPhaseTimes* phase_times() const = 0;
|
||||
// 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:
|
||||
|
||||
G1Policy(STWGCTimer* gc_timer);
|
||||
|
||||
virtual ~G1Policy();
|
||||
|
||||
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.
|
||||
virtual void revise_young_list_target_length_if_necessary(size_t rs_lengths) = 0;
|
||||
void revise_young_list_target_length_if_necessary(size_t rs_lengths);
|
||||
|
||||
// This should be called after the heap is resized.
|
||||
virtual void record_new_heap_size(uint new_number_of_regions) = 0;
|
||||
void record_new_heap_size(uint new_number_of_regions);
|
||||
|
||||
virtual void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) = 0;
|
||||
void init(G1CollectedHeap* g1h, G1CollectionSet* collection_set);
|
||||
|
||||
virtual void note_gc_start() = 0;
|
||||
void note_gc_start();
|
||||
|
||||
virtual bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0) = 0;
|
||||
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.
|
||||
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;
|
||||
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.
|
||||
virtual void record_full_collection_start() = 0;
|
||||
virtual void record_full_collection_end() = 0;
|
||||
|
||||
virtual jlong collection_pause_end_millis() = 0;
|
||||
void record_full_collection_start();
|
||||
void record_full_collection_end();
|
||||
|
||||
// Must currently be called while the world is stopped.
|
||||
virtual void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) = 0;
|
||||
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms);
|
||||
|
||||
// Record start and end of remark.
|
||||
virtual void record_concurrent_mark_remark_start() = 0;
|
||||
virtual void record_concurrent_mark_remark_end() = 0;
|
||||
void record_concurrent_mark_remark_start();
|
||||
void record_concurrent_mark_remark_end();
|
||||
|
||||
// Record start, end, and completion of cleanup.
|
||||
virtual void record_concurrent_mark_cleanup_start() = 0;
|
||||
virtual void record_concurrent_mark_cleanup_end() = 0;
|
||||
virtual void record_concurrent_mark_cleanup_completed() = 0;
|
||||
void record_concurrent_mark_cleanup_start();
|
||||
void record_concurrent_mark_cleanup_end();
|
||||
void record_concurrent_mark_cleanup_completed();
|
||||
|
||||
virtual void print_phases() = 0;
|
||||
void print_phases();
|
||||
|
||||
// Record how much space we copied during a GC. This is typically
|
||||
// called when a GC alloc region is being retired.
|
||||
virtual void record_bytes_copied_during_gc(size_t bytes) = 0;
|
||||
void record_bytes_copied_during_gc(size_t bytes) {
|
||||
_bytes_copied_during_gc += bytes;
|
||||
}
|
||||
|
||||
// The amount of space we copied during a GC.
|
||||
virtual size_t bytes_copied_during_gc() const = 0;
|
||||
size_t bytes_copied_during_gc() const {
|
||||
return _bytes_copied_during_gc;
|
||||
}
|
||||
|
||||
virtual void finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor) = 0;
|
||||
bool next_gc_should_be_mixed(const char* true_action_str,
|
||||
const char* false_action_str) const;
|
||||
|
||||
void finalize_collection_set(double target_pause_time_ms, G1SurvivorRegions* survivor);
|
||||
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.
|
||||
virtual bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) = 0;
|
||||
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
|
||||
@ -156,36 +357,74 @@ 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.
|
||||
virtual void decide_on_conc_mark_initiation() = 0;
|
||||
void decide_on_conc_mark_initiation();
|
||||
|
||||
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 void transfer_survivors_to_cset(const G1SurvivorRegions* survivors) = 0;
|
||||
bool should_allocate_mutator_region() const;
|
||||
|
||||
virtual size_t young_list_target_length() const = 0;
|
||||
bool can_expand_young_list() const;
|
||||
|
||||
virtual bool should_allocate_mutator_region() const = 0;
|
||||
uint young_list_max_length() const {
|
||||
return _young_list_max_length;
|
||||
}
|
||||
|
||||
virtual bool can_expand_young_list() const = 0;
|
||||
bool adaptive_young_list_length() const;
|
||||
|
||||
virtual uint young_list_max_length() const = 0;
|
||||
bool should_process_references() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual bool adaptive_young_list_length() const = 0;
|
||||
void transfer_survivors_to_cset(const G1SurvivorRegions* survivors);
|
||||
|
||||
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;
|
||||
|
||||
virtual void record_age_table(AgeTable* age_table) = 0;
|
||||
virtual void print_age_table() = 0;
|
||||
protected:
|
||||
virtual size_t desired_survivor_size() const = 0;
|
||||
size_t desired_survivor_size() const;
|
||||
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 print_age_table();
|
||||
|
||||
void update_max_gc_locker_expansion();
|
||||
|
||||
void update_survivors_policy();
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_G1_G1POLICY_HPP
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user