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

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

@@ -1165,7 +1165,6 @@ G1CollectedHeap::G1CollectedHeap() :
   _workers(nullptr),
   _refinement_epoch(0),
   _last_synchronized_start(0),
-  _safepoint_duration(0),
   _last_refinement_epoch_start(0),
   _yield_duration_in_refinement_epoch(0),
   _last_safepoint_refinement_epoch(0),
@@ -1534,8 +1533,6 @@ void G1CollectedHeap::safepoint_synchronize_end() {
   jlong now = os::elapsed_counter();
   jlong synchronize_duration = now - _last_synchronized_start;
 
-  _safepoint_duration += synchronize_duration;
-
   if (_last_safepoint_refinement_epoch == refinement_epoch()) {
     _yield_duration_in_refinement_epoch += synchronize_duration;
   } else {

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

@@ -186,7 +186,6 @@ class G1CollectedHeap : public CollectedHeap {
   // The following members are for tracking safepoint durations between garbage
   // collections.
   jlong _last_synchronized_start;
-  jlong _safepoint_duration;                       // Time spent in safepoints since start of VM.
 
   jlong _last_refinement_epoch_start;
   jlong _yield_duration_in_refinement_epoch;       // Time spent in safepoints since beginning of last refinement epoch.
@@ -915,7 +914,6 @@ class G1CollectedHeap : public CollectedHeap {
   void safepoint_synchronize_begin() override;
   void safepoint_synchronize_end() override;
 
-  jlong safepoint_duration() const { return _safepoint_duration; }
   jlong last_refinement_epoch_start() const { return _last_refinement_epoch_start; }
   void set_last_refinement_epoch_start(jlong epoch_start, jlong last_yield_duration);
   jlong yield_duration_in_refinement_epoch();

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

@@ -147,20 +147,16 @@ void G1ConcurrentRefineSweepState::reset_stats() {
   stats()->reset();
 }
 
-void G1ConcurrentRefineSweepState::add_yield_duration(jlong duration) {
-  stats()->inc_yield_duration(duration);
+void G1ConcurrentRefineSweepState::add_yield_during_sweep_duration(jlong duration) {
+  stats()->inc_yield_during_sweep_duration(duration);
 }
 
 size_t G1ConcurrentRefineSweepState::refinement_epoch() {
   return G1CollectedHeap::heap()->refinement_epoch();
 }
 
-bool G1ConcurrentRefineSweepState::in_sweep_epoch() const {
-  return _sweep_start_epoch == refinement_epoch();
-}
-
 bool G1ConcurrentRefineSweepState::advance_state(State next_state) {
-  bool result = in_sweep_epoch();
+  bool result = _sweep_start_epoch == refinement_epoch();
   if (result) {
     _state = next_state;
   } else {
@@ -200,7 +196,7 @@ bool G1ConcurrentRefineSweepState::swap_global_card_table() {
     MutexLocker mu(Threads_lock);
     // A GC that advanced the epoch might have happened, which already switched
     // The global card table. Do nothing.
-    if (in_sweep_epoch()) {
+    if (is_in_progress()) {
       G1BarrierSet::g1_barrier_set()->swap_global_card_table();
     }
   }
@@ -327,7 +323,7 @@ bool G1ConcurrentRefineSweepState::complete_work(bool concurrent, bool print_log
 
     log_debug(gc, refine)("Refinement took %.2fms (pre-sweep %.2fms card refine %.2f) "
                           "(scanned %zu clean %zu (%.2f%%) not_clean %zu (%.2f%%) not_parsable %zu "
-                          "refers_to_cset %zu (%.2f%%) still_refers_to_cset %zu (%.2f%%) clean_again %zu pending %zu)",
+                          "refers_to_cset %zu (%.2f%%) still_refers_to_cset %zu (%.2f%%) no_cross_region %zu pending %zu)",
                           get_duration(State::Idle, _state).seconds() * 1000.0,
                           get_duration(State::Idle, State::SweepRT).seconds() * 1000.0,
                           TimeHelper::counter_to_millis(s->refine_duration()),
@@ -341,12 +337,12 @@ bool G1ConcurrentRefineSweepState::complete_work(bool concurrent, bool print_log
                           percent_of(s->cards_refer_to_cset(), s->cards_not_clean()),
                           s->cards_already_refer_to_cset(),
                           percent_of(s->cards_already_refer_to_cset(), s->cards_not_clean()),
-                          s->cards_clean_again(),
+                          s->cards_no_cross_region(),
                           s->cards_pending()
                          );
   }
 
-  bool has_sweep_rt_work = is_in_progress() && _state == State::SweepRT;
+  bool has_sweep_rt_work = _state == State::SweepRT;
 
   _state = State::Idle;
   return has_sweep_rt_work;

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

@@ -151,8 +151,6 @@ class G1ConcurrentRefineSweepState {
 
   static size_t refinement_epoch();
 
-  bool in_sweep_epoch() const;
-
   // Advances the state to next_state if not interrupted by a changed epoch. Returns
   // to Idle otherwise.
   bool advance_state(State next_state);
@@ -180,7 +178,7 @@ class G1ConcurrentRefineSweepState {
   G1ConcurrentRefineStats* stats() { return &_stats; }
   void reset_stats();
 
-  void add_yield_duration(jlong duration);
+  void add_yield_during_sweep_duration(jlong duration);
 
   bool is_in_progress() const;
   bool are_java_threads_synched() const;

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

@@ -28,26 +28,26 @@
 
 G1ConcurrentRefineStats::G1ConcurrentRefineStats() :
   _sweep_duration(0),
-  _yield_duration(0),
+  _yield_during_sweep_duration(0),
   _cards_scanned(0),
   _cards_clean(0),
   _cards_not_parsable(0),
   _cards_already_refer_to_cset(0),
   _cards_refer_to_cset(0),
-  _cards_clean_again(0),
+  _cards_no_cross_region(0),
   _refine_duration(0)
 {}
 
 void G1ConcurrentRefineStats::add_atomic(G1ConcurrentRefineStats* other) {
   Atomic::add(&_sweep_duration, other->_sweep_duration, memory_order_relaxed);
-  Atomic::add(&_yield_duration, other->_yield_duration, memory_order_relaxed);
+  Atomic::add(&_yield_during_sweep_duration, other->_yield_during_sweep_duration, memory_order_relaxed);
 
   Atomic::add(&_cards_scanned, other->_cards_scanned, memory_order_relaxed);
   Atomic::add(&_cards_clean, other->_cards_clean, memory_order_relaxed);
   Atomic::add(&_cards_not_parsable, other->_cards_not_parsable, memory_order_relaxed);
   Atomic::add(&_cards_already_refer_to_cset, other->_cards_already_refer_to_cset, memory_order_relaxed);
   Atomic::add(&_cards_refer_to_cset, other->_cards_refer_to_cset, memory_order_relaxed);
-  Atomic::add(&_cards_clean_again, other->_cards_clean_again, memory_order_relaxed);
+  Atomic::add(&_cards_no_cross_region, other->_cards_no_cross_region, memory_order_relaxed);
 
   Atomic::add(&_refine_duration, other->_refine_duration, memory_order_relaxed);
 }

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

@@ -35,14 +35,14 @@
 class G1ConcurrentRefineStats : public CHeapObj<mtGC> {
   jlong _sweep_duration;              // Time spent sweeping the table finding non-clean cards
                                       // and refining them.
-  jlong _yield_duration;              // Time spent yielding during the sweep (not doing the sweep).
+  jlong _yield_during_sweep_duration; // Time spent yielding during the sweep (not doing the sweep).
 
   size_t _cards_scanned;              // Total number of cards scanned.
   size_t _cards_clean;                // Number of cards found clean.
   size_t _cards_not_parsable;         // Number of cards we could not parse and left unrefined.
   size_t _cards_already_refer_to_cset;// Number of cards marked found to be already young.
   size_t _cards_refer_to_cset;        // Number of dirty cards that were recently found to contain a to-cset reference.
-  size_t _cards_clean_again;          // Number of dirty cards that were cleaned by the mutator.
+  size_t _cards_no_cross_region;      // Number of dirty cards that were dirtied, but then cleaned again by the mutator.
 
   jlong _refine_duration;             // Time spent during actual refinement.
 
@@ -51,8 +51,8 @@ class G1ConcurrentRefineStats : public CHeapObj<mtGC> {
 
   // Time spent performing sweeping the refinement table (includes actual refinement,
   // but not yield time).
-  jlong sweep_duration() const { return _sweep_duration - _yield_duration; }
-  jlong yield_duration() const { return _yield_duration; }
+  jlong sweep_duration() const { return _sweep_duration - _yield_during_sweep_duration; }
+  jlong yield_during_sweep_duration() const { return _yield_during_sweep_duration; }
   jlong refine_duration() const { return _refine_duration; }
 
   // Number of refined cards.
@@ -64,23 +64,23 @@ class G1ConcurrentRefineStats : public CHeapObj<mtGC> {
   size_t cards_not_parsable() const { return _cards_not_parsable; }
   size_t cards_already_refer_to_cset() const { return _cards_already_refer_to_cset; }
   size_t cards_refer_to_cset() const { return _cards_refer_to_cset; }
-  size_t cards_clean_again() const { return _cards_clean_again; }
+  size_t cards_no_cross_region() const { return _cards_no_cross_region; }
   // Number of cards that were marked dirty and in need of refinement. This includes cards recently
   // found to refer to the collection set as they originally were dirty.
   size_t cards_pending() const { return cards_not_clean() - _cards_already_refer_to_cset; }
 
   size_t cards_to_cset() const { return _cards_already_refer_to_cset + _cards_refer_to_cset; }
 
   void inc_sweep_time(jlong t) { _sweep_duration += t; }
-  void inc_yield_duration(jlong t) { _yield_duration += t; }
+  void inc_yield_during_sweep_duration(jlong t) { _yield_during_sweep_duration += t; }
   void inc_refine_duration(jlong t) { _refine_duration += t; }
 
   void inc_cards_scanned(size_t increment) { _cards_scanned += increment; }
   void inc_cards_clean(size_t increment) { _cards_clean += increment; }
   void inc_cards_not_parsable() { _cards_not_parsable++; }
   void inc_cards_already_refer_to_cset() { _cards_already_refer_to_cset++; }
   void inc_cards_refer_to_cset() { _cards_refer_to_cset++; }
-  void inc_cards_clean_again() { _cards_clean_again++; }
+  void inc_cards_no_cross_region() { _cards_no_cross_region++; }
 
   void add_atomic(G1ConcurrentRefineStats* other);
 

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

@@ -70,8 +70,8 @@ class G1RefineRegionClosure : public G1HeapRegionClosure {
         _refine_stats.inc_cards_already_refer_to_cset();
         break;
       }
-      case G1RemSet::NoInteresting: {
-        _refine_stats.inc_cards_clean_again();
+      case G1RemSet::NoCrossRegion: {
+        _refine_stats.inc_cards_no_cross_region();
         break;
       }
       case G1RemSet::CouldNotParse: {

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

@@ -169,7 +169,7 @@ void G1ConcurrentRefineThread::do_refinement() {
   jlong epoch_yield_duration = g1h->yield_duration_in_refinement_epoch();
   jlong next_epoch_start = os::elapsed_counter();
 
-  jlong synchronize_duration_at_sweep_start = g1h->safepoint_duration();
+  jlong total_yield_during_sweep_duration = 0;
 
   // 4. Snapshot heap.
   state.snapshot_heap();
@@ -187,7 +187,7 @@ void G1ConcurrentRefineThread::do_refinement() {
     }
 
     if (SuspendibleThreadSet::should_yield()) {
-      jlong yield_start = os::elapsed_counter();
+      jlong yield_during_sweep_start = os::elapsed_counter();
       SuspendibleThreadSet::yield();
 
       // The yielding may have completed the task, check.
@@ -196,15 +196,16 @@ void G1ConcurrentRefineThread::do_refinement() {
         interrupted_by_gc = true;
         break;
       } else {
-        jlong yield_duration = os::elapsed_counter() - yield_start;
+        jlong yield_during_sweep_duration = os::elapsed_counter() - yield_during_sweep_start;
         log_debug(gc, refine)("Yielded from card table sweeping for %.2fms, no GC inbetween, continue",
-                              TimeHelper::counter_to_millis(yield_duration));
+                              TimeHelper::counter_to_millis(yield_during_sweep_duration));
+        total_yield_during_sweep_duration += yield_during_sweep_duration;
       }
     }
   }
 
   if (!interrupted_by_gc) {
-    state.add_yield_duration(G1CollectedHeap::heap()->safepoint_duration() - synchronize_duration_at_sweep_start);
+    state.add_yield_during_sweep_duration(total_yield_during_sweep_duration);
 
     state.complete_work(true);
 

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

@@ -608,7 +608,7 @@ static void log_refinement_stats(const G1ConcurrentRefineStats& stats) {
   log_debug(gc, refine, stats)
            ("Refinement: sweep: %.2fms, yield: %.2fms refined: %zu, dirtied: %zu",
             TimeHelper::counter_to_millis(stats.sweep_duration()),
-            TimeHelper::counter_to_millis(stats.yield_duration()),
+            TimeHelper::counter_to_millis(stats.yield_during_sweep_duration()),
             stats.refined_cards(),
             stats.cards_pending());
 }

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

@@ -1363,7 +1363,7 @@ G1RemSet::RefineResult G1RemSet::refine_card_concurrently(CardValue* const card_
     } else if (conc_refine_cl.has_ref_to_old()) {
       return HasRefToOld;
     } else {
-      return NoInteresting;
+      return NoCrossRegion;
     }
   }
   // If unable to process the card then we encountered an unparsable

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

@@ -122,7 +122,7 @@ class G1RemSet: public CHeapObj<mtGC> {
       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.
       HasRefToOld,           // The dirty card contains references to other old regions (not the collection set).
-      NoInteresting,         // There is no interesting reference in the card any more. The mutator changed all
+      NoCrossRegion,         // There is no interesting reference in the card any more. The mutator changed all
                              // references to such after dirtying the card.
       CouldNotParse          // The card is unparsable, need to retry later.
   };