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

rev 49511 : imported patch 8200234-g1concurrentmark-refactorings
rev 49522 : [mq]: 8035557-pause-time-predictions
rev 49523 : imported patch 8035557-pause-time-predictions-cleanup
rev 49525 : [mq]: 8200426-sangheon-review

@@ -60,11 +60,11 @@
   _reserve_regions(0),
   _rs_lengths_prediction(0),
   _bytes_allocated_in_old_since_last_gc(0),
   _initial_mark_to_mixed(),
   _collection_set(NULL),
-  _g1(NULL),
+  _g1h(NULL),
   _phase_times(new G1GCPhaseTimes(gc_timer, ParallelGCThreads)),
   _tenuring_threshold(MaxTenuringThreshold),
   _max_survivor_regions(0),
   _survivors_age_table(true),
   _collection_pause_end_millis(os::javaTimeNanos() / NANOSECS_PER_MILLISEC) {

@@ -72,24 +72,24 @@
 
 G1Policy::~G1Policy() {
   delete _ihop_control;
 }
 
-G1CollectorState* G1Policy::collector_state() const { return _g1->collector_state(); }
+G1CollectorState* G1Policy::collector_state() const { return _g1h->collector_state(); }
 
 void G1Policy::init(G1CollectedHeap* g1h, G1CollectionSet* collection_set) {
-  _g1 = g1h;
+  _g1h = g1h;
   _collection_set = collection_set;
 
   assert(Heap_lock->owned_by_self(), "Locking discipline.");
 
   if (!adaptive_young_list_length()) {
     _young_list_fixed_length = _young_gen_sizer.min_desired_young_length();
   }
-  _young_gen_sizer.adjust_max_new_size(_g1->max_regions());
+  _young_gen_sizer.adjust_max_new_size(_g1h->max_regions());
 
-  _free_regions_at_end_of_collection = _g1->num_free_regions();
+  _free_regions_at_end_of_collection = _g1h->num_free_regions();
 
   update_young_list_max_and_target_length();
   // We may immediately start allocating regions and placing them on the
   // collection set list. Initialize the per-collection set info
   _collection_set->start_incremental_building();

@@ -216,15 +216,15 @@
   YoungTargetLengths result;
 
   // Calculate the absolute and desired min bounds first.
 
   // This is how many young regions we already have (currently: the survivors).
-  const uint base_min_length = _g1->survivor_regions_count();
+  const uint base_min_length = _g1h->survivor_regions_count();
   uint desired_min_length = calculate_young_list_desired_min_length(base_min_length);
   // This is the absolute minimum young length. Ensure that we
   // will at least have one eden region available for allocation.
-  uint absolute_min_length = base_min_length + MAX2(_g1->eden_regions_count(), (uint)1);
+  uint absolute_min_length = base_min_length + MAX2(_g1h->eden_regions_count(), (uint)1);
   // If we shrank the young list target it should not shrink below the current size.
   desired_min_length = MAX2(desired_min_length, absolute_min_length);
   // Calculate the absolute and desired max bounds.
 
   uint desired_max_length = calculate_young_list_desired_max_length();

@@ -379,11 +379,11 @@
   return base_min_length + min_young_length;
 }
 
 double G1Policy::predict_survivor_regions_evac_time() const {
   double survivor_regions_evac_time = 0.0;
-  const GrowableArray<HeapRegion*>* survivor_regions = _g1->survivor()->regions();
+  const GrowableArray<HeapRegion*>* survivor_regions = _g1h->survivor()->regions();
 
   for (GrowableArrayIterator<HeapRegion*> it = survivor_regions->begin();
        it != survivor_regions->end();
        ++it) {
     survivor_regions_evac_time += predict_region_elapsed_time_ms(*it, collector_state()->in_young_only_phase());

@@ -442,11 +442,11 @@
   collector_state()->set_clearing_next_bitmap(false);
 
   _short_lived_surv_rate_group->start_adding_regions();
   // also call this on any additional surv rate groups
 
-  _free_regions_at_end_of_collection = _g1->num_free_regions();
+  _free_regions_at_end_of_collection = _g1h->num_free_regions();
   // Reset survivors SurvRateGroup.
   _survivor_surv_rate_group->reset();
   update_young_list_max_and_target_length();
   update_rs_lengths_prediction();
 

@@ -459,25 +459,25 @@
   // 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.
   update_survivors_policy();
 
-  assert(_g1->used() == _g1->recalculate_used(),
+  assert(_g1h->used() == _g1h->recalculate_used(),
          "sanity, used: " SIZE_FORMAT " recalculate_used: " SIZE_FORMAT,
-         _g1->used(), _g1->recalculate_used());
+         _g1h->used(), _g1h->recalculate_used());
 
   phase_times()->record_cur_collection_start_sec(start_time_sec);
-  _pending_cards = _g1->pending_card_num();
+  _pending_cards = _g1h->pending_card_num();
 
   _collection_set->reset_bytes_used_before();
   _bytes_copied_during_gc = 0;
 
   // do that for any other surv rate groups
   _short_lived_surv_rate_group->stop_adding_regions();
   _survivors_age_table.clear();
 
-  assert(_g1->collection_set()->verify_young_ages(), "region age verification failed");
+  assert(_g1h->collection_set()->verify_young_ages(), "region age verification failed");
 }
 
 void G1Policy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) {
   assert(!collector_state()->initiate_conc_mark_if_possible(), "we should have cleared it by now");
   collector_state()->set_in_initial_mark_gc(false);

@@ -525,30 +525,30 @@
 CollectionSetChooser* G1Policy::cset_chooser() const {
   return _collection_set->cset_chooser();
 }
 
 bool G1Policy::about_to_start_mixed_phase() const {
-  return _g1->concurrent_mark()->cm_thread()->during_cycle() || collector_state()->in_young_gc_before_mixed();
+  return _g1h->concurrent_mark()->cm_thread()->during_cycle() || collector_state()->in_young_gc_before_mixed();
 }
 
 bool G1Policy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) {
   if (about_to_start_mixed_phase()) {
     return false;
   }
 
   size_t marking_initiating_used_threshold = _ihop_control->get_conc_mark_start_threshold();
 
-  size_t cur_used_bytes = _g1->non_young_capacity_bytes();
+  size_t cur_used_bytes = _g1h->non_young_capacity_bytes();
   size_t alloc_byte_size = alloc_word_size * HeapWordSize;
   size_t marking_request_bytes = cur_used_bytes + alloc_byte_size;
 
   bool result = false;
   if (marking_request_bytes > marking_initiating_used_threshold) {
     result = collector_state()->in_young_only_phase() && !collector_state()->in_young_gc_before_mixed();
     log_debug(gc, ergo, ihop)("%s occupancy: " SIZE_FORMAT "B allocation request: " SIZE_FORMAT "B threshold: " SIZE_FORMAT "B (%1.2f) source: %s",
                               result ? "Request concurrent cycle initiation (occupancy higher than threshold)" : "Do not request concurrent cycle initiation (still doing mixed collections)",
-                              cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, (double) marking_initiating_used_threshold / _g1->capacity() * 100, source);
+                              cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, (double) marking_initiating_used_threshold / _g1h->capacity() * 100, source);
   }
 
   return result;
 }
 

@@ -556,16 +556,16 @@
 #define MIN_TIMER_GRANULARITY 0.0000001
 
 void G1Policy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) {
   double end_time_sec = os::elapsedTime();
 
-  size_t cur_used_bytes = _g1->used();
-  assert(cur_used_bytes == _g1->recalculate_used(), "It should!");
+  size_t cur_used_bytes = _g1h->used();
+  assert(cur_used_bytes == _g1h->recalculate_used(), "It should!");
   bool this_pause_included_initial_mark = false;
   bool this_pause_was_young_only = collector_state()->in_young_only_phase();
 
-  bool update_stats = !_g1->evacuation_failed();
+  bool update_stats = !_g1h->evacuation_failed();
 
   record_pause(young_gc_pause_kind(), end_time_sec - pause_time_ms / 1000.0, end_time_sec);
 
   _collection_pause_end_millis = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 

@@ -701,11 +701,11 @@
          "If the last pause has been an initial mark, we should not have been in the marking window");
   if (this_pause_included_initial_mark) {
     collector_state()->set_mark_or_rebuild_in_progress(true);
   }
 
-  _free_regions_at_end_of_collection = _g1->num_free_regions();
+  _free_regions_at_end_of_collection = _g1h->num_free_regions();
   // IHOP control wants to know the expected young gen length if it were not
   // restrained by the heap reserve. Using the actual length would make the
   // prediction too small and the limit the young gen every time we get to the
   // predicted target occupancy.
   size_t last_unrestrained_young_length = update_young_list_max_and_target_length();

@@ -715,11 +715,11 @@
                          _bytes_allocated_in_old_since_last_gc,
                          last_unrestrained_young_length * HeapRegion::GrainBytes,
                          this_pause_was_young_only);
   _bytes_allocated_in_old_since_last_gc = 0;
 
-  _ihop_control->send_trace_event(_g1->gc_tracer_stw());
+  _ihop_control->send_trace_event(_g1h->gc_tracer_stw());
 
   // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
   double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
 
   if (update_rs_time_goal_ms < scan_hcc_time_ms) {

@@ -729,11 +729,11 @@
 
     update_rs_time_goal_ms = 0;
   } else {
     update_rs_time_goal_ms -= scan_hcc_time_ms;
   }
-  _g1->concurrent_refine()->adjust(average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms,
+  _g1h->concurrent_refine()->adjust(average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms,
                                    phase_times()->sum_thread_work_items(G1GCPhaseTimes::UpdateRS),
                                    update_rs_time_goal_ms);
 
   cset_chooser()->verify();
 }

@@ -858,17 +858,17 @@
   }
   return region_elapsed_time_ms;
 }
 
 bool G1Policy::should_allocate_mutator_region() const {
-  uint young_list_length = _g1->young_regions_count();
+  uint young_list_length = _g1h->young_regions_count();
   uint young_list_target_length = _young_list_target_length;
   return young_list_length < young_list_target_length;
 }
 
 bool G1Policy::can_expand_young_list() const {
-  uint young_list_length = _g1->young_regions_count();
+  uint young_list_length = _g1h->young_regions_count();
   uint young_list_max_length = _young_list_max_length;
   return young_list_length < young_list_max_length;
 }
 
 bool G1Policy::adaptive_young_list_length() const {

@@ -916,11 +916,11 @@
 
 bool G1Policy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) {
   // We actually check whether we are marking here and not if we are in a
   // reclamation phase. This means that we will schedule a concurrent mark
   // even while we are still in the process of reclaiming memory.
-  bool during_cycle = _g1->concurrent_mark()->cm_thread()->during_cycle();
+  bool during_cycle = _g1h->concurrent_mark()->cm_thread()->during_cycle();
   if (!during_cycle) {
     log_debug(gc, ergo)("Request concurrent cycle initiation (requested by GC cause). GC cause: %s", GCCause::to_string(gc_cause));
     collector_state()->set_initiate_conc_mark_if_possible(true);
     return true;
   } else {

@@ -951,11 +951,11 @@
 
     if (!about_to_start_mixed_phase() && collector_state()->in_young_only_phase()) {
       // Initiate a new initial mark if there is no marking or reclamation going on.
       initiate_conc_mark();
       log_debug(gc, ergo)("Initiate concurrent cycle (concurrent cycle initiation requested)");
-    } else if (_g1->is_user_requested_concurrent_full_gc(_g1->gc_cause())) {
+    } else if (_g1h->is_user_requested_concurrent_full_gc(_g1h->gc_cause())) {
       // Initiate a user requested initial mark. An initial mark must be young only
       // GC, so the collector state must be updated to reflect this.
       collector_state()->set_in_young_only_phase(true);
       collector_state()->set_in_young_gc_before_mixed(false);
 

@@ -984,11 +984,11 @@
     }
   }
 }
 
 void G1Policy::record_concurrent_mark_cleanup_end() {
-  cset_chooser()->rebuild(_g1->workers(), _g1->num_regions());
+  cset_chooser()->rebuild(_g1h->workers(), _g1h->num_regions());
 
   bool mixed_gc_pending = next_gc_should_be_mixed("request mixed gcs", "request young-only gcs");
   if (!mixed_gc_pending) {
     clear_collection_set_candidates();
     abort_time_to_mixed_tracking();

@@ -1003,11 +1003,11 @@
 
   record_pause(Cleanup, _mark_cleanup_start_sec, end_sec);
 }
 
 double G1Policy::reclaimable_bytes_percent(size_t reclaimable_bytes) const {
-  return percent_of(reclaimable_bytes, _g1->capacity());
+  return percent_of(reclaimable_bytes, _g1h->capacity());
 }
 
 class G1ClearCollectionSetCandidateRemSets : public HeapRegionClosure {
   virtual bool do_heap_region(HeapRegion* r) {
     r->rem_set()->clear_locked(true /* only_cardset */);