jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp

-: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 > jdk8-mips64-public > hotspot / file comparison

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

src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp