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

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

@@ -37,7 +37,7 @@
 // They were chosen by running GCOld and SPECjbb on debris with different
 //   numbers of GC threads and choosing them based on the results
 
-static double cost_per_logged_card_ms_defaults[] = {
+static double cost_per_pending_card_ms_defaults[] = {
   0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015
 };
 
@@ -101,8 +101,8 @@ G1Analytics::G1Analytics(const G1Predictions* predictor) :
   uint index = MIN2(ParallelGCThreads - 1, 7u);
 
   // Start with inverse of maximum STW cost.
-  _concurrent_refine_rate_ms_seq.add(1/cost_per_logged_card_ms_defaults[0]);
-  // Some applications have very low rates for logging cards.
+  _concurrent_refine_rate_ms_seq.add(1/cost_per_pending_card_ms_defaults[0]);
+  // Some applications have very low rates for dirtying cards.
   _dirtied_cards_rate_ms_seq.add(0.0);
 
   _card_merge_to_scan_ratio_seq.set_initial(young_card_merge_to_scan_ratio_defaults[index]);

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

@@ -247,9 +247,8 @@ void G1Arguments::initialize() {
 
   // Verify that the maximum parallelism isn't too high to eventually overflow
   // the refcount in G1CardSetContainer.
-  uint max_parallel_refinement_threads = G1ConcRefinementThreads;
   uint const divisor = 3;  // Safe divisor; we increment by 2 for each claim, but there is a small initial value.
-  if (max_parallel_refinement_threads > UINT_MAX / divisor) {
+  if (G1ConcRefinementThreads > UINT_MAX / divisor) {
     vm_exit_during_initialization("Too large parallelism for remembered sets.");
   }
 

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

@@ -92,7 +92,7 @@ G1CardTable::CardValue* G1ChunkScanner::find_first_dirty_card(CardValue* i_card)
         }
         i_card++;
       }
-      assert(false, "should have early-returned");
+      ShouldNotReachHere();
     }
   }
 
@@ -118,7 +118,7 @@ G1CardTable::CardValue* G1ChunkScanner::find_first_non_dirty_card(CardValue* i_c
         }
         i_card++;
       }
-      assert(false, "should have early-returned");
+      ShouldNotReachHere();
     }
   }
 

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

@@ -213,7 +213,7 @@ bool G1ConcurrentRefineSweepState::swap_java_threads_ct() {
 
     class G1SwapThreadCardTableClosure : public HandshakeClosure {
     public:
-      G1SwapThreadCardTableClosure() : HandshakeClosure("G1 Swap JT card table") { }
+      G1SwapThreadCardTableClosure() : HandshakeClosure("G1 Java Thread CT swap") { }
 
       virtual void do_thread(Thread* thread) {
         G1BarrierSet* bs = G1BarrierSet::g1_barrier_set();
@@ -277,14 +277,14 @@ void G1ConcurrentRefineSweepState::snapshot_heap(bool concurrent) {
 
     set_state_start_time();
 
-    snapshot_heap_into(_sweep_table);
+    snapshot_heap_inner();
 
     advance_state(State::SweepRT);
   } else {
     assert_state(State::Idle);
     assert_at_safepoint();
 
-    snapshot_heap_into(_sweep_table);
+    snapshot_heap_inner();
   }
 }
 
@@ -352,13 +352,13 @@ bool G1ConcurrentRefineSweepState::complete_work(bool concurrent, bool print_log
   return has_sweep_rt_work;
 }
 
-void G1ConcurrentRefineSweepState::snapshot_heap_into(G1CardTableClaimTable* sweep_table) {
+void G1ConcurrentRefineSweepState::snapshot_heap_inner() {
   // 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();
+  _sweep_table->reset_all_to_claimed();
 
   class SnapshotRegionsClosure : public G1HeapRegionClosure {
     G1CardTableClaimTable* _sweep_table;
@@ -377,7 +377,7 @@ void G1ConcurrentRefineSweepState::snapshot_heap_into(G1CardTableClaimTable* swe
       }
       return false;
     }
-  } cl(sweep_table);
+  } cl(_sweep_table);
   G1CollectedHeap::heap()->heap_region_iterate(&cl);
 }
 
@@ -477,18 +477,18 @@ void G1ConcurrentRefine::control_thread_do(ThreadClosure *tc) {
   _thread_control.control_thread_do(tc);
 }
 
-void G1ConcurrentRefine::update_pending_cards_target(double logged_cards_time_ms,
-                                                     size_t processed_logged_cards,
+void G1ConcurrentRefine::update_pending_cards_target(double pending_cards_time_ms,
+                                                     size_t processed_pending_cards,
                                                      double goal_ms) {
   size_t minimum = minimum_pending_cards_target();
-  if ((processed_logged_cards < minimum) || (logged_cards_time_ms == 0.0)) {
+  if ((processed_pending_cards < minimum) || (pending_cards_time_ms == 0.0)) {
     log_debug(gc, ergo, refine)("Unchanged pending cards target: %zu (processed %zu minimum %zu time %1.2f)",
-                                _pending_cards_target, processed_logged_cards, minimum, logged_cards_time_ms);
+                                _pending_cards_target, processed_pending_cards, minimum, pending_cards_time_ms);
     return;
   }
 
   // Base the pending cards budget on the measured rate.
-  double rate = processed_logged_cards / logged_cards_time_ms;
+  double rate = processed_pending_cards / pending_cards_time_ms;
   size_t new_target = static_cast<size_t>(goal_ms * rate);
   // Add some hysteresis with previous values.
   if (is_pending_cards_target_initialized()) {
@@ -500,15 +500,15 @@ void G1ConcurrentRefine::update_pending_cards_target(double logged_cards_time_ms
   log_debug(gc, ergo, refine)("New pending cards target: %zu", new_target);
 }
 
-void G1ConcurrentRefine::adjust_after_gc(double logged_cards_time_ms,
-                                         size_t processed_logged_cards,
+void G1ConcurrentRefine::adjust_after_gc(double pending_cards_time_ms,
+                                         size_t processed_pending_cards,
                                          double goal_ms) {
   if (!G1UseConcRefinement) {
     return;
   }
 
-  update_pending_cards_target(logged_cards_time_ms,
-                              processed_logged_cards,
+  update_pending_cards_target(pending_cards_time_ms,
+                              processed_pending_cards,
                               goal_ms);
   if (_thread_control.is_refinement_enabled()) {
     _needs_adjust = true;
@@ -564,7 +564,7 @@ bool G1ConcurrentRefine::adjust_num_threads_periodically() {
     _needs_adjust = true;
   }
 
-  return (_num_threads_wanted > 0) && !wait_for_heap_lock();
+  return (_num_threads_wanted > 0) && !heap_was_locked();
 }
 
 void G1ConcurrentRefine::adjust_threads_wanted(size_t available_bytes) {

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

@@ -151,7 +151,7 @@ class G1ConcurrentRefineSweepState {
 
   void assert_state(State expected);
 
-  static void snapshot_heap_into(G1CardTableClaimTable* sweep_table);
+  void snapshot_heap_inner();
 
 public:
   G1ConcurrentRefineSweepState(uint max_reserved_regions);
@@ -235,8 +235,8 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
     return _pending_cards_target != PendingCardsTargetUninitialized;
   }
 
-  void update_pending_cards_target(double logged_cards_scan_time_ms,
-                                   size_t processed_logged_cards,
+  void update_pending_cards_target(double pending_cards_scan_time_ms,
+                                   size_t processed_pending_cards,
                                    double goal_ms);
 
   uint64_t adjust_threads_period_ms() const;
@@ -268,8 +268,8 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
   // cards.  Updates the mutator refinement threshold.  Ensures the refinement
   // control thread (if it exists) is active, so it will adjust the number
   // of running threads.
-  void adjust_after_gc(double logged_cards_scan_time_ms,
-                       size_t processed_logged_cards,
+  void adjust_after_gc(double pending_cards_scan_time_ms,
+                       size_t processed_pending_cards,
                        double goal_ms);
 
   // Target number of pending dirty cards at the start of the next GC.
@@ -298,7 +298,7 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
 
   // Indicate that last refinement adjustment had been deferred due to not
   // obtaining the heap lock.
-  bool wait_for_heap_lock() const { return _heap_was_locked; }
+  bool heap_was_locked() const { return _heap_was_locked; }
 
   uint num_threads_wanted() const { return _num_threads_wanted; }
   uint max_num_threads() const { return _thread_control.max_num_threads(); }

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

@@ -76,7 +76,7 @@ void G1ConcurrentRefineThread::run_service() {
         log_debug(gc, refine)("Concurrent Refine Adjust Only (#threads wanted: %u adjustment_needed: %s wait_for_heap_lock: %s) %.2fms",
                               cr()->num_threads_wanted(),
                               BOOL_TO_STR(cr()->is_thread_adjustment_needed()),
-                              BOOL_TO_STR(cr()->wait_for_heap_lock()),
+                              BOOL_TO_STR(cr()->heap_was_locked()),
                               (Ticks::now() - adjust_start).seconds() * MILLIUNITS);
 
         deactivate();

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

@@ -97,7 +97,7 @@ G1GCPhaseTimes::G1GCPhaseTimes(STWGCTimer* gc_timer, uint max_gc_threads) :
   _gc_par_phases[MergePSS] = new WorkerDataArray<double>("MergePSS", "Merge Per-Thread State (ms):", max_gc_threads);
   _gc_par_phases[RestoreEvacuationFailedRegions] = new WorkerDataArray<double>("RestoreEvacuationFailedRegions", "Restore Evacuation Failed Regions (ms):", max_gc_threads);
   _gc_par_phases[RemoveSelfForwards] = new WorkerDataArray<double>("RemoveSelfForwards", "Remove Self Forwards (ms):", max_gc_threads);
-  _gc_par_phases[ClearCardTable] = new WorkerDataArray<double>("ClearLoggedCards", "Clear Logged Cards (ms):", max_gc_threads);
+  _gc_par_phases[ClearCardTable] = new WorkerDataArray<double>("ClearPendingCards", "Clear Pending Cards (ms):", max_gc_threads);
   _gc_par_phases[RecalculateUsed] = new WorkerDataArray<double>("RecalculateUsed", "Recalculate Used Memory (ms):", max_gc_threads);
 #if COMPILER2_OR_JVMCI
   _gc_par_phases[UpdateDerivedPointers] = new WorkerDataArray<double>("UpdateDerivedPointers", "Update Derived Pointers (ms):", max_gc_threads);

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

@@ -768,27 +768,27 @@ bool G1Policy::concurrent_operation_is_full_mark(const char* msg) {
     ((_g1h->gc_cause() != GCCause::_g1_humongous_allocation) || need_to_start_conc_mark(msg));
 }
 
-double G1Policy::logged_cards_processing_time() const {
+double G1Policy::pending_cards_processing_time() const {
   double all_cards_processing_time = average_time_ms(G1GCPhaseTimes::ScanHR) + average_time_ms(G1GCPhaseTimes::OptScanHR);
-  size_t logged_dirty_cards = phase_times()->sum_thread_work_items(G1GCPhaseTimes::ScanHR, G1GCPhaseTimes::ScanHRPendingCards) +
-                              phase_times()->sum_thread_work_items(G1GCPhaseTimes::OptScanHR, G1GCPhaseTimes::ScanHRPendingCards);
+  size_t pending_cards = phase_times()->sum_thread_work_items(G1GCPhaseTimes::ScanHR, G1GCPhaseTimes::ScanHRPendingCards) +
+                         phase_times()->sum_thread_work_items(G1GCPhaseTimes::OptScanHR, G1GCPhaseTimes::ScanHRPendingCards);
   size_t scan_heap_roots_cards = phase_times()->sum_thread_work_items(G1GCPhaseTimes::ScanHR, G1GCPhaseTimes::ScanHRScannedCards) +
                                  phase_times()->sum_thread_work_items(G1GCPhaseTimes::OptScanHR, G1GCPhaseTimes::ScanHRScannedCards);
 
-  double merge_logged_cards_time = phase_times()->cur_merge_refinement_table_time();
+  double merge_pending_cards_time = phase_times()->cur_merge_refinement_table_time();
 
-  // Approximate the time spent processing cards from log buffers by scaling
-  // the total processing time by the ratio of logged cards to total cards
+  // Approximate the time spent processing cards from pending cards by scaling
+  // the total processing time by the ratio of pending cards to total cards
   // processed.  There might be duplicate cards in different log buffers,
   // leading to an overestimate.  That effect should be relatively small
   // unless there are few cards to process, because cards in buffers are
   // dirtied to limit duplication.  Also need to avoid scaling when both
   // counts are zero, which happens especially during early GCs.  So ascribe
-  // all of the time to the logged cards unless there are more total cards.
-  if (logged_dirty_cards >= scan_heap_roots_cards) {
-    return all_cards_processing_time + merge_logged_cards_time;
+  // all of the time to the pending cards unless there are more total cards.
+  if (pending_cards >= scan_heap_roots_cards) {
+    return all_cards_processing_time + merge_pending_cards_time;
   }
-  return (all_cards_processing_time * logged_dirty_cards / scan_heap_roots_cards) + merge_logged_cards_time;
+  return (all_cards_processing_time * pending_cards / scan_heap_roots_cards) + merge_pending_cards_time;
 }
 
 // Anything below that is considered to be zero
@@ -1002,26 +1002,26 @@ void G1Policy::record_young_collection_end(bool concurrent_operation_is_full_mar
   }
 
   // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
-  double logged_cards_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
+  double pending_cards_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
 
-  double const logged_cards_time_ms = logged_cards_processing_time();
-  size_t logged_cards = phase_times()->sum_thread_work_items(G1GCPhaseTimes::ScanHR, G1GCPhaseTimes::ScanHRPendingCards) +
-                        phase_times()->sum_thread_work_items(G1GCPhaseTimes::OptScanHR, G1GCPhaseTimes::ScanHRPendingCards);
+  double const pending_cards_time_ms = pending_cards_processing_time();
+  size_t pending_cards = phase_times()->sum_thread_work_items(G1GCPhaseTimes::ScanHR, G1GCPhaseTimes::ScanHRPendingCards) +
+                         phase_times()->sum_thread_work_items(G1GCPhaseTimes::OptScanHR, G1GCPhaseTimes::ScanHRPendingCards);
 
-  bool exceeded_goal = logged_cards_time_goal_ms < logged_cards_time_ms;
+  bool exceeded_goal = pending_cards_time_goal_ms < pending_cards_time_ms;
   G1ConcurrentRefine* cr = _g1h->concurrent_refine();
 
   log_debug(gc, ergo, refine)
            ("GC refinement: goal: %zu / %1.2fms, actual: %zu / %1.2fms, %s",
             cr->pending_cards_target(),
-            logged_cards_time_goal_ms,
-            logged_cards,
-            logged_cards_time_ms,
+            pending_cards_time_goal_ms,
+            pending_cards,
+            pending_cards_time_ms,
             (exceeded_goal ? " (exceeded goal)" : ""));
 
-  cr->adjust_after_gc(logged_cards_time_ms,
-                      logged_cards,
-                      logged_cards_time_goal_ms);
+  cr->adjust_after_gc(pending_cards_time_ms,
+                      pending_cards,
+                      pending_cards_time_goal_ms);
 }
 
 G1IHOPControl* G1Policy::create_ihop_control(const G1OldGenAllocationTracker* old_gen_alloc_tracker,

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

@@ -121,7 +121,7 @@ class G1Policy: public CHeapObj<mtGC> {
     return collector_state()->in_young_only_phase() && !collector_state()->mark_or_rebuild_in_progress();
   }
 
-  double logged_cards_processing_time() const;
+  double pending_cards_processing_time() const;
 public:
   const G1Predictions& predictor() const { return _predictor; }
   const G1Analytics* analytics()   const { return const_cast<const G1Analytics*>(_analytics); }

test/hotspot/jtreg/gc/g1/TestGCLogMessages.java

@@ -177,7 +177,7 @@ public boolean isAvailable() {
         new LogMessageWithLevel("To-Young-Gen Cards:", Level.DEBUG),
         new LogMessageWithLevel("Evac-Fail Cards:", Level.DEBUG),
         new LogMessageWithLevel("Marked Cards:", Level.DEBUG),
-        new LogMessageWithLevel("Clear Logged Cards \\(ms\\):", Level.DEBUG),
+        new LogMessageWithLevel("Clear Pending Cards \\(ms\\):", Level.DEBUG),
         new LogMessageWithLevel("Recalculate Used Memory \\(ms\\):", Level.DEBUG),
 
         // Post Evacuate Cleanup 2

test/jdk/jdk/jfr/event/gc/collection/TestG1ParallelPhases.java

@@ -108,7 +108,7 @@ public static void main(String[] args) throws IOException {
             "UpdateDerivedPointers",
             "EagerlyReclaimHumongousObjects",
             "ResetPartialArrayStateManager",
-            "ClearLoggedCards",
+            "ClearPendingCards",
             "MergePSS",
             "NonYoungFreeCSet",
             "YoungFreeCSet",