0N/A

0N/A#include "incls/_precompiled.incl"

0N/A#include "incls/_g1CollectorPolicy.cpp.incl"

0N/A

0N/A#define PREDICTIONS_VERBOSE 0

0N/A

0N/A

0N/A

0N/Astatic double rs_length_diff_defaults[] = {

0N/A 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0

0N/A};

0N/A

0N/Astatic double cost_per_card_ms_defaults[] = {

0N/A 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015

0N/A};

0N/A

0N/Astatic double cost_per_scan_only_region_ms_defaults[] = {

0N/A 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0

0N/A};

0N/A

0N/Astatic double fully_young_cards_per_entry_ratio_defaults[] = {

0N/A 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0

0N/A};

0N/A

0N/Astatic double cost_per_entry_ms_defaults[] = {

0N/A 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005

0N/A};

0N/A

0N/Astatic double cost_per_byte_ms_defaults[] = {

0N/A 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009

0N/A};

0N/A

0N/Astatic double constant_other_time_ms_defaults[] = {

0N/A 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0

0N/A};

0N/A

0N/A

0N/Astatic double young_other_cost_per_region_ms_defaults[] = {

0N/A 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1

0N/A};

0N/A

0N/Astatic double non_young_other_cost_per_region_ms_defaults[] = {

0N/A 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30

0N/A};

0N/A

0N/A

0N/AG1CollectorPolicy::G1CollectorPolicy() :

0N/A _parallel_gc_threads((ParallelGCThreads > 0) ? ParallelGCThreads : 1),

0N/A _n_pauses(0),

0N/A _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _recent_rs_sizes(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _all_pause_times_ms(new NumberSeq()),

0N/A _stop_world_start(0.0),

0N/A _all_stop_world_times_ms(new NumberSeq()),

0N/A _all_yield_times_ms(new NumberSeq()),

0N/A

0N/A _all_mod_union_times_ms(new NumberSeq()),

0N/A

0N/A _summary(new Summary()),

0N/A _abandoned_summary(new AbandonedSummary()),

0N/A

0N/A#ifndef PRODUCT

0N/A _cur_clear_ct_time_ms(0.0),

0N/A _min_clear_cc_time_ms(-1.0),

0N/A _max_clear_cc_time_ms(-1.0),

0N/A _cur_clear_cc_time_ms(0.0),

0N/A _cum_clear_cc_time_ms(0.0),

0N/A _num_cc_clears(0L),

0N/A#endif

0N/A

0N/A _region_num_young(0),

0N/A _region_num_tenured(0),

0N/A _prev_region_num_young(0),

0N/A _prev_region_num_tenured(0),

0N/A

0N/A _aux_num(10),

0N/A _all_aux_times_ms(new NumberSeq[_aux_num]),

0N/A _cur_aux_start_times_ms(new double[_aux_num]),

0N/A _cur_aux_times_ms(new double[_aux_num]),

0N/A _cur_aux_times_set(new bool[_aux_num]),

0N/A

0N/A _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A

0N/A // <NEW PREDICTION>

0N/A

0N/A _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _prev_collection_pause_end_ms(0.0),

0N/A _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_scan_only_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _fully_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _partially_young_cards_per_entry_ratio_seq(

0N/A new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _partially_young_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _cost_per_scan_only_region_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _non_young_other_cost_per_region_ms_seq(

0N/A new TruncatedSeq(TruncatedSeqLength)),

0N/A

0N/A _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A

0N/A _pause_time_target_ms((double) MaxGCPauseMillis),

0N/A

0N/A // </NEW PREDICTION>

0N/A

0N/A _in_young_gc_mode(false),

0N/A _full_young_gcs(true),

0N/A _full_young_pause_num(0),

0N/A _partial_young_pause_num(0),

0N/A

0N/A _during_marking(false),

0N/A _in_marking_window(false),

0N/A _in_marking_window_im(false),

0N/A

0N/A _known_garbage_ratio(0.0),

0N/A _known_garbage_bytes(0),

0N/A

0N/A _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)),

0N/A _target_pause_time_ms(-1.0),

0N/A

0N/A _recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)),

0N/A

_recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)),

_recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)),

_recent_avg_pause_time_ratio(0.0),

_num_markings(0),

_n_marks(0),

_n_pauses_at_mark_end(0),

_all_full_gc_times_ms(new NumberSeq()),

// G1PausesBtwnConcMark defaults to -1

// so the hack is to do the cast QQQ FIXME

_pauses_btwn_concurrent_mark((size_t)G1PausesBtwnConcMark),

_n_marks_since_last_pause(0),

_conc_mark_initiated(false),

_should_initiate_conc_mark(false),

_should_revert_to_full_young_gcs(false),

_last_full_young_gc(false),

_prev_collection_pause_used_at_end_bytes(0),

_collection_set(NULL),

#ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away

#pragma warning( disable:4355 ) // 'this' : used in base member initializer list

#endif // _MSC_VER

_short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived",

G1YoungSurvRateNumRegionsSummary)),

_survivor_surv_rate_group(new SurvRateGroup(this, "Survivor",

G1YoungSurvRateNumRegionsSummary)),

// add here any more surv rate groups

_recorded_survivor_regions(0),

_recorded_survivor_head(NULL),

_recorded_survivor_tail(NULL),

_survivors_age_table(true)

{

// Set up the region size and associated fields. Given that the

// policy is created before the heap, we have to set this up here,

// so it's done as soon as possible.

HeapRegion::setup_heap_region_size(Arguments::min_heap_size());

_recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime());

_prev_collection_pause_end_ms = os::elapsedTime() * 1000.0;

_par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads];

_par_last_mark_stack_scan_times_ms = new double[_parallel_gc_threads];

_par_last_scan_only_times_ms = new double[_parallel_gc_threads];

_par_last_scan_only_regions_scanned = new double[_parallel_gc_threads];

_par_last_update_rs_start_times_ms = new double[_parallel_gc_threads];

_par_last_update_rs_times_ms = new double[_parallel_gc_threads];

_par_last_update_rs_processed_buffers = new double[_parallel_gc_threads];

_par_last_scan_rs_start_times_ms = new double[_parallel_gc_threads];

_par_last_scan_rs_times_ms = new double[_parallel_gc_threads];

_par_last_scan_new_refs_times_ms = new double[_parallel_gc_threads];

_par_last_obj_copy_times_ms = new double[_parallel_gc_threads];

_par_last_termination_times_ms = new double[_parallel_gc_threads];

// start conservatively

_expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;

// <NEW PREDICTION>

int index;

if (ParallelGCThreads == 0)

index = 0;

else if (ParallelGCThreads > 8)

index = 7;

else

index = ParallelGCThreads - 1;

_pending_card_diff_seq->add(0.0);

_rs_length_diff_seq->add(rs_length_diff_defaults[index]);

_cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]);

_cost_per_scan_only_region_ms_seq->add(

cost_per_scan_only_region_ms_defaults[index]);

_fully_young_cards_per_entry_ratio_seq->add(

fully_young_cards_per_entry_ratio_defaults[index]);

_cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]);

_cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]);

_constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]);

_young_other_cost_per_region_ms_seq->add(

young_other_cost_per_region_ms_defaults[index]);

_non_young_other_cost_per_region_ms_seq->add(

non_young_other_cost_per_region_ms_defaults[index]);

// </NEW PREDICTION>

double time_slice = (double) GCPauseIntervalMillis / 1000.0;

double max_gc_time = (double) MaxGCPauseMillis / 1000.0;

guarantee(max_gc_time < time_slice,

"Max GC time should not be greater than the time slice");

_mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);

_sigma = (double) G1ConfidencePercent / 100.0;

// start conservatively (around 50ms is about right)

_concurrent_mark_init_times_ms->add(0.05);

_concurrent_mark_remark_times_ms->add(0.05);

_concurrent_mark_cleanup_times_ms->add(0.20);

_tenuring_threshold = MaxTenuringThreshold;

if (G1UseSurvivorSpaces) {

// if G1FixedSurvivorSpaceSize is 0 which means the size is not

// fixed, then _max_survivor_regions will be calculated at

// calculate_young_list_target_config during initialization

_max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;

} else {

_max_survivor_regions = 0;

}

initialize_all();

}

static void inc_mod(int& i, int len) {

i++; if (i == len) i = 0;

}

void G1CollectorPolicy::initialize_flags() {

set_min_alignment(HeapRegion::GrainBytes);

set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name()));

if (SurvivorRatio < 1) {

vm_exit_during_initialization("Invalid survivor ratio specified");

}

CollectorPolicy::initialize_flags();

}

void G1CollectorPolicy::init() {

// Set aside an initial future to_space.

_g1 = G1CollectedHeap::heap();

size_t regions = Universe::heap()->capacity() / HeapRegion::GrainBytes;

assert(Heap_lock->owned_by_self(), "Locking discipline.");

if (G1SteadyStateUsed < 50) {

vm_exit_during_initialization("G1SteadyStateUsed must be at least 50%.");

}

initialize_gc_policy_counters();

if (G1Gen) {

_in_young_gc_mode = true;

if (G1YoungGenSize == 0) {

set_adaptive_young_list_length(true);

_young_list_fixed_length = 0;

} else {

set_adaptive_young_list_length(false);

_young_list_fixed_length = (G1YoungGenSize / HeapRegion::GrainBytes);

}

_free_regions_at_end_of_collection = _g1->free_regions();

_scan_only_regions_at_end_of_collection = 0;

calculate_young_list_min_length();

guarantee( _young_list_min_length == 0, "invariant, not enough info" );

calculate_young_list_target_config();

} else {

_young_list_fixed_length = 0;

_in_young_gc_mode = false;

}

}

void G1CollectorPolicy::initialize_gc_policy_counters()

{

_gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 2 + G1Gen);

}

void G1CollectorPolicy::calculate_young_list_min_length() {

_young_list_min_length = 0;

if (!adaptive_young_list_length())

return;

if (_alloc_rate_ms_seq->num() > 3) {

double now_sec = os::elapsedTime();

double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;

double alloc_rate_ms = predict_alloc_rate_ms();

int min_regions = (int) ceil(alloc_rate_ms * when_ms);

int current_region_num = (int) _g1->young_list_length();

_young_list_min_length = min_regions + current_region_num;

}

}

void G1CollectorPolicy::calculate_young_list_target_config() {

if (adaptive_young_list_length()) {

size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);

calculate_young_list_target_config(rs_lengths);

} else {

if (full_young_gcs())

_young_list_target_length = _young_list_fixed_length;

else

_young_list_target_length = _young_list_fixed_length / 2;

_young_list_target_length = MAX2(_young_list_target_length, (size_t)1);

size_t so_length = calculate_optimal_so_length(_young_list_target_length);

guarantee( so_length < _young_list_target_length, "invariant" );

_young_list_so_prefix_length = so_length;

}

calculate_survivors_policy();

}

size_t G1CollectorPolicy::calculate_optimal_so_length(

size_t young_list_length) {

if (!G1UseScanOnlyPrefix)

return 0;

if (_all_pause_times_ms->num() < 3) {

// we won't use a scan-only set at the beginning to allow the rest

// of the predictors to warm up

return 0;

}

if (_cost_per_scan_only_region_ms_seq->num() < 3) {

// then, we'll only set the S-O set to 1 for a little bit of time,

// to get enough information on the scanning cost

return 1;

}

size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);

size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq);

size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();

size_t scanned_cards;

if (full_young_gcs())

scanned_cards = predict_young_card_num(adj_rs_lengths);

else

scanned_cards = predict_non_young_card_num(adj_rs_lengths);

double base_time_ms = predict_base_elapsed_time_ms(pending_cards,

scanned_cards);

size_t so_length = 0;

double max_gc_eff = 0.0;

for (size_t i = 0; i < young_list_length; ++i) {

double gc_eff = 0.0;

double pause_time_ms = 0.0;

predict_gc_eff(young_list_length, i, base_time_ms,

&gc_eff, &pause_time_ms);

if (gc_eff > max_gc_eff) {

max_gc_eff = gc_eff;

so_length = i;

}

}

// set it to 95% of the optimal to make sure we sample the "area"

// around the optimal length to get up-to-date survival rate data

return so_length * 950 / 1000;

}

void G1CollectorPolicy::calculate_young_list_target_config(size_t rs_lengths) {

guarantee( adaptive_young_list_length(), "pre-condition" );

double start_time_sec = os::elapsedTime();

size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePercent);

min_reserve_perc = MIN2((size_t) 50, min_reserve_perc);

size_t reserve_regions =

(size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0);

if (full_young_gcs() && _free_regions_at_end_of_collection > 0) {

// we are in fully-young mode and there are free regions in the heap

double survivor_regions_evac_time =

predict_survivor_regions_evac_time();

size_t min_so_length = 0;

size_t max_so_length = 0;

if (G1UseScanOnlyPrefix) {

if (_all_pause_times_ms->num() < 3) {

// we won't use a scan-only set at the beginning to allow the rest

// of the predictors to warm up

min_so_length = 0;

max_so_length = 0;

} else if (_cost_per_scan_only_region_ms_seq->num() < 3) {

// then, we'll only set the S-O set to 1 for a little bit of time,

// to get enough information on the scanning cost

min_so_length = 1;

max_so_length = 1;

} else if (_in_marking_window || _last_full_young_gc) {

// no S-O prefix during a marking phase either, as at the end

// of the marking phase we'll have to use a very small young

// length target to fill up the rest of the CSet with

// non-young regions and, if we have lots of scan-only regions

// left-over, we will not be able to add any more non-young

// regions.

min_so_length = 0;

max_so_length = 0;

} else {

// this is the common case; we'll never reach the maximum, we

// one of the end conditions will fire well before that

// (hopefully!)

min_so_length = 0;

max_so_length = _free_regions_at_end_of_collection - 1;

}

} else {

// no S-O prefix, as the switch is not set, but we still need to

// do one iteration to calculate the best young target that

// meets the pause time; this way we reuse the same code instead

// of replicating it

min_so_length = 0;

max_so_length = 0;

}

double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;

size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);

size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();

size_t scanned_cards;

if (full_young_gcs())

scanned_cards = predict_young_card_num(adj_rs_lengths);

else

scanned_cards = predict_non_young_card_num(adj_rs_lengths);

// calculate this once, so that we don't have to recalculate it in

// the innermost loop

double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards)

+ survivor_regions_evac_time;

// the result

size_t final_young_length = 0;

size_t final_so_length = 0;

double final_gc_eff = 0.0;

// we'll also keep track of how many times we go into the inner loop

// this is for profiling reasons

size_t calculations = 0;

// this determines which of the three iterations the outer loop is in

typedef enum {

pass_type_coarse,

pass_type_fine,

pass_type_final

} pass_type_t;

// range of the outer loop's iteration

size_t from_so_length = min_so_length;

size_t to_so_length = max_so_length;

guarantee( from_so_length <= to_so_length, "invariant" );

// this will keep the S-O length that's found by the second

// iteration of the outer loop; we'll keep it just in case the third

// iteration fails to find something

size_t fine_so_length = 0;

// the increment step for the coarse (first) iteration

size_t so_coarse_increments = 5;

// the common case, we'll start with the coarse iteration

pass_type_t pass = pass_type_coarse;

size_t so_length_incr = so_coarse_increments;

if (from_so_length == to_so_length) {

// not point in doing the coarse iteration, we'll go directly into

// the fine one (we essentially trying to find the optimal young

// length for a fixed S-O length).

so_length_incr = 1;

pass = pass_type_final;

} else if (to_so_length - from_so_length < 3 * so_coarse_increments) {

// again, the range is too short so no point in foind the coarse

// iteration either

so_length_incr = 1;

pass = pass_type_fine;

}

bool done = false;

// this is the outermost loop

while (!done) {

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr("searching between " SIZE_FORMAT " and " SIZE_FORMAT

", incr " SIZE_FORMAT ", pass %s",

from_so_length, to_so_length, so_length_incr,

(pass == pass_type_coarse) ? "coarse" :

(pass == pass_type_fine) ? "fine" : "final");

#endif // TRACE_CALC_YOUNG_CONFIG

size_t so_length = from_so_length;

size_t init_free_regions =

MAX2((size_t)0,

_free_regions_at_end_of_collection +

_scan_only_regions_at_end_of_collection - reserve_regions);

// this determines whether a configuration was found

bool gc_eff_set = false;

// this is the middle loop

while (so_length <= to_so_length) {

// base time, which excludes region-related time; again we

// calculate it once to avoid recalculating it in the

// innermost loop

double base_time_with_so_ms =

base_time_ms + predict_scan_only_time_ms(so_length);

// it's already over the pause target, go around

if (base_time_with_so_ms > target_pause_time_ms)

break;

size_t starting_young_length = so_length+1;

// we make sure that the short young length that makes sense

// (one more than the S-O length) is feasible

size_t min_young_length = starting_young_length;

double min_gc_eff;

bool min_ok;

++calculations;

min_ok = predict_gc_eff(min_young_length, so_length,

base_time_with_so_ms,

init_free_regions, target_pause_time_ms,

&min_gc_eff);

if (min_ok) {

// the shortest young length is indeed feasible; we'll know

// set up the max young length and we'll do a binary search

// between min_young_length and max_young_length

size_t max_young_length = _free_regions_at_end_of_collection - 1;

double max_gc_eff = 0.0;

bool max_ok = false;

// the innermost loop! (finally!)

while (max_young_length > min_young_length) {

// we'll make sure that min_young_length is always at a

// feasible config

guarantee( min_ok, "invariant" );

++calculations;

max_ok = predict_gc_eff(max_young_length, so_length,

base_time_with_so_ms,

init_free_regions, target_pause_time_ms,

&max_gc_eff);

size_t diff = (max_young_length - min_young_length) / 2;

if (max_ok) {

min_young_length = max_young_length;

min_gc_eff = max_gc_eff;

min_ok = true;

}

max_young_length = min_young_length + diff;

}

// the innermost loop found a config

guarantee( min_ok, "invariant" );

if (min_gc_eff > final_gc_eff) {

// it's the best config so far, so we'll keep it

final_gc_eff = min_gc_eff;

final_young_length = min_young_length;

final_so_length = so_length;

gc_eff_set = true;

}

}

// incremental the fixed S-O length and go around

so_length += so_length_incr;

}

// this is the end of the outermost loop and we need to decide

// what to do during the next iteration

if (pass == pass_type_coarse) {

// we just did the coarse pass (first iteration)

if (!gc_eff_set)

// we didn't find a feasible config so we'll just bail out; of

// course, it might be the case that we missed it; but I'd say

// it's a bit unlikely

done = true;

else {

// We did find a feasible config with optimal GC eff during

// the first pass. So the second pass we'll only consider the

// S-O lengths around that config with a fine increment.

guarantee( so_length_incr == so_coarse_increments, "invariant" );

guarantee( final_so_length >= min_so_length, "invariant" );

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr(" coarse pass: SO length " SIZE_FORMAT,

final_so_length);

#endif // TRACE_CALC_YOUNG_CONFIG

from_so_length =

(final_so_length - min_so_length > so_coarse_increments) ?

final_so_length - so_coarse_increments + 1 : min_so_length;

to_so_length =

(max_so_length - final_so_length > so_coarse_increments) ?

final_so_length + so_coarse_increments - 1 : max_so_length;

pass = pass_type_fine;

so_length_incr = 1;

}

} else if (pass == pass_type_fine) {

// we just finished the second pass

if (!gc_eff_set) {

// we didn't find a feasible config (yes, it's possible;

// notice that, sometimes, we go directly into the fine

// iteration and skip the coarse one) so we bail out

done = true;

} else {

// We did find a feasible config with optimal GC eff

guarantee( so_length_incr == 1, "invariant" );

if (final_so_length == 0) {

// The config is of an empty S-O set, so we'll just bail out

done = true;

} else {

// we'll go around once more, setting the S-O length to 95%

// of the optimal

size_t new_so_length = 950 * final_so_length / 1000;

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr(" fine pass: SO length " SIZE_FORMAT

", setting it to " SIZE_FORMAT,

final_so_length, new_so_length);

#endif // TRACE_CALC_YOUNG_CONFIG

from_so_length = new_so_length;

to_so_length = new_so_length;

fine_so_length = final_so_length;

pass = pass_type_final;

}

}

} else if (pass == pass_type_final) {

// we just finished the final (third) pass

if (!gc_eff_set)

// we didn't find a feasible config, so we'll just use the one

// we found during the second pass, which we saved

final_so_length = fine_so_length;

// and we're done!

done = true;

} else {

guarantee( false, "should never reach here" );

}

// we now go around the outermost loop

}

// we should have at least one region in the target young length

_young_list_target_length =

MAX2((size_t) 1, final_young_length + _recorded_survivor_regions);

if (final_so_length >= final_young_length)

// and we need to ensure that the S-O length is not greater than

// the target young length (this is being a bit careful)

final_so_length = 0;

_young_list_so_prefix_length = final_so_length;

guarantee( !_in_marking_window || !_last_full_young_gc ||

_young_list_so_prefix_length == 0, "invariant" );

// let's keep an eye of how long we spend on this calculation

// right now, I assume that we'll print it when we need it; we

// should really adde it to the breakdown of a pause

double end_time_sec = os::elapsedTime();

double elapsed_time_ms = (end_time_sec - start_time_sec) * 1000.0;

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr("target = %1.1lf ms, young = " SIZE_FORMAT

", SO = " SIZE_FORMAT ", "

"elapsed %1.2lf ms, calcs: " SIZE_FORMAT " (%s%s) "

SIZE_FORMAT SIZE_FORMAT,

target_pause_time_ms,

_young_list_target_length - _young_list_so_prefix_length,

_young_list_so_prefix_length,

elapsed_time_ms,

calculations,

full_young_gcs() ? "full" : "partial",

should_initiate_conc_mark() ? " i-m" : "",

_in_marking_window,

_in_marking_window_im);

#endif // TRACE_CALC_YOUNG_CONFIG

if (_young_list_target_length < _young_list_min_length) {

// bummer; this means that, if we do a pause when the optimal

// config dictates, we'll violate the pause spacing target (the

// min length was calculate based on the application's current

// alloc rate);

// so, we have to bite the bullet, and allocate the minimum

// number. We'll violate our target, but we just can't meet it.

size_t so_length = 0;

// a note further up explains why we do not want an S-O length

// during marking

if (!_in_marking_window && !_last_full_young_gc)

// but we can still try to see whether we can find an optimal

// S-O length

so_length = calculate_optimal_so_length(_young_list_min_length);

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr("adjusted target length from "

SIZE_FORMAT " to " SIZE_FORMAT

", SO " SIZE_FORMAT,

_young_list_target_length, _young_list_min_length,

so_length);

#endif // TRACE_CALC_YOUNG_CONFIG

_young_list_target_length =

MAX2(_young_list_min_length, (size_t)1);

_young_list_so_prefix_length = so_length;

}

} else {

// we are in a partially-young mode or we've run out of regions (due

// to evacuation failure)

#ifdef TRACE_CALC_YOUNG_CONFIG

// leave this in for debugging, just in case

gclog_or_tty->print_cr("(partial) setting target to " SIZE_FORMAT

", SO " SIZE_FORMAT,

_young_list_min_length, 0);

#endif // TRACE_CALC_YOUNG_CONFIG

// we'll do the pause as soon as possible and with no S-O prefix

// (see above for the reasons behind the latter)

_young_list_target_length =

MAX2(_young_list_min_length, (size_t) 1);

_young_list_so_prefix_length = 0;

}

_rs_lengths_prediction = rs_lengths;

}

G1CollectorPolicy::predict_gc_eff(size_t young_length,

size_t so_length,

double base_time_ms,

double* ret_gc_eff,

double* ret_pause_time_ms) {

double so_time_ms = predict_scan_only_time_ms(so_length);

double accum_surv_rate_adj = 0.0;

if (so_length > 0)

accum_surv_rate_adj = accum_yg_surv_rate_pred((int)(so_length - 1));

double accum_surv_rate =

accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj;

size_t bytes_to_copy =

(size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);

double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);

double young_other_time_ms =

predict_young_other_time_ms(young_length - so_length);

double pause_time_ms =

base_time_ms + so_time_ms + copy_time_ms + young_other_time_ms;

size_t reclaimed_bytes =

(young_length - so_length) * HeapRegion::GrainBytes - bytes_to_copy;

double gc_eff = (double) reclaimed_bytes / pause_time_ms;

*ret_gc_eff = gc_eff;

*ret_pause_time_ms = pause_time_ms;

}

G1CollectorPolicy::predict_gc_eff(size_t young_length,

size_t so_length,

double base_time_with_so_ms,

size_t init_free_regions,

double target_pause_time_ms,

double* ret_gc_eff) {

*ret_gc_eff = 0.0;

if (young_length >= init_free_regions)

// end condition 1: not enough space for the young regions

return false;

double accum_surv_rate_adj = 0.0;

if (so_length > 0)

accum_surv_rate_adj = accum_yg_surv_rate_pred((int)(so_length - 1));

double accum_surv_rate =

accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj;

size_t bytes_to_copy =

(size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);

double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);

double young_other_time_ms =

predict_young_other_time_ms(young_length - so_length);

double pause_time_ms =

base_time_with_so_ms + copy_time_ms + young_other_time_ms;

if (pause_time_ms > target_pause_time_ms)

// end condition 2: over the target pause time

return false;

size_t reclaimed_bytes =

(young_length - so_length) * HeapRegion::GrainBytes - bytes_to_copy;

size_t free_bytes =

(init_free_regions - young_length) * HeapRegion::GrainBytes;

if ((2.0 + sigma()) * (double) bytes_to_copy > (double) free_bytes)

// end condition 3: out of to-space (conservatively)

return false;

// success!

double gc_eff = (double) reclaimed_bytes / pause_time_ms;

*ret_gc_eff = gc_eff;

return true;

}

double G1CollectorPolicy::predict_survivor_regions_evac_time() {

double survivor_regions_evac_time = 0.0;

for (HeapRegion * r = _recorded_survivor_head;

r != NULL && r != _recorded_survivor_tail->get_next_young_region();

r = r->get_next_young_region()) {

survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true);

}

return survivor_regions_evac_time;

}

void G1CollectorPolicy::check_prediction_validity() {

guarantee( adaptive_young_list_length(), "should not call this otherwise" );

size_t rs_lengths = _g1->young_list_sampled_rs_lengths();

if (rs_lengths > _rs_lengths_prediction) {

// add 10% to avoid having to recalculate often

size_t rs_lengths_prediction = rs_lengths * 1100 / 1000;

calculate_young_list_target_config(rs_lengths_prediction);

}

}

HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size,

bool is_tlab,

bool* gc_overhead_limit_was_exceeded) {

guarantee(false, "Not using this policy feature yet.");

return NULL;

}

HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size,

bool is_tlab) {

guarantee(false, "Not using this policy feature yet.");

return NULL;

}

#ifndef PRODUCT

bool G1CollectorPolicy::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

}

G1CollectorPolicy::verify_young_ages(HeapRegion* head,

SurvRateGroup *surv_rate_group) {

guarantee( surv_rate_group != NULL, "pre-condition" );

const char* name = surv_rate_group->name();

bool ret = true;

int prev_age = -1;

for (HeapRegion* curr = head;

curr != NULL;

curr = curr->get_next_young_region()) {

SurvRateGroup* group = curr->surv_rate_group();

if (group == NULL && !curr->is_survivor()) {

gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name);

ret = false;

}

if (surv_rate_group == group) {

int age = curr->age_in_surv_rate_group();

if (age < 0) {

gclog_or_tty->print_cr("## %s: encountered negative age", name);

ret = false;

}

if (age <= prev_age) {

gclog_or_tty->print_cr("## %s: region ages are not strictly increasing "

"(%d, %d)", name, age, prev_age);

ret = false;

}

prev_age = age;

}

}

return ret;

}

#endif // PRODUCT

void G1CollectorPolicy::record_full_collection_start() {

_cur_collection_start_sec = os::elapsedTime();

// Release the future to-space so that it is available for compaction into.

_g1->set_full_collection();

}

void G1CollectorPolicy::record_full_collection_end() {

// Consider this like a collection pause for the purposes of allocation

// since last pause.

double end_sec = os::elapsedTime();

double full_gc_time_sec = end_sec - _cur_collection_start_sec;

double full_gc_time_ms = full_gc_time_sec * 1000.0;

_all_full_gc_times_ms->add(full_gc_time_ms);

update_recent_gc_times(end_sec, full_gc_time_ms);

_g1->clear_full_collection();

// "Nuke" the heuristics that control the fully/partially young GC

// transitions and make sure we start with fully young GCs after the

// Full GC.

set_full_young_gcs(true);

_last_full_young_gc = false;

_should_revert_to_full_young_gcs = false;

_should_initiate_conc_mark = false;

_known_garbage_bytes = 0;

_known_garbage_ratio = 0.0;

_in_marking_window = false;

_in_marking_window_im = false;

_short_lived_surv_rate_group->record_scan_only_prefix(0);

_short_lived_surv_rate_group->start_adding_regions();

// also call this on any additional surv rate groups

record_survivor_regions(0, NULL, NULL);

_prev_region_num_young = _region_num_young;

_prev_region_num_tenured = _region_num_tenured;

_free_regions_at_end_of_collection = _g1->free_regions();

_scan_only_regions_at_end_of_collection = 0;

// Reset survivors SurvRateGroup.

_survivor_surv_rate_group->reset();

calculate_young_list_min_length();

calculate_young_list_target_config();

}

void G1CollectorPolicy::record_before_bytes(size_t bytes) {

_bytes_in_to_space_before_gc += bytes;

}

void G1CollectorPolicy::record_after_bytes(size_t bytes) {

_bytes_in_to_space_after_gc += bytes;

}

void G1CollectorPolicy::record_stop_world_start() {

_stop_world_start = os::elapsedTime();

}

void G1CollectorPolicy::record_collection_pause_start(double start_time_sec,

size_t start_used) {

if (PrintGCDetails) {

gclog_or_tty->stamp(PrintGCTimeStamps);

gclog_or_tty->print("[GC pause");

if (in_young_gc_mode())

gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial");

}

assert(_g1->used_regions() == _g1->recalculate_used_regions(),

"sanity");

assert(_g1->used() == _g1->recalculate_used(), "sanity");

double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;

_all_stop_world_times_ms->add(s_w_t_ms);

_stop_world_start = 0.0;

_cur_collection_start_sec = start_time_sec;

_cur_collection_pause_used_at_start_bytes = start_used;

_cur_collection_pause_used_regions_at_start = _g1->used_regions();

_pending_cards = _g1->pending_card_num();

_max_pending_cards = _g1->max_pending_card_num();

_bytes_in_to_space_before_gc = 0;

_bytes_in_to_space_after_gc = 0;

_bytes_in_collection_set_before_gc = 0;

#ifdef DEBUG

// initialise these to something well known so that we can spot

// if they are not set properly

for (int i = 0; i < _parallel_gc_threads; ++i) {

_par_last_ext_root_scan_times_ms[i] = -666.0;

_par_last_mark_stack_scan_times_ms[i] = -666.0;

_par_last_scan_only_times_ms[i] = -666.0;

_par_last_scan_only_regions_scanned[i] = -666.0;

_par_last_update_rs_start_times_ms[i] = -666.0;

_par_last_update_rs_times_ms[i] = -666.0;

_par_last_update_rs_processed_buffers[i] = -666.0;

_par_last_scan_rs_start_times_ms[i] = -666.0;

_par_last_scan_rs_times_ms[i] = -666.0;

_par_last_scan_new_refs_times_ms[i] = -666.0;

_par_last_obj_copy_times_ms[i] = -666.0;

_par_last_termination_times_ms[i] = -666.0;

}

#endif

for (int i = 0; i < _aux_num; ++i) {

_cur_aux_times_ms[i] = 0.0;

_cur_aux_times_set[i] = false;

}

_satb_drain_time_set = false;

_last_satb_drain_processed_buffers = -1;

if (in_young_gc_mode())

_last_young_gc_full = false;

// do that for any other surv rate groups

_short_lived_surv_rate_group->stop_adding_regions();

size_t short_lived_so_length = _young_list_so_prefix_length;

_short_lived_surv_rate_group->record_scan_only_prefix(short_lived_so_length);

tag_scan_only(short_lived_so_length);

if (G1UseSurvivorSpaces) {

_survivors_age_table.clear();

}

assert( verify_young_ages(), "region age verification" );

}

void G1CollectorPolicy::tag_scan_only(size_t short_lived_scan_only_length) {

// done in a way that it can be extended for other surv rate groups too...

HeapRegion* head = _g1->young_list_first_region();

bool finished_short_lived = (short_lived_scan_only_length == 0);

if (finished_short_lived)

return;

for (HeapRegion* curr = head;

curr != NULL;

curr = curr->get_next_young_region()) {

SurvRateGroup* surv_rate_group = curr->surv_rate_group();

int age = curr->age_in_surv_rate_group();

if (surv_rate_group == _short_lived_surv_rate_group) {

if ((size_t)age < short_lived_scan_only_length)

curr->set_scan_only();

else

finished_short_lived = true;

}

if (finished_short_lived)

return;

}

guarantee( false, "we should never reach here" );

}

void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) {

_mark_closure_time_ms = mark_closure_time_ms;

}

void G1CollectorPolicy::record_concurrent_mark_init_start() {

_mark_init_start_sec = os::elapsedTime();

guarantee(!in_young_gc_mode(), "should not do be here in young GC mode");

}

void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double

mark_init_elapsed_time_ms) {

_during_marking = true;

_should_initiate_conc_mark = false;

_cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms;

}

void G1CollectorPolicy::record_concurrent_mark_init_end() {

double end_time_sec = os::elapsedTime();

double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0;

_concurrent_mark_init_times_ms->add(elapsed_time_ms);

record_concurrent_mark_init_end_pre(elapsed_time_ms);

_mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true);

}

void G1CollectorPolicy::record_concurrent_mark_remark_start() {

_mark_remark_start_sec = os::elapsedTime();

_during_marking = false;

}

void G1CollectorPolicy::record_concurrent_mark_remark_end() {

double end_time_sec = os::elapsedTime();

double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;

_concurrent_mark_remark_times_ms->add(elapsed_time_ms);

_cur_mark_stop_world_time_ms += elapsed_time_ms;

_prev_collection_pause_end_ms += elapsed_time_ms;

_mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true);

}

void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {

_mark_cleanup_start_sec = os::elapsedTime();

}

G1CollectorPolicy::record_concurrent_mark_cleanup_end(size_t freed_bytes,

size_t max_live_bytes) {

record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes);

record_concurrent_mark_cleanup_end_work2();

}

G1CollectorPolicy::

record_concurrent_mark_cleanup_end_work1(size_t freed_bytes,

size_t max_live_bytes) {

if (_n_marks < 2) _n_marks++;

if (G1PolicyVerbose > 0)

gclog_or_tty->print_cr("At end of marking, max_live is " SIZE_FORMAT " MB "

" (of " SIZE_FORMAT " MB heap).",

max_live_bytes/M, _g1->capacity()/M);

}

void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() {

double end_time_sec = os::elapsedTime();

double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0;

_concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);

_cur_mark_stop_world_time_ms += elapsed_time_ms;

_prev_collection_pause_end_ms += elapsed_time_ms;

_mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true);

_num_markings++;

// We did a marking, so reset the "since_last_mark" variables.

double considerConcMarkCost = 1.0;

// If there are available processors, concurrent activity is free...

if (Threads::number_of_non_daemon_threads() * 2 <

os::active_processor_count()) {

considerConcMarkCost = 0.0;

}

_n_pauses_at_mark_end = _n_pauses;

_n_marks_since_last_pause++;

_conc_mark_initiated = false;

}

G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {

if (in_young_gc_mode()) {

_should_revert_to_full_young_gcs = false;

_last_full_young_gc = true;

_in_marking_window = false;

if (adaptive_young_list_length())

calculate_young_list_target_config();

}

}

void G1CollectorPolicy::record_concurrent_pause() {

if (_stop_world_start > 0.0) {

double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0;

_all_yield_times_ms->add(yield_ms);

}

}

void G1CollectorPolicy::record_concurrent_pause_end() {

}

void G1CollectorPolicy::record_collection_pause_end_CH_strong_roots() {

_cur_CH_strong_roots_end_sec = os::elapsedTime();

_cur_CH_strong_roots_dur_ms =

(_cur_CH_strong_roots_end_sec - _cur_collection_start_sec) * 1000.0;

}

void G1CollectorPolicy::record_collection_pause_end_G1_strong_roots() {

_cur_G1_strong_roots_end_sec = os::elapsedTime();

_cur_G1_strong_roots_dur_ms =

(_cur_G1_strong_roots_end_sec - _cur_CH_strong_roots_end_sec) * 1000.0;

}

template<class T>

T sum_of(T* sum_arr, int start, int n, int N) {

T sum = (T)0;

for (int i = 0; i < n; i++) {

int j = (start + i) % N;

sum += sum_arr[j];

}

return sum;

}

void G1CollectorPolicy::print_par_stats (int level,

const char* str,

double* data,

bool summary) {

double min = data[0], max = data[0];

double total = 0.0;

int j;

for (j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print("[%s (ms):", str);

for (uint i = 0; i < ParallelGCThreads; ++i) {

double val = data[i];

if (val < min)

min = val;

if (val > max)

max = val;

total += val;

gclog_or_tty->print(" %3.1lf", val);

}

if (summary) {

gclog_or_tty->print_cr("");

double avg = total / (double) ParallelGCThreads;

gclog_or_tty->print(" ");

for (j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print("Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf",

avg, min, max);

}

gclog_or_tty->print_cr("]");

}

void G1CollectorPolicy::print_par_buffers (int level,

const char* str,

double* data,

bool summary) {

double min = data[0], max = data[0];

double total = 0.0;

int j;

for (j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print("[%s :", str);

for (uint i = 0; i < ParallelGCThreads; ++i) {

double val = data[i];

if (val < min)

min = val;

if (val > max)

max = val;

total += val;

gclog_or_tty->print(" %d", (int) val);

}

if (summary) {

gclog_or_tty->print_cr("");

double avg = total / (double) ParallelGCThreads;

gclog_or_tty->print(" ");

for (j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print("Sum: %d, Avg: %d, Min: %d, Max: %d",

(int)total, (int)avg, (int)min, (int)max);

}

gclog_or_tty->print_cr("]");

}

void G1CollectorPolicy::print_stats (int level,

const char* str,

double value) {

for (int j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print_cr("[%s: %5.1lf ms]", str, value);

}

void G1CollectorPolicy::print_stats (int level,

const char* str,

int value) {

for (int j = 0; j < level; ++j)

gclog_or_tty->print(" ");

gclog_or_tty->print_cr("[%s: %d]", str, value);

}

double G1CollectorPolicy::avg_value (double* data) {