graal-compiler: src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 6611:7383557659bd

7185699: G1: Prediction model discrepancies Summary: Correct the result value of G1CollectedHeap::pending_card_num(). Change the code that calculates the GC efficiency of a non-young heap region to use historical data from mixed GCs and the actual number of live bytes when predicting how long it would take to collect the region. Changes were also reviewed by Thomas Schatzl. Reviewed-by: azeemj, brutisso

author	johnc
date	Tue, 21 Aug 2012 14:10:39 -0700
parents	a2f7274eb6ef
children	bb3f6194fedb

comparison

equal deleted inserted replaced

-:f99a36499b8c
+:7383557659bd
 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _prev_collection_pause_end_ms(0.0),
-_pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)),
 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
 _mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _phase_times = new G1GCPhaseTimes(_parallel_gc_threads);
 int index = MIN2(_parallel_gc_threads - 1, 7);
-_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]);
 _young_cards_per_entry_ratio_seq->add(
 young_cards_per_entry_ratio_defaults[index]);
 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]);
 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);
+survivor_regions_evac_time += predict_region_elapsed_time_ms(r, gcs_are_young());
 }
 return survivor_regions_evac_time;
 }
 void G1CollectorPolicy::revise_young_list_target_length_if_necessary() {
 phase_times()->_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();
+_collection_set_bytes_used_before = 0;
-_bytes_in_collection_set_before_gc = 0;
 _bytes_copied_during_gc = 0;
 YoungList* young_list = _g1->young_list();
 _eden_bytes_before_gc = young_list->eden_used_bytes();
 _survivor_bytes_before_gc = young_list->survivor_used_bytes();
 _short_lived_surv_rate_group->start_adding_regions();
 // do that for any other surv rate groupsx
 if (update_stats) {
-size_t diff = 0;
-if (_max_pending_cards >= _pending_cards) {
-diff = _max_pending_cards - _pending_cards;
-}
-_pending_card_diff_seq->add((double) diff);
 double cost_per_card_ms = 0.0;
 if (_pending_cards > 0) {
 cost_per_card_ms = phase_times()->_update_rs_time / (double) _pending_cards;
 _cost_per_card_ms_seq->add(cost_per_card_ms);
 }
 double constant_other_time_ms = all_other_time_ms -
 (young_other_time_ms + non_young_other_time_ms);
 _constant_other_time_ms_seq->add(constant_other_time_ms);
 double survival_ratio = 0.0;
-if (_bytes_in_collection_set_before_gc > 0) {
+if (_collection_set_bytes_used_before > 0) {
 survival_ratio = (double) _bytes_copied_during_gc /
-(double) _bytes_in_collection_set_before_gc;
+(double) _collection_set_bytes_used_before;
 }
 _pending_cards_seq->add((double) _pending_cards);
 _rs_lengths_seq->add((double) _max_rs_lengths);
 }
 }
 dcqs.notify_if_necessary();
 }
 double
+G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
+size_t scanned_cards) {
+return
+predict_rs_update_time_ms(pending_cards) +
+predict_rs_scan_time_ms(scanned_cards) +
+predict_constant_other_time_ms();
+}
+double
 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) {
 size_t rs_length = predict_rs_length_diff();
 size_t card_num;
 if (gcs_are_young()) {
 card_num = predict_young_card_num(rs_length);
 } else {
 card_num = predict_non_young_card_num(rs_length);
 }
 return predict_base_elapsed_time_ms(pending_cards, card_num);
-}
-double
-G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards,
-size_t scanned_cards) {
-return
-predict_rs_update_time_ms(pending_cards) +
-predict_rs_scan_time_ms(scanned_cards) +
-predict_constant_other_time_ms();
-}
-double
-G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
-bool young) {
-size_t rs_length = hr->rem_set()->occupied();
-size_t card_num;
-if (gcs_are_young()) {
-card_num = predict_young_card_num(rs_length);
-} else {
-card_num = predict_non_young_card_num(rs_length);
-}
-size_t bytes_to_copy = predict_bytes_to_copy(hr);
-double region_elapsed_time_ms =
-predict_rs_scan_time_ms(card_num) +
-predict_object_copy_time_ms(bytes_to_copy);
-if (young)
-region_elapsed_time_ms += predict_young_other_time_ms(1);
-else
-region_elapsed_time_ms += predict_non_young_other_time_ms(1);
-return region_elapsed_time_ms;
 }
 size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
 size_t bytes_to_copy;
 if (hr->is_marked())
 int age = hr->age_in_surv_rate_group();
 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group());
 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate);
 }
 return bytes_to_copy;
+}
+double
+G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
+bool for_young_gc) {
+size_t rs_length = hr->rem_set()->occupied();
+size_t card_num;
+// Predicting the number of cards is based on which type of GC
+// we're predicting for.
+if (for_young_gc) {
+card_num = predict_young_card_num(rs_length);
+} else {
+card_num = predict_non_young_card_num(rs_length);
+}
+size_t bytes_to_copy = predict_bytes_to_copy(hr);
+double region_elapsed_time_ms =
+predict_rs_scan_time_ms(card_num) +
+predict_object_copy_time_ms(bytes_to_copy);
+// The prediction of the "other" time for this region is based
+// upon the region type and NOT the GC type.
+if (hr->is_young()) {
+region_elapsed_time_ms += predict_young_other_time_ms(1);
+} else {
+region_elapsed_time_ms += predict_non_young_other_time_ms(1);
+}
+return region_elapsed_time_ms;
 }
 void
 G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length,
 uint survivor_cset_region_length) {
 return expand_bytes;
 } else {
 return 0;
 }
-}
-class CountCSClosure: public HeapRegionClosure {
-G1CollectorPolicy* _g1_policy;
-public:
-CountCSClosure(G1CollectorPolicy* g1_policy) :
-_g1_policy(g1_policy) {}
-bool doHeapRegion(HeapRegion* r) {
-_g1_policy->_bytes_in_collection_set_before_gc += r->used();
-return false;
-}
-};
-void G1CollectorPolicy::count_CS_bytes_used() {
-CountCSClosure cs_closure(this);
-_g1->collection_set_iterate(&cs_closure);
 }
 void G1CollectorPolicy::print_tracing_info() const {
 _trace_gen0_time_data.print();
 _trace_gen1_time_data.print();
 // Therefore this routine may be called at a safepoint by the
 // VM thread, or in-between safepoints by mutator threads (when
 // retiring the current allocation region) or a concurrent
 // refine thread (RSet sampling).
-double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true);
+double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
 size_t used_bytes = hr->used();
 _inc_cset_recorded_rs_lengths += rs_length;
 _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms;
 _inc_cset_bytes_used_before += used_bytes;
 ssize_t old_rs_length = (ssize_t) hr->recorded_rs_length();
 ssize_t rs_lengths_diff = (ssize_t) new_rs_length - old_rs_length;
 _inc_cset_recorded_rs_lengths_diffs += rs_lengths_diff;
 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms();
-double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true);
+double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
 double elapsed_ms_diff = new_region_elapsed_time_ms - old_elapsed_time_ms;
 _inc_cset_predicted_elapsed_time_ms_diffs += elapsed_ms_diff;
 hr->set_recorded_rs_length(new_rs_length);
 hr->set_predicted_elapsed_time_ms(new_region_elapsed_time_ms);
 reclaimable_bytes, perc, threshold);
 return true;
 }
 void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) {
-// Set this here - in case we're not doing young collections.
+double young_start_time_sec = os::elapsedTime();
-double non_young_start_time_sec = os::elapsedTime();
 YoungList* young_list = _g1->young_list();
 finalize_incremental_cset_building();
 guarantee(target_pause_time_ms > 0.0,
 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards);
 double predicted_pause_time_ms = base_time_ms;
 double time_remaining_ms = target_pause_time_ms - base_time_ms;
-ergo_verbose3(ErgoCSetConstruction | ErgoHigh,
+ergo_verbose4(ErgoCSetConstruction | ErgoHigh,
 "start choosing CSet",
+ergo_format_size("_pending_cards")
 ergo_format_ms("predicted base time")
 ergo_format_ms("remaining time")
 ergo_format_ms("target pause time"),
-base_time_ms, time_remaining_ms, target_pause_time_ms);
+_pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms);
-HeapRegion* hr;
-double young_start_time_sec = os::elapsedTime();
-_collection_set_bytes_used_before = 0;
 _last_gc_was_young = gcs_are_young() ? true : false;
 if (_last_gc_was_young) {
 _trace_gen0_time_data.increment_young_collection_count();
 } else {
 //   [Newly Young Regions ++ Survivors from last pause].
 uint survivor_region_length = young_list->survivor_length();
 uint eden_region_length = young_list->length() - survivor_region_length;
 init_cset_region_lengths(eden_region_length, survivor_region_length);
-hr = young_list->first_survivor_region();
+HeapRegion* hr = young_list->first_survivor_region();
 while (hr != NULL) {
 assert(hr->is_survivor(), "badly formed young list");
 hr->set_young();
 hr = hr->get_next_young_region();
 }
 double young_end_time_sec = os::elapsedTime();
 phase_times()->_recorded_young_cset_choice_time_ms =
 (young_end_time_sec - young_start_time_sec) * 1000.0;
-// We are doing young collections so reset this.
+// Set the start of the non-young choice time.
-non_young_start_time_sec = young_end_time_sec;
+double non_young_start_time_sec = young_end_time_sec;
 if (!gcs_are_young()) {
 CollectionSetChooser* cset_chooser = _collectionSetChooser;
 cset_chooser->verify();
 const uint min_old_cset_length = cset_chooser->calc_min_old_cset_length();
 const uint max_old_cset_length = cset_chooser->calc_max_old_cset_length();
 uint expensive_region_num = 0;
 bool check_time_remaining = adaptive_young_list_length();
 HeapRegion* hr = cset_chooser->peek();
 while (hr != NULL) {
 if (old_cset_region_length() >= max_old_cset_length) {
 // Added maximum number of old regions to the CSet.
 ergo_verbose2(ErgoCSetConstruction,
 ergo_format_region("max"),
 old_cset_region_length(), max_old_cset_length);
 break;
 }
-double predicted_time_ms = predict_region_elapsed_time_ms(hr, false);
+double predicted_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young());
 if (check_time_remaining) {
 if (predicted_time_ms > time_remaining_ms) {
 // Too expensive for the current CSet.
 if (old_cset_region_length() >= min_old_cset_length) {
 cset_chooser->verify();
 }
 stop_incremental_cset_building();
-count_CS_bytes_used();
 ergo_verbose5(ErgoCSetConstruction,
 "finish choosing CSet",
 ergo_format_region("eden")
 ergo_format_region("survivors")
 ergo_format_region("old")

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 6611:7383557659bd