8342382: Implement JEP 522: G1 GC: Improve Throughput by Reducing Synchronization

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

@@ -75,7 +75,7 @@ jint G1ConcurrentRefineThreadControl::initialize(G1ConcurrentRefine* cr) {
   assert(cr != nullptr, "G1ConcurrentRefine must not be null");
   _cr = cr;
 
-  if (max_num_threads() > 0) {
+  if (is_refinement_enabled()) {
     _control_thread = create_refinement_thread();
     if (_control_thread == nullptr) {
       vm_shutdown_during_initialization("Could not allocate refinement control thread");
@@ -105,19 +105,19 @@ void G1ConcurrentRefineThreadControl::run_task(WorkerTask* task, uint num_worker
 }
 
 void G1ConcurrentRefineThreadControl::control_thread_do(ThreadClosure* tc) {
-  if (_control_thread != nullptr) {
+  if (is_refinement_enabled()) {
     tc->do_thread(_control_thread);
   }
 }
 
 void G1ConcurrentRefineThreadControl::worker_threads_do(ThreadClosure* tc) {
-  if (_control_thread != nullptr) {
+  if (is_refinement_enabled()) {
     _workers->threads_do(tc);
   }
 }
 
 void G1ConcurrentRefineThreadControl::stop() {
-  if (_control_thread != nullptr) {
+  if (is_refinement_enabled()) {
     _control_thread->stop();
   }
 }
@@ -338,8 +338,11 @@ bool G1ConcurrentRefineSweepState::complete_work(bool concurrent, bool print_log
 }
 
 void G1ConcurrentRefineSweepState::snapshot_heap_into(G1CardTableClaimTable* sweep_table) {
-  // G1CollectedHeap::heap_region_iterate() below will only visit committed regions. Initialize
-  // all entries in the state table here to not require special handling when iterating over it.
+  // G1CollectedHeap::heap_region_iterate() below will only visit currently committed
+  // regions. Initialize all entries in the state table here and later in this method
+  // selectively enable regions that we are interested. This way regions committed
+  // later will be automatically excluded from iteration.
+  // Their refinement table must be completely empty anyway.
   sweep_table->reset_all_to_claimed();
 
   class SnapshotRegionsClosure : public G1HeapRegionClosure {
@@ -351,7 +354,7 @@ void G1ConcurrentRefineSweepState::snapshot_heap_into(G1CardTableClaimTable* swe
     bool do_heap_region(G1HeapRegion* r) override {
       if (!r->is_free()) {
         // Need to scan all parts of non-free regions, so reset the claim.
-        // No need for synchronization: we are only interested about regions
+        // No need for synchronization: we are only interested in regions
         // that were allocated before the handshake; the handshake makes such
         // regions' metadata visible to all threads, and we do not care about
         // humongous regions that were allocated afterwards.
@@ -395,7 +398,7 @@ jint G1ConcurrentRefine::initialize() {
 }
 
 G1ConcurrentRefineSweepState& G1ConcurrentRefine::sweep_state_for_merge() {
-  bool has_sweep_claims = sweep_state().complete_work(false);
+  bool has_sweep_claims = sweep_state().complete_work(false /* concurrent */);
   if (has_sweep_claims) {
     log_debug(gc, refine)("Continue existing work");
   } else {
@@ -485,7 +488,7 @@ void G1ConcurrentRefine::adjust_after_gc(double logged_cards_time_ms,
   update_pending_cards_target(logged_cards_time_ms,
                               processed_logged_cards,
                               goal_ms);
-  if (_thread_control.max_num_threads() != 0) {
+  if (_thread_control.is_refinement_enabled()) {
     _needs_adjust = true;
     if (is_pending_cards_target_initialized()) {
       _thread_control.activate();

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

@@ -68,6 +68,7 @@ class G1ConcurrentRefineThreadControl {
   void assert_current_thread_is_control_refinement_thread() const NOT_DEBUG_RETURN;
 
   uint max_num_threads() const { return _max_num_threads; }
+  bool is_refinement_enabled() const { return _max_num_threads > 0; }
 
   // Activate the control thread.
   void activate();

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

@@ -61,7 +61,7 @@ class G1RefineRegionClosure : public G1HeapRegionClosure {
     } else if (res == G1RemSet::AlreadyToCSet) {
       *dest_card = G1CardTable::g1_to_cset_card;
       _refine_stats.inc_cards_already_refer_to_cset();
-    } else if (res == G1RemSet::HasToCSetRef) {
+    } else if (res == G1RemSet::HasRefToCSet) {
       *dest_card = G1CardTable::g1_to_cset_card;
       _refine_stats.inc_cards_refer_to_cset();
     } else if (res == G1RemSet::NoInteresting) {

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

@@ -202,19 +202,19 @@ class G1RootRegionScanClosure : public ClaimMetadataVisitingOopIterateClosure {
 class G1ConcurrentRefineOopClosure: public BasicOopIterateClosure {
   G1CollectedHeap* _g1h;
   uint _worker_id;
-  bool _has_to_cset_ref;
-  bool _has_to_old_ref;
+  bool _has_ref_to_cset;
+  bool _has_ref_to_old;
 
 public:
   G1ConcurrentRefineOopClosure(G1CollectedHeap* g1h, uint worker_id) :
     _g1h(g1h),
     _worker_id(worker_id),
-    _has_to_cset_ref(false),
-    _has_to_old_ref(false) {
+    _has_ref_to_cset(false),
+    _has_ref_to_old(false) {
   }
 
-  bool has_to_cset_ref() const { return _has_to_cset_ref; }
-  bool has_to_old_ref() const { return _has_to_old_ref; }
+  bool has_ref_to_cset() const { return _has_ref_to_cset; }
+  bool has_ref_to_old() const { return _has_ref_to_old; }
 
   virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
 

src/hotspot/share/gc/g1/g1OopClosures.inline.hpp

@@ -128,7 +128,7 @@ inline static void check_obj_during_refinement(T* p, oop const obj) {
 template <class T>
 inline void G1ConcurrentRefineOopClosure::do_oop_work(T* p) {
   // Early out if we already found a to-young reference.
-  if (_has_to_cset_ref) {
+  if (_has_ref_to_cset) {
     return;
   }
 
@@ -152,8 +152,8 @@ inline void G1ConcurrentRefineOopClosure::do_oop_work(T* p) {
   }
 
   G1HeapRegion* to_region = _g1h->heap_region_containing(obj);
-  _has_to_cset_ref = to_region->is_young();
-  if (_has_to_cset_ref) {
+  _has_ref_to_cset = to_region->is_young();
+  if (_has_ref_to_cset) {
     return;
   }
   G1HeapRegionRemSet* to_rem_set = to_region->rem_set();
@@ -164,7 +164,7 @@ inline void G1ConcurrentRefineOopClosure::do_oop_work(T* p) {
 
     if (from->rem_set()->cset_group() != to_rem_set->cset_group()) {
       to_rem_set->add_reference(p, _worker_id);
-      _has_to_old_ref = true;
+      _has_ref_to_old = true;
     }
   }
 }

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

@@ -102,7 +102,17 @@ class G1Policy: public CHeapObj<mtGC> {
 
   uint _free_regions_at_end_of_collection;
 
+  // Tracks the number of cards marked as dirty (only) during garbage collection
+  // (evacuation) on the card table.
+  // This is needed to properly account for those cards in the heuristics to start
+  // refinement at the correct time which needs to know how many cards are currently
+  // approximately on the card table.
+  // After the first completed refinement sweep of the refinement table between two
+  // garbage collections this value is reset to zero as that refinement processed all
+  // those cards.
   size_t _pending_cards_from_gc;
+  // Tracks the approximate number of cards found as to-collection-set by either the
+  // garbage collection or the most recent refinement sweep.
   size_t _to_collection_set_cards;
 
   G1ConcurrentStartToMixedTimeTracker _concurrent_start_to_mixed;

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

@@ -1358,10 +1358,10 @@ G1RemSet::RefineResult G1RemSet::refine_card_concurrently(CardValue* const card_
 
   G1ConcurrentRefineOopClosure conc_refine_cl(_g1h, worker_id);
   if (r->oops_on_memregion_seq_iterate_careful<false>(dirty_region, &conc_refine_cl) != nullptr) {
-    if (conc_refine_cl.has_to_cset_ref()) {
-      return HasToCSetRef;
-    } else if (conc_refine_cl.has_to_old_ref()) {
-      return HasToOldRef;
+    if (conc_refine_cl.has_ref_to_cset()) {
+      return HasRefToCSet;
+    } else if (conc_refine_cl.has_ref_to_old()) {
+      return HasRefToOld;
     } else {
       return NoInteresting;
     }

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

@@ -120,9 +120,9 @@ class G1RemSet: public CHeapObj<mtGC> {
                                           G1GCPhaseTimes::GCParPhases objcopy_phase);
 
   enum RefineResult {
-      HasToCSetRef,          // The (dirty) card has a reference to the collection set.
+      HasRefToCSet,          // The (dirty) card has a reference to the collection set.
       AlreadyToCSet,         // The card is already one marked as having a reference to the collection set.
-      HasToOldRef,           // The dirty cards contains references to other old regions (not the collection set).
+      HasRefToOld,           // The dirty card contains references to other old regions (not the collection set).
       NoInteresting,         // There is no interesting reference in the card.
       CouldNotParse          // The card is unparsable, need to retry later.
   };