8295149: Misnomer for_young_gc instead of for_young_only_phase in G1Analytics

Reviewed-by: kbarrett, iwalulya

Author: Thomas Schatzl

src/hotspot/share/gc/g1/g1Analytics.cpp

@@ -172,32 +172,32 @@ void G1Analytics::report_dirtied_cards_rate_ms(double cards_per_ms) {
   _dirtied_cards_rate_ms_seq->add(cards_per_ms);
 }
 
-void G1Analytics::report_cost_per_card_scan_ms(double cost_per_card_ms, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_cost_per_card_scan_ms(double cost_per_card_ms, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_cost_per_card_scan_ms_seq->add(cost_per_card_ms);
   } else {
     _mixed_cost_per_card_scan_ms_seq->add(cost_per_card_ms);
   }
 }
 
-void G1Analytics::report_cost_per_card_merge_ms(double cost_per_card_ms, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_cost_per_card_merge_ms(double cost_per_card_ms, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_cost_per_card_merge_ms_seq->add(cost_per_card_ms);
   } else {
     _mixed_cost_per_card_merge_ms_seq->add(cost_per_card_ms);
   }
 }
 
-void G1Analytics::report_card_merge_to_scan_ratio(double merge_to_scan_ratio, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_card_merge_to_scan_ratio(double merge_to_scan_ratio, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_card_merge_to_scan_ratio_seq->add(merge_to_scan_ratio);
   } else {
     _mixed_card_merge_to_scan_ratio_seq->add(merge_to_scan_ratio);
   }
 }
 
-void G1Analytics::report_rs_length_diff(double rs_length_diff, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_rs_length_diff(double rs_length_diff, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_rs_length_diff_seq->add(rs_length_diff);
   } else {
     _mixed_rs_length_diff_seq->add(rs_length_diff);
@@ -224,16 +224,16 @@ void G1Analytics::report_constant_other_time_ms(double constant_other_time_ms) {
   _constant_other_time_ms_seq->add(constant_other_time_ms);
 }
 
-void G1Analytics::report_pending_cards(double pending_cards, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_pending_cards(double pending_cards, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_pending_cards_seq->add(pending_cards);
   } else {
     _mixed_pending_cards_seq->add(pending_cards);
   }
 }
 
-void G1Analytics::report_rs_length(double rs_length, bool for_young_gc) {
-  if (for_young_gc) {
+void G1Analytics::report_rs_length(double rs_length, bool for_young_only_phase) {
+  if  (for_young_only_phase) {
     _young_rs_length_seq->add(rs_length);
   } else {
     _mixed_rs_length_seq->add(rs_length);
@@ -256,24 +256,24 @@ double G1Analytics::predict_dirtied_cards_rate_ms() const {
   return predict_zero_bounded(_dirtied_cards_rate_ms_seq);
 }
 
-size_t G1Analytics::predict_scan_card_num(size_t rs_length, bool for_young_gc) const {
-  if (for_young_gc || !enough_samples_available(_mixed_card_merge_to_scan_ratio_seq)) {
+size_t G1Analytics::predict_scan_card_num(size_t rs_length, bool for_young_only_phase) const {
+  if  (for_young_only_phase || !enough_samples_available(_mixed_card_merge_to_scan_ratio_seq)) {
     return (size_t)(rs_length * predict_in_unit_interval(_young_card_merge_to_scan_ratio_seq));
   } else {
     return (size_t)(rs_length * predict_in_unit_interval(_mixed_card_merge_to_scan_ratio_seq));
   }
 }
 
-double G1Analytics::predict_card_merge_time_ms(size_t card_num, bool for_young_gc) const {
-  if (for_young_gc || !enough_samples_available(_mixed_cost_per_card_merge_ms_seq)) {
+double G1Analytics::predict_card_merge_time_ms(size_t card_num, bool for_young_only_phase) const {
+  if  (for_young_only_phase || !enough_samples_available(_mixed_cost_per_card_merge_ms_seq)) {
     return card_num * predict_zero_bounded(_young_cost_per_card_merge_ms_seq);
   } else {
     return card_num * predict_zero_bounded(_mixed_cost_per_card_merge_ms_seq);
   }
 }
 
-double G1Analytics::predict_card_scan_time_ms(size_t card_num, bool for_young_gc) const {
-  if (for_young_gc || !enough_samples_available(_mixed_cost_per_card_scan_ms_seq)) {
+double G1Analytics::predict_card_scan_time_ms(size_t card_num, bool for_young_only_phase) const {
+  if  (for_young_only_phase || !enough_samples_available(_mixed_cost_per_card_scan_ms_seq)) {
     return card_num * predict_zero_bounded(_young_cost_per_card_scan_ms_seq);
   } else {
     return card_num * predict_zero_bounded(_mixed_cost_per_card_scan_ms_seq);
@@ -316,16 +316,16 @@ double G1Analytics::predict_cleanup_time_ms() const {
   return predict_zero_bounded(_concurrent_mark_cleanup_times_ms);
 }
 
-size_t G1Analytics::predict_rs_length(bool for_young_gc) const {
-  if (for_young_gc || !enough_samples_available(_mixed_rs_length_seq)) {
+size_t G1Analytics::predict_rs_length(bool for_young_only_phase) const {
+  if  (for_young_only_phase || !enough_samples_available(_mixed_rs_length_seq)) {
     return predict_size(_young_rs_length_seq) + predict_size(_young_rs_length_diff_seq);
   } else {
     return predict_size(_mixed_rs_length_seq) + predict_size(_mixed_rs_length_diff_seq);
   }
 }
 
-size_t G1Analytics::predict_pending_cards(bool for_young_gc) const {
-  if (for_young_gc || !enough_samples_available(_mixed_pending_cards_seq)) {
+size_t G1Analytics::predict_pending_cards(bool for_young_only_phase) const {
+  if  (for_young_only_phase || !enough_samples_available(_mixed_pending_cards_seq)) {
     return predict_size(_young_pending_cards_seq);
   } else {
     return predict_size(_mixed_pending_cards_seq);

src/hotspot/share/gc/g1/g1Analytics.hpp

@@ -126,16 +126,16 @@ class G1Analytics: public CHeapObj<mtGC> {
   void report_alloc_rate_ms(double alloc_rate);
   void report_concurrent_refine_rate_ms(double cards_per_ms);
   void report_dirtied_cards_rate_ms(double cards_per_ms);
-  void report_cost_per_card_scan_ms(double cost_per_remset_card_ms, bool for_young_gc);
-  void report_cost_per_card_merge_ms(double cost_per_card_ms, bool for_young_gc);
-  void report_card_merge_to_scan_ratio(double cards_per_entry_ratio, bool for_young_gc);
-  void report_rs_length_diff(double rs_length_diff, bool for_young_gc);
+  void report_cost_per_card_scan_ms(double cost_per_remset_card_ms, bool for_young_only_phase);
+  void report_cost_per_card_merge_ms(double cost_per_card_ms, bool for_young_only_phase);
+  void report_card_merge_to_scan_ratio(double cards_per_entry_ratio, bool for_young_only_phase);
+  void report_rs_length_diff(double rs_length_diff, bool for_young_only_phase);
   void report_cost_per_byte_ms(double cost_per_byte_ms, bool mark_or_rebuild_in_progress);
   void report_young_other_cost_per_region_ms(double other_cost_per_region_ms);
   void report_non_young_other_cost_per_region_ms(double other_cost_per_region_ms);
   void report_constant_other_time_ms(double constant_other_time_ms);
-  void report_pending_cards(double pending_cards, bool for_young_gc);
-  void report_rs_length(double rs_length, bool for_young_gc);
+  void report_pending_cards(double pending_cards, bool for_young_only_phase);
+  void report_rs_length(double rs_length, bool for_young_only_phase);
 
   double predict_alloc_rate_ms() const;
   int num_alloc_rate_ms() const;
@@ -145,10 +145,10 @@ class G1Analytics: public CHeapObj<mtGC> {
 
   // Predict how many of the given remembered set of length rs_length will add to
   // the number of total cards scanned.
-  size_t predict_scan_card_num(size_t rs_length, bool for_young_gc) const;
+  size_t predict_scan_card_num(size_t rs_length, bool for_young_only_phase) const;
 
-  double predict_card_merge_time_ms(size_t card_num, bool for_young_gc) const;
-  double predict_card_scan_time_ms(size_t card_num, bool for_young_gc) const;
+  double predict_card_merge_time_ms(size_t card_num, bool for_young_only_phase) const;
+  double predict_card_scan_time_ms(size_t card_num, bool for_young_only_phase) const;
 
   double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) const;
 
@@ -164,8 +164,8 @@ class G1Analytics: public CHeapObj<mtGC> {
 
   double predict_cleanup_time_ms() const;
 
-  size_t predict_rs_length(bool for_young_gc) const;
-  size_t predict_pending_cards(bool for_young_gc) const;
+  size_t predict_rs_length(bool for_young_only_phase) const;
+  size_t predict_pending_cards(bool for_young_only_phase) const;
 
   // Add a new GC of the given duration and end time to the record.
   void update_recent_gc_times(double end_time_sec, double elapsed_ms);

src/hotspot/share/gc/g1/g1Policy.cpp

@@ -194,9 +194,9 @@ uint G1Policy::calculate_desired_eden_length_by_mmu() const {
 }
 
 void G1Policy::update_young_length_bounds() {
-  bool for_young_gc = collector_state()->in_young_only_phase();
-  update_young_length_bounds(_analytics->predict_pending_cards(for_young_gc),
-                             _analytics->predict_rs_length(for_young_gc));
+  bool for_young_only_phase = collector_state()->in_young_only_phase();
+  update_young_length_bounds(_analytics->predict_pending_cards(for_young_only_phase),
+                             _analytics->predict_rs_length(for_young_only_phase));
 }
 
 void G1Policy::update_young_length_bounds(size_t pending_cards, size_t rs_length) {
@@ -487,7 +487,7 @@ uint G1Policy::calculate_desired_eden_length_before_mixed(double base_time_ms,
   double predicted_region_evac_time_ms = base_time_ms;
   for (uint i = candidates->cur_idx(); i < min_old_regions_end; i++) {
     HeapRegion* r = candidates->at(i);
-    predicted_region_evac_time_ms += predict_region_total_time_ms(r, false /* for_young_gc */);
+    predicted_region_evac_time_ms += predict_region_total_time_ms(r, false /* for_young_only_phase */);
   }
   uint desired_eden_length_by_min_cset_length =
      calculate_desired_eden_length_before_young_only(predicted_region_evac_time_ms,
@@ -533,8 +533,8 @@ void G1Policy::revise_young_list_target_length_if_necessary(size_t rs_length) {
 }
 
 void G1Policy::update_rs_length_prediction() {
-  bool for_young_gc = collector_state()->in_young_only_phase();
-  update_rs_length_prediction(_analytics->predict_rs_length(for_young_gc));
+  bool for_young_only_phase = collector_state()->in_young_only_phase();
+  update_rs_length_prediction(_analytics->predict_rs_length(for_young_only_phase));
 }
 
 void G1Policy::update_rs_length_prediction(size_t prediction) {
@@ -1033,8 +1033,8 @@ double G1Policy::predict_base_time_ms(size_t pending_cards,
 }
 
 double G1Policy::predict_base_time_ms(size_t pending_cards) const {
-  bool for_young_gc = collector_state()->in_young_only_phase();
-  size_t rs_length = _analytics->predict_rs_length(for_young_gc);
+  bool for_young_only_phase = collector_state()->in_young_only_phase();
+  size_t rs_length = _analytics->predict_rs_length(for_young_only_phase);
   return predict_base_time_ms(pending_cards, rs_length);
 }
 
@@ -1065,9 +1065,9 @@ double G1Policy::predict_region_copy_time_ms(HeapRegion* hr) const {
 }
 
 double G1Policy::predict_region_non_copy_time_ms(HeapRegion* hr,
-                                                 bool for_young_gc) const {
+                                                 bool for_young_only_phase) const {
   size_t rs_length = hr->rem_set()->occupied();
-  size_t scan_card_num = _analytics->predict_scan_card_num(rs_length, for_young_gc);
+  size_t scan_card_num = _analytics->predict_scan_card_num(rs_length, for_young_only_phase);
 
   double region_elapsed_time_ms =
     _analytics->predict_card_merge_time_ms(rs_length, collector_state()->in_young_only_phase()) +
@@ -1083,8 +1083,8 @@ double G1Policy::predict_region_non_copy_time_ms(HeapRegion* hr,
   return region_elapsed_time_ms;
 }
 
-double G1Policy::predict_region_total_time_ms(HeapRegion* hr, bool for_young_gc) const {
-  return predict_region_non_copy_time_ms(hr, for_young_gc) + predict_region_copy_time_ms(hr);
+double G1Policy::predict_region_total_time_ms(HeapRegion* hr, bool for_young_only_phase) const {
+  return predict_region_non_copy_time_ms(hr, for_young_only_phase) + predict_region_copy_time_ms(hr);
 }
 
 bool G1Policy::should_allocate_mutator_region() const {

src/hotspot/share/gc/g1/g1Policy.hpp

@@ -147,8 +147,8 @@ class G1Policy: public CHeapObj<mtGC> {
 public:
 
   double predict_eden_copy_time_ms(uint count, size_t* bytes_to_copy = NULL) const;
-  double predict_region_non_copy_time_ms(HeapRegion* hr, bool for_young_gc) const;
-  double predict_region_total_time_ms(HeapRegion* hr, bool for_young_gc) const;
+  double predict_region_non_copy_time_ms(HeapRegion* hr, bool for_young_only_phase) const;
+  double predict_region_total_time_ms(HeapRegion* hr, bool for_young_only_phase) const;
 
   void cset_regions_freed() {
     bool update = should_update_surv_rate_group_predictors();

src/hotspot/share/gc/g1/g1YoungGCEvacFailureInjector.cpp

@@ -57,7 +57,7 @@ void G1YoungGCEvacFailureInjector::select_evac_failure_regions() {
   g1h->collection_set_iterate_all(&closure);
 }
 
-bool G1YoungGCEvacFailureInjector::arm_if_needed_for_gc_type(bool for_young_gc,
+bool G1YoungGCEvacFailureInjector::arm_if_needed_for_gc_type(bool for_young_only_phase,
                                                              bool during_concurrent_start,
                                                              bool mark_or_rebuild_in_progress) {
   bool res = false;
@@ -67,7 +67,7 @@ bool G1YoungGCEvacFailureInjector::arm_if_needed_for_gc_type(bool for_young_gc,
   if (during_concurrent_start) {
     res |= G1EvacuationFailureALotDuringConcurrentStart;
   }
-  if (for_young_gc) {
+  if (for_young_only_phase) {
     res |= G1EvacuationFailureALotDuringYoungGC;
   } else {
     // GCs are mixed

src/hotspot/share/gc/g1/g1YoungGCEvacFailureInjector.hpp

@@ -61,7 +61,7 @@ class G1YoungGCEvacFailureInjector {
   CHeapBitMap _evac_failure_regions;
 #endif
 
-  bool arm_if_needed_for_gc_type(bool for_young_gc,
+  bool arm_if_needed_for_gc_type(bool for_young_only_phase,
                                  bool during_concurrent_start,
                                  bool mark_or_rebuild_in_progress) EVAC_FAILURE_INJECTOR_RETURN_( return false; );
 

src/hotspot/share/gc/g1/heapRegion.cpp

@@ -147,7 +147,7 @@ void HeapRegion::calc_gc_efficiency() {
   // Retrieve a prediction of the elapsed time for this region for
   // a mixed gc because the region will only be evacuated during a
   // mixed gc.
-  double region_elapsed_time_ms = policy->predict_region_total_time_ms(this, false /* for_young_gc */);
+  double region_elapsed_time_ms = policy->predict_region_total_time_ms(this, false /* for_young_only_phase */);
   _gc_efficiency = (double) reclaimable_bytes() / region_elapsed_time_ms;
 }