truffle: src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 677:96b229c54d1e

6543938: G1: remove the concept of popularity Reviewed-by: iveresov, tonyp

author	apetrusenko
date	Wed, 25 Mar 2009 13:10:54 -0700
parents	2314b7336582
children	20c6f43950b5

comparison

equal deleted inserted replaced

-:59f139e8a8d1
+:96b229c54d1e
 _all_stop_world_times_ms(new NumberSeq()),
 _all_yield_times_ms(new NumberSeq()),
 _all_mod_union_times_ms(new NumberSeq()),
-_non_pop_summary(new NonPopSummary()),
+_summary(new Summary()),
-_pop_summary(new PopSummary()),
+_abandoned_summary(new AbandonedSummary()),
-_non_pop_abandoned_summary(new NonPopAbandonedSummary()),
-_pop_abandoned_summary(new PopAbandonedSummary()),
 _cur_clear_ct_time_ms(0.0),
 _region_num_young(0),
 _region_num_tenured(0),
 _aux_num(10),
 _all_aux_times_ms(new NumberSeq[_aux_num]),
 _cur_aux_start_times_ms(new double[_aux_num]),
 _cur_aux_times_ms(new double[_aux_num]),
 _cur_aux_times_set(new bool[_aux_num]),
-_pop_compute_rc_start(0.0),
-_pop_evac_start(0.0),
 _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _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];
-// we store the data from the first pass during popularity pauses
-_pop_par_last_update_rs_start_times_ms = new double[_parallel_gc_threads];
-_pop_par_last_update_rs_times_ms = new double[_parallel_gc_threads];
-_pop_par_last_update_rs_processed_buffers = new double[_parallel_gc_threads];
-_pop_par_last_scan_rs_start_times_ms = new double[_parallel_gc_threads];
-_pop_par_last_scan_rs_times_ms = new double[_parallel_gc_threads];
-_pop_par_last_closure_app_times_ms = new double[_parallel_gc_threads];
 // start conservatively
 _expensive_region_limit_ms = 0.5 * (double) G1MaxPauseTimeMS;
 // <NEW PREDICTION>
 _survivor_surv_rate_group->reset();
 calculate_young_list_min_length();
 calculate_young_list_target_config();
 }
-void G1CollectorPolicy::record_pop_compute_rc_start() {
-_pop_compute_rc_start = os::elapsedTime();
-}
-void G1CollectorPolicy::record_pop_compute_rc_end() {
-double ms = (os::elapsedTime() - _pop_compute_rc_start)*1000.0;
-_cur_popular_compute_rc_time_ms = ms;
-_pop_compute_rc_start = 0.0;
-}
-void G1CollectorPolicy::record_pop_evac_start() {
-_pop_evac_start = os::elapsedTime();
-}
-void G1CollectorPolicy::record_pop_evac_end() {
-double ms = (os::elapsedTime() - _pop_evac_start)*1000.0;
-_cur_popular_evac_time_ms = ms;
-_pop_evac_start = 0.0;
-}
 void G1CollectorPolicy::record_before_bytes(size_t bytes) {
 _bytes_in_to_space_before_gc += bytes;
 }
 void G1CollectorPolicy::record_after_bytes(size_t bytes) {
 _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;
-_pop_par_last_update_rs_start_times_ms[i] = -666.0;
-_pop_par_last_update_rs_times_ms[i] = -666.0;
-_pop_par_last_update_rs_processed_buffers[i] = -666.0;
-_pop_par_last_scan_rs_start_times_ms[i] = -666.0;
-_pop_par_last_scan_rs_times_ms[i] = -666.0;
-_pop_par_last_closure_app_times_ms[i] = -666.0;
 }
 #endif
 for (int i = 0; i < _aux_num; ++i) {
 _cur_aux_times_ms[i] = 0.0;
 if (finished_short_lived)
 return;
 }
 guarantee( false, "we should never reach here" );
-}
-void G1CollectorPolicy::record_popular_pause_preamble_start() {
-_cur_popular_preamble_start_ms = os::elapsedTime() * 1000.0;
-}
-void G1CollectorPolicy::record_popular_pause_preamble_end() {
-_cur_popular_preamble_time_ms =
-(os::elapsedTime() * 1000.0) - _cur_popular_preamble_start_ms;
-// copy the recorded statistics of the first pass to temporary arrays
-for (int i = 0; i < _parallel_gc_threads; ++i) {
-_pop_par_last_update_rs_start_times_ms[i] = _par_last_update_rs_start_times_ms[i];
-_pop_par_last_update_rs_times_ms[i] = _par_last_update_rs_times_ms[i];
-_pop_par_last_update_rs_processed_buffers[i] = _par_last_update_rs_processed_buffers[i];
-_pop_par_last_scan_rs_start_times_ms[i] = _par_last_scan_rs_start_times_ms[i];
-_pop_par_last_scan_rs_times_ms[i] = _par_last_scan_rs_times_ms[i];
-_pop_par_last_closure_app_times_ms[i] = _par_last_obj_copy_times_ms[i];
-}
 }
 void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) {
 _mark_closure_time_ms = mark_closure_time_ms;
 }
 }
 // Anything below that is considered to be zero
 #define MIN_TIMER_GRANULARITY 0.0000001
-void G1CollectorPolicy::record_collection_pause_end(bool popular,
+void G1CollectorPolicy::record_collection_pause_end(bool abandoned) {
-bool abandoned) {
 double end_time_sec = os::elapsedTime();
 double elapsed_ms = _last_pause_time_ms;
 bool parallel = ParallelGCThreads > 0;
 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0;
 size_t rs_size =
 if (G1PolicyVerbose > 1) {
 gclog_or_tty->print_cr("   Recording collection pause(%d)", _n_pauses);
 }
 PauseSummary* summary;
-if (!abandoned && !popular)
+if (abandoned) {
-summary = _non_pop_summary;
+summary = _abandoned_summary;
-else if (!abandoned && popular)
+} else {
-summary = _pop_summary;
+summary = _summary;
-else if (abandoned && !popular)
-summary = _non_pop_abandoned_summary;
-else if (abandoned && popular)
-summary = _pop_abandoned_summary;
-else
-guarantee(false, "should not get here!");
-double pop_update_rs_time;
-double pop_update_rs_processed_buffers;
-double pop_scan_rs_time;
-double pop_closure_app_time;
-double pop_other_time;
-if (popular) {
-PopPreambleSummary* preamble_summary = summary->pop_preamble_summary();
-guarantee(preamble_summary != NULL, "should not be null!");
-pop_update_rs_time = avg_value(_pop_par_last_update_rs_times_ms);
-pop_update_rs_processed_buffers =
-sum_of_values(_pop_par_last_update_rs_processed_buffers);
-pop_scan_rs_time = avg_value(_pop_par_last_scan_rs_times_ms);
-pop_closure_app_time = avg_value(_pop_par_last_closure_app_times_ms);
-pop_other_time = _cur_popular_preamble_time_ms -
-(pop_update_rs_time + pop_scan_rs_time + pop_closure_app_time +
-_cur_popular_evac_time_ms);
-preamble_summary->record_pop_preamble_time_ms(_cur_popular_preamble_time_ms);
-preamble_summary->record_pop_update_rs_time_ms(pop_update_rs_time);
-preamble_summary->record_pop_scan_rs_time_ms(pop_scan_rs_time);
-preamble_summary->record_pop_closure_app_time_ms(pop_closure_app_time);
-preamble_summary->record_pop_evacuation_time_ms(_cur_popular_evac_time_ms);
-preamble_summary->record_pop_other_time_ms(pop_other_time);
 }
 double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms);
 double mark_stack_scan_time = avg_value(_par_last_mark_stack_scan_times_ms);
 double scan_only_time = avg_value(_par_last_scan_only_times_ms);
 gclog_or_tty->print_cr("       Recent %% gc pause time: %6.2f",
 recent_avg_pause_time_ratio() * 100.0);
 }
 double other_time_ms = elapsed_ms;
-if (popular)
-other_time_ms -= _cur_popular_preamble_time_ms;
 if (!abandoned) {
 if (_satb_drain_time_set)
 other_time_ms -= _cur_satb_drain_time_ms;
 scan_rs_time + obj_copy_time;
 }
 if (PrintGCDetails) {
 gclog_or_tty->print_cr("%s%s, %1.8lf secs]",
-(popular && !abandoned) ? " (popular)" :
+abandoned ? " (abandoned)" : "",
-(!popular && abandoned) ? " (abandoned)" :
-(popular && abandoned) ? " (popular/abandoned)" : "",
 (last_pause_included_initial_mark) ? " (initial-mark)" : "",
 elapsed_ms / 1000.0);
 if (!abandoned) {
-if (_satb_drain_time_set)
+if (_satb_drain_time_set) {
 print_stats(1, "SATB Drain Time", _cur_satb_drain_time_ms);
-if (_last_satb_drain_processed_buffers >= 0)
+}
+if (_last_satb_drain_processed_buffers >= 0) {
 print_stats(2, "Processed Buffers", _last_satb_drain_processed_buffers);
 }
-if (popular)
+if (parallel) {
-print_stats(1, "Popularity Preamble", _cur_popular_preamble_time_ms);
+print_stats(1, "Parallel Time", _cur_collection_par_time_ms);
-if (parallel) {
+print_par_stats(2, "Update RS (Start)", _par_last_update_rs_start_times_ms, false);
-if (popular) {
+print_par_stats(2, "Update RS", _par_last_update_rs_times_ms);
-print_par_stats(2, "Update RS (Start)", _pop_par_last_update_rs_start_times_ms, false);
-print_par_stats(2, "Update RS", _pop_par_last_update_rs_times_ms);
 if (G1RSBarrierUseQueue)
 print_par_buffers(3, "Processed Buffers",
-_pop_par_last_update_rs_processed_buffers, true);
+_par_last_update_rs_processed_buffers, true);
-print_par_stats(2, "Scan RS", _pop_par_last_scan_rs_times_ms);
-print_par_stats(2, "Closure app", _pop_par_last_closure_app_times_ms);
-print_stats(2, "Evacuation", _cur_popular_evac_time_ms);
-print_stats(2, "Other", pop_other_time);
-}
-if (!abandoned) {
-print_stats(1, "Parallel Time", _cur_collection_par_time_ms);
-if (!popular) {
-print_par_stats(2, "Update RS (Start)", _par_last_update_rs_start_times_ms, false);
-print_par_stats(2, "Update RS", _par_last_update_rs_times_ms);
-if (G1RSBarrierUseQueue)
-print_par_buffers(3, "Processed Buffers",
-_par_last_update_rs_processed_buffers, true);
-}
 print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms);
 print_par_stats(2, "Mark Stack Scanning", _par_last_mark_stack_scan_times_ms);
 print_par_stats(2, "Scan-Only Scanning", _par_last_scan_only_times_ms);
 print_par_buffers(3, "Scan-Only Regions",
 _par_last_scan_only_regions_scanned, true);
 print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms);
 print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms);
 print_par_stats(2, "Termination", _par_last_termination_times_ms);
 print_stats(2, "Other", parallel_other_time);
 print_stats(1, "Clear CT", _cur_clear_ct_time_ms);
-}
+} else {
-} else {
+print_stats(1, "Update RS", update_rs_time);
-if (popular) {
-print_stats(2, "Update RS", pop_update_rs_time);
 if (G1RSBarrierUseQueue)
-print_stats(3, "Processed Buffers",
+print_stats(2, "Processed Buffers",
-(int)pop_update_rs_processed_buffers);
+(int)update_rs_processed_buffers);
-print_stats(2, "Scan RS", pop_scan_rs_time);
-print_stats(2, "Closure App", pop_closure_app_time);
-print_stats(2, "Evacuation", _cur_popular_evac_time_ms);
-print_stats(2, "Other", pop_other_time);
-}
-if (!abandoned) {
-if (!popular) {
-print_stats(1, "Update RS", update_rs_time);
-if (G1RSBarrierUseQueue)
-print_stats(2, "Processed Buffers",
-(int)update_rs_processed_buffers);
-}
 print_stats(1, "Ext Root Scanning", ext_root_scan_time);
 print_stats(1, "Mark Stack Scanning", mark_stack_scan_time);
 print_stats(1, "Scan-Only Scanning", scan_only_time);
 print_stats(1, "Scan RS", scan_rs_time);
 print_stats(1, "Object Copying", obj_copy_time);
 _short_lived_surv_rate_group->start_adding_regions();
 // do that for any other surv rate groupsx
 // <NEW PREDICTION>
-if (!popular && update_stats) {
+if (update_stats) {
 double pause_time_ms = elapsed_ms;
 size_t diff = 0;
 if (_max_pending_cards >= _pending_cards)
 diff = _max_pending_cards - _pending_cards;
 }
 void G1CollectorPolicy::print_summary(PauseSummary* summary) const {
 bool parallel = ParallelGCThreads > 0;
 MainBodySummary*    body_summary = summary->main_body_summary();
-PopPreambleSummary* preamble_summary = summary->pop_preamble_summary();
 if (summary->get_total_seq()->num() > 0) {
-print_summary_sd(0,
+print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq());
-(preamble_summary == NULL) ? "Non-Popular Pauses" :
-"Popular Pauses",
-summary->get_total_seq());
-if (preamble_summary != NULL) {
-print_summary(1, "Popularity Preamble",
-preamble_summary->get_pop_preamble_seq());
-print_summary(2, "Update RS", preamble_summary->get_pop_update_rs_seq());
-print_summary(2, "Scan RS", preamble_summary->get_pop_scan_rs_seq());
-print_summary(2, "Closure App",
-preamble_summary->get_pop_closure_app_seq());
-print_summary(2, "Evacuation",
-preamble_summary->get_pop_evacuation_seq());
-print_summary(2, "Other", preamble_summary->get_pop_other_seq());
-{
-NumberSeq* other_parts[] = {
-preamble_summary->get_pop_update_rs_seq(),
-preamble_summary->get_pop_scan_rs_seq(),
-preamble_summary->get_pop_closure_app_seq(),
-preamble_summary->get_pop_evacuation_seq()
-};
-NumberSeq calc_other_times_ms(preamble_summary->get_pop_preamble_seq(),
-4, other_parts);
-check_other_times(2, preamble_summary->get_pop_other_seq(),
-&calc_other_times_ms);
-}
-}
 if (body_summary != NULL) {
 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq());
 if (parallel) {
 print_summary(1, "Parallel Time", body_summary->get_parallel_seq());
 print_summary(2, "Update RS", body_summary->get_update_rs_seq());
 // not abandoned
 if (parallel) {
 // parallel
 NumberSeq* other_parts[] = {
 body_summary->get_satb_drain_seq(),
-(preamble_summary == NULL) ? NULL :
-preamble_summary->get_pop_preamble_seq(),
 body_summary->get_parallel_seq(),
 body_summary->get_clear_ct_seq()
 };
-calc_other_times_ms = NumberSeq (summary->get_total_seq(),
+calc_other_times_ms = NumberSeq(summary->get_total_seq(),
-4, other_parts);
+3, other_parts);
 } else {
 // serial
 NumberSeq* other_parts[] = {
 body_summary->get_satb_drain_seq(),
-(preamble_summary == NULL) ? NULL :
-preamble_summary->get_pop_preamble_seq(),
 body_summary->get_update_rs_seq(),
 body_summary->get_ext_root_scan_seq(),
 body_summary->get_mark_stack_scan_seq(),
 body_summary->get_scan_only_seq(),
 body_summary->get_scan_rs_seq(),
 body_summary->get_obj_copy_seq()
 };
 calc_other_times_ms = NumberSeq(summary->get_total_seq(),
-8, other_parts);
+7, other_parts);
 }
 } else {
 // abandoned
-NumberSeq* other_parts[] = {
+calc_other_times_ms = NumberSeq();
-(preamble_summary == NULL) ? NULL :
-preamble_summary->get_pop_preamble_seq()
-};
-calc_other_times_ms = NumberSeq(summary->get_total_seq(),
-1, other_parts);
 }
 check_other_times(1,  summary->get_other_seq(), &calc_other_times_ms);
 }
 } else {
 print_indent(0);
 }
 gclog_or_tty->print_cr("");
 }
 void
-G1CollectorPolicy::print_abandoned_summary(PauseSummary* non_pop_summary,
+G1CollectorPolicy::print_abandoned_summary(PauseSummary* summary) const {
-PauseSummary* pop_summary) const {
 bool printed = false;
-if (non_pop_summary->get_total_seq()->num() > 0) {
+if (summary->get_total_seq()->num() > 0) {
 printed = true;
-print_summary(non_pop_summary);
+print_summary(summary);
 }
-if (pop_summary->get_total_seq()->num() > 0) {
-printed = true;
-print_summary(pop_summary);
-}
 if (!printed) {
 print_indent(0);
 gclog_or_tty->print_cr("none");
 gclog_or_tty->print_cr("");
 }
 gclog_or_tty->print_cr("");
 gclog_or_tty->print_cr("   Full Young GC Pauses:    %8d", _full_young_pause_num);
 gclog_or_tty->print_cr("   Partial Young GC Pauses: %8d", _partial_young_pause_num);
 gclog_or_tty->print_cr("");
-gclog_or_tty->print_cr("NON-POPULAR PAUSES");
+gclog_or_tty->print_cr("EVACUATION PAUSES");
-print_summary(_non_pop_summary);
+print_summary(_summary);
-gclog_or_tty->print_cr("POPULAR PAUSES");
-print_summary(_pop_summary);
 gclog_or_tty->print_cr("ABANDONED PAUSES");
-print_abandoned_summary(_non_pop_abandoned_summary,
+print_abandoned_summary(_abandoned_summary);
-_pop_abandoned_summary);
 gclog_or_tty->print_cr("MISC");
 print_summary_sd(0, "Stop World", _all_stop_world_times_ms);
 print_summary_sd(0, "Yields", _all_yield_times_ms);
 for (int i = 0; i < _aux_num; ++i) {
 gclog_or_tty->print_cr("%d regions.", _conc_refine_current_delta);
 }
 _conc_refine_enabled++;
 }
-void G1CollectorPolicy::set_single_region_collection_set(HeapRegion* hr) {
-assert(collection_set() == NULL, "Must be no current CS.");
-_collection_set_size = 0;
-_collection_set_bytes_used_before = 0;
-add_to_collection_set(hr);
-count_CS_bytes_used();
-}
 bool
 G1CollectorPolicy::should_add_next_region_to_young_list() {
 assert(in_young_gc_mode(), "should be in young GC mode");
 bool ret;
 size_t young_list_length = _g1->young_list_length();
 } else {
 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(
 HeapRegion::GrainWords * _max_survivor_regions);
 }
 }
-void
-G1CollectorPolicy_BestRegionsFirst::
-set_single_region_collection_set(HeapRegion* hr) {
-G1CollectorPolicy::set_single_region_collection_set(hr);
-_collectionSetChooser->removeRegion(hr);
-}
 bool
 G1CollectorPolicy_BestRegionsFirst::should_do_collection_pause(size_t
 word_size) {
 assert(_g1->regions_accounted_for(), "Region leakage!");
 _g1->register_region_with_in_cset_fast_test(hr);
 }
 void
 G1CollectorPolicy_BestRegionsFirst::
-choose_collection_set(HeapRegion* pop_region) {
+choose_collection_set() {
 double non_young_start_time_sec;
 start_recording_regions();
-if (pop_region != NULL) {
+guarantee(_target_pause_time_ms > -1.0,
-_target_pause_time_ms = (double) G1MaxPauseTimeMS;
+"_target_pause_time_ms should have been set!");
-} else {
+assert(_collection_set == NULL, "Precondition");
-guarantee(_target_pause_time_ms > -1.0,
-"_target_pause_time_ms should have been set!");
-}
-// pop region is either null (and so is CS), or else it *is* the CS.
-assert(_collection_set == pop_region, "Precondition");
 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
 double predicted_pause_time_ms = base_time_ms;
 double target_time_ms = _target_pause_time_ms;
 size_t max_live_bytes = _g1->free_regions() * HeapRegion::GrainBytes;
 size_t expansion_bytes =
 _g1->expansion_regions() * HeapRegion::GrainBytes;
-if (pop_region == NULL) {
+_collection_set_bytes_used_before = 0;
-_collection_set_bytes_used_before = 0;
+_collection_set_size = 0;
-_collection_set_size = 0;
-}
 // Adjust for expansion and slop.
 max_live_bytes = max_live_bytes + expansion_bytes;
-assert(pop_region != NULL || _g1->regions_accounted_for(), "Region leakage!");
+assert(_g1->regions_accounted_for(), "Region leakage!");
 HeapRegion* hr;
 if (in_young_gc_mode()) {
 double young_start_time_sec = os::elapsedTime();
 ++_young_cset_length;
 double predicted_time_ms = predict_region_elapsed_time_ms(hr, true);
 time_remaining_ms -= predicted_time_ms;
 predicted_pause_time_ms += predicted_time_ms;
-if (hr == pop_region) {
+assert(!hr->in_collection_set(), "invariant");
-// The popular region was young.  Skip over it.
+add_to_collection_set(hr);
-assert(hr->in_collection_set(), "It's the pop region.");
+record_cset_region(hr, true);
-} else {
-assert(!hr->in_collection_set(), "It's not the pop region.");
-add_to_collection_set(hr);
-record_cset_region(hr, true);
-}
 max_live_bytes -= MIN2(hr->max_live_bytes(), max_live_bytes);
 if (G1PolicyVerbose > 0) {
 gclog_or_tty->print_cr("  Added [" PTR_FORMAT ", " PTR_FORMAT") to CS.",
 hr->bottom(), hr->end());
 gclog_or_tty->print_cr("    (" SIZE_FORMAT " KB left in heap.)",
 if (_young_cset_length > 0 && _last_young_gc_full) {
 // don't bother adding more regions...
 goto choose_collection_set_end;
 }
-} else if (pop_region != NULL) {
-// We're not in young mode, and we chose a popular region; don't choose
-// any more.
-return;
 }
 if (!in_young_gc_mode() || !full_young_gcs()) {
 bool should_continue = true;
 NumberSeq seq;
 double avg_prediction = 100000000000000000.0; // something very large
 do {
 hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms,
 avg_prediction);
-if (hr != NULL && !hr->popular()) {
+if (hr != NULL) {
 double predicted_time_ms = predict_region_elapsed_time_ms(hr, false);
 time_remaining_ms -= predicted_time_ms;
 predicted_pause_time_ms += predicted_time_ms;
 add_to_collection_set(hr);
 record_cset_region(hr, false);
 size_t expansion_bytes = numRegions * HeapRegion::GrainBytes;
 _g1->expand(expansion_bytes);
 }
 void G1CollectorPolicy_BestRegionsFirst::
-record_collection_pause_end(bool popular, bool abandoned) {
+record_collection_pause_end(bool abandoned) {
-G1CollectorPolicy::record_collection_pause_end(popular, abandoned);
+G1CollectorPolicy::record_collection_pause_end(abandoned);
 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end.");
 }
 // Local Variables: ***
 // c-indentation-style: gnu ***

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 677:96b229c54d1e