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

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

@@ -798,13 +798,13 @@ void G1CollectedHeap::prepare_for_mutator_after_full_collection() {
 }
 
 void G1CollectedHeap::abort_refinement() {
-  G1ConcurrentRefineWorkState& refine_state = concurrent_refine()->refine_state();
-  if (refine_state.is_in_progress()) {
+  G1ConcurrentRefineSweepState& sweep_state = concurrent_refine()->sweep_state();
+  if (sweep_state.is_in_progress()) {
     // Record any available refinement statistics.
-    policy()->record_refinement_stats(refine_state.stats());
-    refine_state.complete(false /* concurrent */, false /* print_log */);
+    policy()->record_refinement_stats(sweep_state.stats());
+    sweep_state.complete_work(false /* concurrent */, false /* print_log */);
   }
-  refine_state.reset_stats();
+  sweep_state.reset_stats();
 }
 
 void G1CollectedHeap::verify_after_full_collection() {

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

@@ -122,41 +122,41 @@ void G1ConcurrentRefineThreadControl::stop() {
   }
 }
 
-G1ConcurrentRefineWorkState::G1ConcurrentRefineWorkState(uint max_reserved_regions) :
+G1ConcurrentRefineSweepState::G1ConcurrentRefineSweepState(uint max_reserved_regions) :
   _state(State::Idle),
-  _refine_work_epoch(0),
+  _sweep_start_epoch(0),
   _sweep_table(new G1CardTableClaimTable(G1CollectedHeap::get_chunks_per_region_for_merge())),
   _stats()
 {
   _sweep_table->initialize(max_reserved_regions);
 }
 
-G1ConcurrentRefineWorkState::~G1ConcurrentRefineWorkState() {
+G1ConcurrentRefineSweepState::~G1ConcurrentRefineSweepState() {
   delete _sweep_table;
 }
 
-void G1ConcurrentRefineWorkState::set_state_start_time() {
+void G1ConcurrentRefineSweepState::set_state_start_time() {
   _state_start[static_cast<uint>(_state)] = Ticks::now();
 }
 
-Tickspan G1ConcurrentRefineWorkState::get_duration(State start, State end) {
+Tickspan G1ConcurrentRefineSweepState::get_duration(State start, State end) {
   return _state_start[static_cast<uint>(end)] - _state_start[static_cast<uint>(start)];
 }
 
-void G1ConcurrentRefineWorkState::reset_stats() {
+void G1ConcurrentRefineSweepState::reset_stats() {
   stats()->reset();
 }
 
-void G1ConcurrentRefineWorkState::add_yield_duration(jlong duration) {
+void G1ConcurrentRefineSweepState::add_yield_duration(jlong duration) {
   stats()->inc_yield_duration(duration);
 }
 
-size_t G1ConcurrentRefineWorkState::refinement_epoch() {
+size_t G1ConcurrentRefineSweepState::refinement_epoch() {
   return G1CollectedHeap::heap()->refinement_epoch();
 }
 
-bool G1ConcurrentRefineWorkState::advance_state(State next_state) {
-  bool result = _refine_work_epoch == refinement_epoch();
+bool G1ConcurrentRefineSweepState::advance_state(State next_state) {
+  bool result = _sweep_start_epoch == refinement_epoch();
   if (result) {
     _state = next_state;
   } else {
@@ -165,23 +165,23 @@ bool G1ConcurrentRefineWorkState::advance_state(State next_state) {
   return result;
 }
 
-void G1ConcurrentRefineWorkState::assert_state(State expected) {
+void G1ConcurrentRefineSweepState::assert_state(State expected) {
   assert(_state == expected, "must be %s but is %s", state_name(expected), state_name(_state));
 }
 
-void G1ConcurrentRefineWorkState::start_refine_work() {
+void G1ConcurrentRefineSweepState::start_work() {
   assert_state(State::Idle);
 
   set_state_start_time();
 
-  _refine_work_epoch = refinement_epoch();
+  _sweep_start_epoch = refinement_epoch();
 
   _stats.reset();
 
   advance_state(State::SwapGlobalCT);
 }
 
-bool G1ConcurrentRefineWorkState::swap_global_card_table() {
+bool G1ConcurrentRefineSweepState::swap_global_card_table() {
   assert_state(State::SwapGlobalCT);
 
   set_state_start_time();
@@ -200,7 +200,7 @@ bool G1ConcurrentRefineWorkState::swap_global_card_table() {
   return advance_state(State::SwapJavaThreadsCT);
 }
 
-bool G1ConcurrentRefineWorkState::swap_java_threads_ct() {
+bool G1ConcurrentRefineSweepState::swap_java_threads_ct() {
   assert_state(State::SwapJavaThreadsCT);
 
   set_state_start_time();
@@ -217,14 +217,13 @@ bool G1ConcurrentRefineWorkState::swap_java_threads_ct() {
         G1ThreadLocalData::set_byte_map_base(t, bs->card_table()->byte_map_base());
       }
     } cl;
-
     Handshake::execute(&cl);
   }
 
   return advance_state(State::SwapGCThreadsCT);
 }
 
-bool G1ConcurrentRefineWorkState::swap_gc_threads_ct() {
+bool G1ConcurrentRefineSweepState::swap_gc_threads_ct() {
   assert_state(State::SwapGCThreadsCT);
 
   set_state_start_time();
@@ -259,7 +258,7 @@ bool G1ConcurrentRefineWorkState::swap_gc_threads_ct() {
   return advance_state(State::SnapshotHeap);
 }
 
-void G1ConcurrentRefineWorkState::snapshot_heap(bool concurrent) {
+void G1ConcurrentRefineSweepState::snapshot_heap(bool concurrent) {
   if (concurrent) {
     assert_state(State::SnapshotHeap);
 
@@ -276,13 +275,13 @@ void G1ConcurrentRefineWorkState::snapshot_heap(bool concurrent) {
   }
 }
 
-void G1ConcurrentRefineWorkState::sweep_rt_start() {
+void G1ConcurrentRefineSweepState::sweep_refinement_table_start() {
   assert_state(State::SweepRT);
 
   set_state_start_time();
 }
 
-bool G1ConcurrentRefineWorkState::sweep_rt_step() {
+bool G1ConcurrentRefineSweepState::sweep_refinement_table_step() {
   assert_state(State::SweepRT);
 
   G1ConcurrentRefine* cr = G1CollectedHeap::heap()->concurrent_refine();
@@ -298,7 +297,7 @@ bool G1ConcurrentRefineWorkState::sweep_rt_step() {
   }
 }
 
-bool G1ConcurrentRefineWorkState::complete(bool concurrent, bool print_log) {
+bool G1ConcurrentRefineSweepState::complete_work(bool concurrent, bool print_log) {
   if (concurrent) {
     assert_state(State::CompleteRefineWork);
   } else {
@@ -338,7 +337,7 @@ bool G1ConcurrentRefineWorkState::complete(bool concurrent, bool print_log) {
   return has_sweep_rt_work;
 }
 
-void G1ConcurrentRefineWorkState::snapshot_heap_into(G1CardTableClaimTable* sweep_table) {
+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.
   sweep_table->reset_all_to_claimed();
@@ -364,7 +363,7 @@ void G1ConcurrentRefineWorkState::snapshot_heap_into(G1CardTableClaimTable* swee
   G1CollectedHeap::heap()->heap_region_iterate(&cl);
 }
 
-bool G1ConcurrentRefineWorkState::is_in_progress() const {
+bool G1ConcurrentRefineSweepState::is_in_progress() const {
   return _state != State::Idle;
 }
 
@@ -388,15 +387,15 @@ G1ConcurrentRefine::G1ConcurrentRefine(G1CollectedHeap* g1h) :
   _heap_was_locked(false),
   _threads_needed(g1h->policy(), adjust_threads_period_ms()),
   _thread_control(G1ConcRefinementThreads),
-  _refine_state(g1h->max_reserved_regions())
+  _sweep_state(g1h->max_reserved_regions())
 { }
 
 jint G1ConcurrentRefine::initialize() {
   return _thread_control.initialize(this);
 }
 
-G1ConcurrentRefineWorkState& G1ConcurrentRefine::refine_state_for_merge() {
-  bool has_sweep_claims = refine_state().complete(false);
+G1ConcurrentRefineSweepState& G1ConcurrentRefine::sweep_state_for_merge() {
+  bool has_sweep_claims = sweep_state().complete_work(false);
   if (has_sweep_claims) {
     log_debug(gc, refine)("Continue existing work");
   } else {
@@ -407,9 +406,9 @@ G1ConcurrentRefineWorkState& G1ConcurrentRefine::refine_state_for_merge() {
     // creating the snapshot right now.
     log_debug(gc, refine)("Create work from scratch");
 
-    refine_state().snapshot_heap(false /* concurrent */);
+    sweep_state().snapshot_heap(false /* concurrent */);
   }
-  return refine_state();
+  return sweep_state();
 }
 
 void G1ConcurrentRefine::run_with_refinement_workers(WorkerTask* task) {
@@ -418,8 +417,8 @@ void G1ConcurrentRefine::run_with_refinement_workers(WorkerTask* task) {
 
 void G1ConcurrentRefine::notify_region_reclaimed(G1HeapRegion* r) {
   assert_at_safepoint();
-  if (_refine_state.is_in_progress()) {
-    _refine_state.sweep_table()->claim_all_cards(r->hrm_index());
+  if (_sweep_state.is_in_progress()) {
+    _sweep_state.sweep_table()->claim_all_cards(r->hrm_index());
   }
 }
 

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

@@ -79,9 +79,34 @@ class G1ConcurrentRefineThreadControl {
   void stop();
 };
 
-// Tracks the current refinement state from idle to completion (and reset back
-// to idle).
-class G1ConcurrentRefineWorkState {
+// Tracks the current state of re-examining the dirty cards from idle to completion
+// (and reset back to idle).
+//
+// The process steps are as follows:
+//
+// 1) Swap global card table pointers
+//
+// 2) Swap Java Thread's card table pointers
+//
+// 3) Synchronize GC Threads
+//      Ensures memory visibility
+//
+// After this point mutator threads should not mark the refinement table.
+//
+// 4) Snapshot the heap
+//      Determines which regions need to be swept.
+//
+// 5) Sweep Refinement table
+//      Examines non-Clean cards on the refinement table.
+//
+// 6) Completion Work
+//      Calculates statistics about the process to be used in various parts of
+//      the garbage collection.
+//
+// All but step 4 are interruptible by safepoints. In case of a garbage collection,
+// the garbage collection will interrupt this process, and go to Idle state.
+//
+class G1ConcurrentRefineSweepState {
 
   enum class State : uint {
     Idle,                        // Refinement is doing nothing.
@@ -97,20 +122,20 @@ class G1ConcurrentRefineWorkState {
   static const char* state_name(State state) {
     static const char* _state_names[] = {
       "Idle",
-      "Swap Global CT",
-      "Swap JavaThread CT",
-      "Swap GC Thread CT",
+      "Swap Global Card Table",
+      "Swap JavaThread Card Table",
+      "Synchronize GC Threads",
       "Snapshot Heap",
-      "Sweep RT",
-      "Complete Refine Work"
+      "Sweep Refinement Table",
+      "Complete Sweep Work"
     };
 
     return _state_names[static_cast<uint>(state)];
   }
 
-  // Current epoch the work has been started; used to determine if there has been
+  // The epoch the sweep has started; used to determine if there has been
   // a forced card table swap due to a garbage collection while doing work.
-  size_t _refine_work_epoch;
+  size_t _sweep_start_epoch;
 
   // Current heap snapshot.
   G1CardTableClaimTable* _sweep_table;
@@ -131,22 +156,22 @@ class G1ConcurrentRefineWorkState {
 
   void assert_state(State expected);
 
+  static void snapshot_heap_into(G1CardTableClaimTable* sweep_table);
+
 public:
-  G1ConcurrentRefineWorkState(uint max_reserved_regions);
-  ~G1ConcurrentRefineWorkState();
+  G1ConcurrentRefineSweepState(uint max_reserved_regions);
+  ~G1ConcurrentRefineSweepState();
 
-  void start_refine_work();
+  void start_work();
 
   bool swap_global_card_table();
   bool swap_java_threads_ct();
   bool swap_gc_threads_ct();
   void snapshot_heap(bool concurrent = true);
-  void sweep_rt_start();
-  bool sweep_rt_step();
-
-  bool complete(bool concurrent, bool print_log = true);
+  void sweep_refinement_table_start();
+  bool sweep_refinement_table_step();
 
-  static void snapshot_heap_into(G1CardTableClaimTable* sweep_table);
+  bool complete_work(bool concurrent, bool print_log = true);
 
   G1CardTableClaimTable* sweep_table() { return _sweep_table; }
   G1ConcurrentRefineStats* stats() { return &_stats; }
@@ -195,7 +220,7 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
   G1ConcurrentRefineThreadsNeeded _threads_needed;
   G1ConcurrentRefineThreadControl _thread_control;
 
-  G1ConcurrentRefineWorkState _refine_state;
+  G1ConcurrentRefineSweepState _sweep_state;
 
   G1ConcurrentRefine(G1CollectedHeap* g1h);
 
@@ -230,9 +255,9 @@ class G1ConcurrentRefine : public CHeapObj<mtGC> {
 public:
   ~G1ConcurrentRefine();
 
-  G1ConcurrentRefineWorkState& refine_state() { return _refine_state; }
+  G1ConcurrentRefineSweepState& sweep_state() { return _sweep_state; }
 
-  G1ConcurrentRefineWorkState& refine_state_for_merge();
+  G1ConcurrentRefineSweepState& sweep_state_for_merge();
 
   void run_with_refinement_workers(WorkerTask* task);
 

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

@@ -137,9 +137,9 @@ bool G1ConcurrentRefineThread::wait_for_work() {
 }
 
 void G1ConcurrentRefineThread::do_refinement() {
-  G1ConcurrentRefineWorkState& state = _cr->refine_state();
+  G1ConcurrentRefineSweepState& state = _cr->sweep_state();
 
-  state.start_refine_work();
+  state.start_work();
   log_debug(gc,refine)("Concurrent Refine Work Start (threads wanted: %u)", _cr->num_threads_wanted());
 
   // Swap card tables.
@@ -178,9 +178,9 @@ void G1ConcurrentRefineThread::do_refinement() {
   // 5. Sweep refinement table until done
   bool interrupted_by_gc = false;
 
-  state.sweep_rt_start();
+  state.sweep_refinement_table_start();
   while (true) {
-    bool completed = state.sweep_rt_step();
+    bool completed = state.sweep_refinement_table_step();
 
     if (completed) {
       break;
@@ -206,7 +206,7 @@ void G1ConcurrentRefineThread::do_refinement() {
   if (!interrupted_by_gc) {
     state.add_yield_duration(G1CollectedHeap::heap()->safepoint_duration() - synchronize_duration_at_sweep_start);
 
-    state.complete(true);
+    state.complete_work(true);
 
     G1CollectedHeap* g1h = G1CollectedHeap::heap();
     G1Policy* policy = g1h->policy();

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

@@ -64,8 +64,8 @@ class G1ConcurrentRefineThread: public ConcurrentGCThread {
   // precondition: this is the current thread.
   bool deactivate();
 
-  // Attempt to do some refinement work.
-  // precondition: this is the current thread.
+  // Swap card table and do a complete re-examination/refinement pass over the
+  // refinement table.
   void do_refinement();
 
   // Update concurrent refine threads stats.

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

@@ -937,7 +937,7 @@ void G1Policy::record_young_collection_end(bool concurrent_operation_is_full_mar
 
   {
     double mutator_end_time = phase_times()->cur_collection_start_sec() * MILLIUNITS;
-    G1ConcurrentRefineStats* stats = _g1h->concurrent_refine()->refine_state().stats();
+    G1ConcurrentRefineStats* stats = _g1h->concurrent_refine()->sweep_state().stats();
     // Record any available refinement statistics.
     record_refinement_stats(stats);