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

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 4710:41406797186b

7113012: G1: rename not-fully-young GCs as "mixed" Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets). Reviewed-by: johnc, brutisso

author	tonyp
date	Fri, 16 Dec 2011 02:14:27 -0500
parents	d23d2b18183e
children	67fdcb391461

comparison

equal deleted inserted replaced

-:fd2b426c30db
+:41406797186b
 static double cost_per_card_ms_defaults[] = {
 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015
 };
 // all the same
-static double fully_young_cards_per_entry_ratio_defaults[] = {
+static double young_cards_per_entry_ratio_defaults[] = {
 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0
 };
 static double cost_per_entry_ms_defaults[] = {
 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005
 _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)),
-_fully_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
+_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
-_partially_young_cards_per_entry_ratio_seq(
+_mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)),
-new TruncatedSeq(TruncatedSeqLength)),
 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
-_partially_young_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
+_mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)),
 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)),
 _non_young_other_cost_per_region_ms_seq(
 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
 _pause_time_target_ms((double) MaxGCPauseMillis),
-_full_young_gcs(true),
+_gcs_are_young(true),
-_full_young_pause_num(0),
+_young_pause_num(0),
-_partial_young_pause_num(0),
+_mixed_pause_num(0),
 _during_marking(false),
 _in_marking_window(false),
 _in_marking_window_im(false),
 _known_garbage_ratio(0.0),
 _known_garbage_bytes(0),
 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)),
-_recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)),
+_recent_prev_end_times_for_all_gcs_sec(
+new TruncatedSeq(NumPrevPausesForHeuristics)),
 _recent_avg_pause_time_ratio(0.0),
 _all_full_gc_times_ms(new NumberSeq()),
 _initiate_conc_mark_if_possible(false),
 _during_initial_mark_pause(false),
-_should_revert_to_full_young_gcs(false),
+_should_revert_to_young_gcs(false),
-_last_full_young_gc(false),
+_last_young_gc(false),
+_last_gc_was_young(false),
 _eden_bytes_before_gc(0),
 _survivor_bytes_before_gc(0),
 _capacity_before_gc(0),
 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]);
-_fully_young_cards_per_entry_ratio_seq->add(
+_young_cards_per_entry_ratio_seq->add(
-fully_young_cards_per_entry_ratio_defaults[index]);
+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]);
 desired_max_length = absolute_max_length;
 }
 size_t young_list_target_length = 0;
 if (adaptive_young_list_length()) {
-if (full_young_gcs()) {
+if (gcs_are_young()) {
 young_list_target_length =
 calculate_young_list_target_length(rs_lengths,
 base_min_length,
 desired_min_length,
 desired_max_length);
 // Don't calculate anything and let the code below bound it to
 // the desired_min_length, i.e., do the next GC as soon as
 // possible to maximize how many old regions we can add to it.
 }
 } else {
-if (full_young_gcs()) {
+if (gcs_are_young()) {
 young_list_target_length = _young_list_fixed_length;
 } else {
-// A bit arbitrary: during partially-young GCs we allocate half
+// A bit arbitrary: during mixed GCs we allocate half
 // the young regions to try to add old regions to the CSet.
 young_list_target_length = _young_list_fixed_length / 2;
 // We choose to accept that we might go under the desired min
 // length given that we intentionally ask for a smaller young gen.
 desired_min_length = absolute_min_length;
 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths,
 size_t base_min_length,
 size_t desired_min_length,
 size_t desired_max_length) {
 assert(adaptive_young_list_length(), "pre-condition");
-assert(full_young_gcs(), "only call this for fully-young GCs");
+assert(gcs_are_young(), "only call this for young GCs");
 // In case some edge-condition makes the desired max length too small...
 if (desired_max_length <= desired_min_length) {
 return desired_min_length;
 }
 update_recent_gc_times(end_sec, full_gc_time_ms);
 _g1->clear_full_collection();
-// "Nuke" the heuristics that control the fully/partially young GC
+// "Nuke" the heuristics that control the young/mixed GC
-// transitions and make sure we start with fully young GCs after the
+// transitions and make sure we start with young GCs after the Full GC.
-// Full GC.
+set_gcs_are_young(true);
-set_full_young_gcs(true);
+_last_young_gc = false;
-_last_full_young_gc = false;
+_should_revert_to_young_gcs = false;
-_should_revert_to_full_young_gcs = false;
 clear_initiate_conc_mark_if_possible();
 clear_during_initial_mark_pause();
 _known_garbage_bytes = 0;
 _known_garbage_ratio = 0.0;
 _in_marking_window = false;
 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");
-gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial");
+gclog_or_tty->print(" (%s)", gcs_are_young() ? "young" : "mixed");
 }
 // 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.
 // This is initialized to zero here and is set during
 // the evacuation pause if marking is in progress.
 _cur_satb_drain_time_ms = 0.0;
-_last_young_gc_full = false;
+_last_gc_was_young = false;
 // do that for any other surv rate groups
 _short_lived_surv_rate_group->stop_adding_regions();
 _survivors_age_table.clear();
 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
 _mark_cleanup_start_sec = os::elapsedTime();
 }
 void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
-_should_revert_to_full_young_gcs = false;
+_should_revert_to_young_gcs = false;
-_last_full_young_gc = true;
+_last_young_gc = true;
 _in_marking_window = false;
 }
 void G1CollectorPolicy::record_concurrent_pause() {
 if (_stop_world_start > 0.0) {
 record_concurrent_mark_init_end(0.0);
 size_t marking_initiating_used_threshold =
 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent;
-if (!_g1->mark_in_progress() && !_last_full_young_gc) {
+if (!_g1->mark_in_progress() && !_last_young_gc) {
 assert(!last_pause_included_initial_mark, "invariant");
 if (cur_used_bytes > marking_initiating_used_threshold) {
 if (cur_used_bytes > _prev_collection_pause_used_at_end_bytes) {
 assert(!during_initial_mark_pause(), "we should not see this here");
 if (during_initial_mark_pause()) {
 new_in_marking_window = true;
 new_in_marking_window_im = true;
 }
-if (_last_full_young_gc) {
+if (_last_young_gc) {
 if (!last_pause_included_initial_mark) {
-ergo_verbose2(ErgoPartiallyYoungGCs,
+ergo_verbose2(ErgoMixedGCs,
-"start partially-young GCs",
+"start mixed GCs",
 ergo_format_byte_perc("known garbage"),
 _known_garbage_bytes, _known_garbage_ratio * 100.0);
-set_full_young_gcs(false);
+set_gcs_are_young(false);
 } else {
-ergo_verbose0(ErgoPartiallyYoungGCs,
+ergo_verbose0(ErgoMixedGCs,
-"do not start partially-young GCs",
+"do not start mixed GCs",
 ergo_format_reason("concurrent cycle is about to start"));
 }
-_last_full_young_gc = false;
+_last_young_gc = false;
 }
-if ( !_last_young_gc_full ) {
+if (!_last_gc_was_young) {
-if (_should_revert_to_full_young_gcs) {
+if (_should_revert_to_young_gcs) {
-ergo_verbose2(ErgoPartiallyYoungGCs,
+ergo_verbose2(ErgoMixedGCs,
-"end partially-young GCs",
+"end mixed GCs",
-ergo_format_reason("partially-young GCs end requested")
+ergo_format_reason("mixed GCs end requested")
 ergo_format_byte_perc("known garbage"),
 _known_garbage_bytes, _known_garbage_ratio * 100.0);
-set_full_young_gcs(true);
+set_gcs_are_young(true);
 } else if (_known_garbage_ratio < 0.05) {
-ergo_verbose3(ErgoPartiallyYoungGCs,
+ergo_verbose3(ErgoMixedGCs,
-"end partially-young GCs",
+"end mixed GCs",
 ergo_format_reason("known garbage percent lower than threshold")
 ergo_format_byte_perc("known garbage")
 ergo_format_perc("threshold"),
 _known_garbage_bytes, _known_garbage_ratio * 100.0,
 0.05 * 100.0);
-set_full_young_gcs(true);
+set_gcs_are_young(true);
 } else if (adaptive_young_list_length() &&
 (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) {
-ergo_verbose5(ErgoPartiallyYoungGCs,
+ergo_verbose5(ErgoMixedGCs,
-"end partially-young GCs",
+"end mixed GCs",
 ergo_format_reason("current GC efficiency lower than "
-"predicted fully-young GC efficiency")
+"predicted young GC efficiency")
 ergo_format_double("GC efficiency factor")
 ergo_format_double("current GC efficiency")
-ergo_format_double("predicted fully-young GC efficiency")
+ergo_format_double("predicted young GC efficiency")
 ergo_format_byte_perc("known garbage"),
 get_gc_eff_factor(), cur_efficiency,
 predict_young_gc_eff(),
 _known_garbage_bytes, _known_garbage_ratio * 100.0);
-set_full_young_gcs(true);
+set_gcs_are_young(true);
 }
 }
-_should_revert_to_full_young_gcs = false;
+_should_revert_to_young_gcs = false;
-if (_last_young_gc_full && !_during_marking) {
+if (_last_gc_was_young && !_during_marking) {
 _young_gc_eff_seq->add(cur_efficiency);
 }
 _short_lived_surv_rate_group->start_adding_regions();
 // do that for any other surv rate groupsx
 size_t cards_scanned = _g1->cards_scanned();
 double cost_per_entry_ms = 0.0;
 if (cards_scanned > 10) {
 cost_per_entry_ms = scan_rs_time / (double) cards_scanned;
-if (_last_young_gc_full)
+if (_last_gc_was_young) {
 _cost_per_entry_ms_seq->add(cost_per_entry_ms);
-else
+} else {
-_partially_young_cost_per_entry_ms_seq->add(cost_per_entry_ms);
+_mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms);
+}
 }
 if (_max_rs_lengths > 0) {
 double cards_per_entry_ratio =
 (double) cards_scanned / (double) _max_rs_lengths;
-if (_last_young_gc_full)
+if (_last_gc_was_young) {
-_fully_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
+_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
-else
+} else {
-_partially_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
+_mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio);
+}
 }
 // It turns out that, sometimes, _max_rs_lengths can get smaller
 // than _recorded_rs_lengths which causes rs_length_diff to get
 // very large and mess up the RSet length predictions. We'll be
 size_t copied_bytes = surviving_bytes;
 double cost_per_byte_ms = 0.0;
 if (copied_bytes > 0) {
 cost_per_byte_ms = obj_copy_time / (double) copied_bytes;
-if (_in_marking_window)
+if (_in_marking_window) {
 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms);
-else
+} else {
 _cost_per_byte_ms_seq->add(cost_per_byte_ms);
+}
 }
 double all_other_time_ms = pause_time_ms -
 (update_rs_time + scan_rs_time + obj_copy_time +
 _mark_closure_time_ms + termination_time);
 young_num += adjustment;
 size_t pending_cards = predict_pending_cards();
 size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() +
 predict_rs_length_diff();
 size_t card_num;
-if (full_young_gcs())
+if (gcs_are_young()) {
 card_num = predict_young_card_num(rs_lengths);
-else
+} else {
 card_num = predict_non_young_card_num(rs_lengths);
+}
 size_t young_byte_size = young_num * HeapRegion::GrainBytes;
 double accum_yg_surv_rate =
 _short_lived_surv_rate_group->accum_surv_rate(adjustment);
 size_t bytes_to_copy =
 double
 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) {
 size_t rs_length = predict_rs_length_diff();
 size_t card_num;
-if (full_young_gcs())
+if (gcs_are_young()) {
 card_num = predict_young_card_num(rs_length);
-else
+} 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,
 double
 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr,
 bool young) {
 size_t rs_length = hr->rem_set()->occupied();
 size_t card_num;
-if (full_young_gcs())
+if (gcs_are_young()) {
 card_num = predict_young_card_num(rs_length);
-else
+} 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);
 void G1CollectorPolicy::check_if_region_is_too_expensive(double
 predicted_time_ms) {
 // I don't think we need to do this when in young GC mode since
 // marking will be initiated next time we hit the soft limit anyway...
 if (predicted_time_ms > _expensive_region_limit_ms) {
-ergo_verbose2(ErgoPartiallyYoungGCs,
+ergo_verbose2(ErgoMixedGCs,
-"request partially-young GCs end",
+"request mixed GCs end",
 ergo_format_reason("predicted region time higher than threshold")
 ergo_format_ms("predicted region time")
 ergo_format_ms("threshold"),
 predicted_time_ms, _expensive_region_limit_ms);
-// no point in doing another partial one
+// no point in doing another mixed GC
-_should_revert_to_full_young_gcs = true;
+_should_revert_to_young_gcs = true;
 }
 }
 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec,
 double elapsed_ms) {
 if (TraceGen0Time) {
 gclog_or_tty->print_cr("ALL PAUSES");
 print_summary_sd(0, "Total", _all_pause_times_ms);
 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("   Young GC Pauses: %8d", _young_pause_num);
-gclog_or_tty->print_cr("   Partial Young GC Pauses: %8d", _partial_young_pause_num);
+gclog_or_tty->print_cr("   Mixed GC Pauses: %8d", _mixed_pause_num);
 gclog_or_tty->print_cr("");
 gclog_or_tty->print_cr("EVACUATION PAUSES");
 print_summary(_summary);
 // The concurrent marking thread is not "during a cycle", i.e.,
 // it has completed the last one. So we can go ahead and
 // initiate a new cycle.
 set_during_initial_mark_pause();
-// We do not allow non-full young GCs during marking.
+// We do not allow mixed GCs during marking.
-if (!full_young_gcs()) {
+if (!gcs_are_young()) {
-set_full_young_gcs(true);
+set_gcs_are_young(true);
-ergo_verbose0(ErgoPartiallyYoungGCs,
+ergo_verbose0(ErgoMixedGCs,
-"end partially-young GCs",
+"end mixed GCs",
 ergo_format_reason("concurrent cycle is about to start"));
 }
 // And we can now clear initiate_conc_mark_if_possible() as
 // we've already acted on it.
 HeapRegion* hr;
 double young_start_time_sec = os::elapsedTime();
 _collection_set_bytes_used_before = 0;
-_last_young_gc_full = full_young_gcs() ? true : false;
+_last_gc_was_young = gcs_are_young() ? true : false;
-if (_last_young_gc_full) {
+if (_last_gc_was_young) {
-++_full_young_pause_num;
+++_young_pause_num;
 } else {
-++_partial_young_pause_num;
+++_mixed_pause_num;
 }
 // The young list is laid with the survivor regions from the previous
 // pause are appended to the RHS of the young list, i.e.
 //   [Newly Young Regions ++ Survivors from last pause].
 (young_end_time_sec - young_start_time_sec) * 1000.0;
 // We are doing young collections so reset this.
 non_young_start_time_sec = young_end_time_sec;
-if (!full_young_gcs()) {
+if (!gcs_are_young()) {
 bool should_continue = true;
 NumberSeq seq;
 double avg_prediction = 100000000000000000.0; // something very large
 double prev_predicted_pause_time_ms = predicted_pause_time_ms;
 }
 }
 } while (should_continue);
 if (!adaptive_young_list_length() &&
 cset_region_length() < _young_list_fixed_length) {
 ergo_verbose2(ErgoCSetConstruction,
-"request partially-young GCs end",
+"request mixed GCs end",
 ergo_format_reason("CSet length lower than target")
 ergo_format_region("CSet")
 ergo_format_region("young target"),
 cset_region_length(), _young_list_fixed_length);
-_should_revert_to_full_young_gcs  = true;
+_should_revert_to_young_gcs  = true;
 }
 ergo_verbose2(ErgoCSetConstruction | ErgoHigh,
 "add old regions to CSet",
 ergo_format_region("old")

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 4710:41406797186b