8350314: Shenandoah: Capture thread state sync times in GC timings

Xiaolong Peng · Xiaolong Peng · commit 01bd7e417ee3 · 2025-02-27T09:49:29.000Z
Reviewed-by: ysr, shade, wkemper
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp
@@ -688,6 +688,11 @@ void ShenandoahConcurrentGC::op_init_mark() {
   if (ShenandoahPacing) {
     heap->pacer()->setup_for_mark();
   }
+
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::init_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 void ShenandoahConcurrentGC::op_mark_roots() {
@@ -755,6 +760,11 @@ void ShenandoahConcurrentGC::op_final_mark() {
       }
     }
   }
+
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 bool ShenandoahConcurrentGC::has_in_place_promotions(ShenandoahHeap* heap) {
@@ -1158,6 +1168,11 @@ void ShenandoahConcurrentGC::op_final_update_refs() {
   }
 
   heap->rebuild_free_set(true /*concurrent*/);
+
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_update_refs_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 void ShenandoahConcurrentGC::op_final_roots() {
@@ -1182,6 +1197,11 @@ void ShenandoahConcurrentGC::op_final_roots() {
   if (VerifyAfterGC) {
     Universe::verify();
   }
+
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_roots_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 void ShenandoahConcurrentGC::op_cleanup_complete() {
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahDegeneratedGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahDegeneratedGC.cpp
@@ -83,6 +83,10 @@ void ShenandoahDegenGC::entry_degenerated() {
   heap->set_degenerated_gc_in_progress(true);
   op_degenerated();
   heap->set_degenerated_gc_in_progress(false);
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::degen_gc_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 void ShenandoahDegenGC::op_degenerated() {
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp
@@ -130,6 +130,11 @@ void ShenandoahFullGC::op_full(GCCause::Cause cause) {
   // Regardless if progress was made, we record that we completed a "successful" full GC.
   heap->global_generation()->heuristics()->record_success_full();
   heap->shenandoah_policy()->record_success_full();
+
+  {
+    ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::full_gc_propagate_gc_state);
+    heap->propagate_gc_state_to_all_threads();
+  }
 }
 
 void ShenandoahFullGC::do_it(GCCause::Cause gc_cause) {
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahOldGC.cpp
@@ -78,6 +78,11 @@ void ShenandoahOldGC::op_final_mark() {
     if (VerifyAfterGC) {
       Universe::verify();
     }
+
+    {
+      ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);
+      heap->propagate_gc_state_to_all_threads();
+    }
   }
 }
 
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.hpp b/src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.hpp
@@ -57,6 +57,7 @@ class outputStream;
   f(init_swap_rset,                                 "  Swap Remembered Set")           \
   f(init_transfer_satb,                             "  Transfer Old From SATB")        \
   f(init_update_region_states,                      "  Update Region States")          \
+  f(init_propagate_gc_state,                        "  Propagate GC State")            \
                                                                                        \
   f(init_scan_rset,                                 "Concurrent Scan Remembered Set")  \
   SHENANDOAH_PAR_PHASE_DO(init_scan_rset_,          "  RS: ", f)                       \
@@ -70,6 +71,7 @@ class outputStream;
   f(final_mark_gross,                               "Pause Final Mark (G)")            \
   f(final_mark,                                     "Pause Final Mark (N)")            \
   f(finish_mark,                                    "  Finish Mark")                   \
+  f(final_mark_propagate_gc_state,                  "  Propagate GC State")            \
   SHENANDOAH_PAR_PHASE_DO(finish_mark_,             "    FM: ", f)                     \
   f(purge,                                          "  System Purge")                  \
   SHENANDOAH_PAR_PHASE_DO(purge_cu_par_,            "      CU: ", f)                   \
@@ -107,6 +109,7 @@ class outputStream;
   f(promote_in_place,                               "Concurrent Promote Regions")      \
   f(final_roots_gross,                              "Pause Final Roots (G)")           \
   f(final_roots,                                    "Pause Final Roots (N)")           \
+  f(final_roots_propagate_gc_state,                 "  Propagate GC State")            \
                                                                                        \
   f(init_update_refs_gross,                         "Pause Init Update Refs (G)")      \
   f(init_update_refs,                               "Pause Init Update Refs (N)")      \
@@ -121,6 +124,7 @@ class outputStream;
   f(final_update_refs_update_region_states,         "  Update Region States")          \
   f(final_update_refs_trash_cset,                   "  Trash Collection Set")          \
   f(final_update_refs_rebuild_freeset,              "  Rebuild Free Set")              \
+  f(final_update_refs_propagate_gc_state,           "  Propagate GC State")            \
                                                                                        \
   f(conc_cleanup_complete,                          "Concurrent Cleanup")              \
   f(conc_coalesce_and_fill,                         "Concurrent Coalesce and Fill")    \
@@ -157,6 +161,7 @@ class outputStream;
   f(degen_gc_promote_regions,                       "  Degen Promote Regions")         \
   f(degen_gc_coalesce_and_fill,                     "  Degen Coalesce and Fill")       \
   SHENANDOAH_PAR_PHASE_DO(degen_coalesce_,          "    DC&F", f)                     \
+  f(degen_gc_propagate_gc_state,                    "  Propagate GC State")            \
                                                                                        \
   f(full_gc_gross,                                  "Pause Full GC (G)")               \
   f(full_gc,                                        "Pause Full GC (N)")               \
@@ -188,6 +193,7 @@ class outputStream;
   f(full_gc_copy_objects_rebuild,                   "    Rebuild Region Sets")         \
   f(full_gc_reconstruct_remembered_set,             "    Reconstruct Remembered Set")  \
   f(full_gc_heapdump_post,                          "  Post Heap Dump")                \
+  f(full_gc_propagate_gc_state,                     "  Propagate GC State")            \
                                                                                        \
   f(pacing,                                         "Pacing")                          \
                                                                                        \
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahVMOperations.cpp b/src/hotspot/share/gc/shenandoah/shenandoahVMOperations.cpp
@@ -81,47 +81,40 @@ void VM_ShenandoahInitMark::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Init Mark", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_init_mark();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahFinalMarkStartEvac::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Final Mark", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_final_mark();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahFullGC::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Full GC", SvcGCMarker::FULL);
   set_active_generation();
   _full_gc->entry_full(_gc_cause);
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahDegeneratedGC::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Degenerated GC", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_degenerated();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahInitUpdateRefs::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Init Update Refs", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_init_update_refs();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahFinalUpdateRefs::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Final Update Refs", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_final_update_refs();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }
 
 void VM_ShenandoahFinalRoots::doit() {
   ShenandoahGCPauseMark mark(_gc_id, "Final Roots", SvcGCMarker::CONCURRENT);
   set_active_generation();
   _gc->entry_final_roots();
-  ShenandoahHeap::heap()->propagate_gc_state_to_all_threads();
 }

Original file line number	Diff line number	Diff line change
`@@ -688,6 +688,11 @@ void ShenandoahConcurrentGC::op_init_mark() {`
`688`	`688`	`if (ShenandoahPacing) {`
`689`	`689`	`heap->pacer()->setup_for_mark();`
`690`	`690`	`}`
	`691`	`+`
	`692`	`+ {`
	`693`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::init_propagate_gc_state);`
	`694`	`+ heap->propagate_gc_state_to_all_threads();`
	`695`	`+ }`
`691`	`696`	`}`
`692`	`697`
`693`	`698`	`void ShenandoahConcurrentGC::op_mark_roots() {`
`@@ -755,6 +760,11 @@ void ShenandoahConcurrentGC::op_final_mark() {`
`755`	`760`	`}`
`756`	`761`	`}`
`757`	`762`	`}`
	`763`	`+`
	`764`	`+ {`
	`765`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);`
	`766`	`+ heap->propagate_gc_state_to_all_threads();`
	`767`	`+ }`
`758`	`768`	`}`
`759`	`769`
`760`	`770`	`bool ShenandoahConcurrentGC::has_in_place_promotions(ShenandoahHeap* heap) {`
`@@ -1158,6 +1168,11 @@ void ShenandoahConcurrentGC::op_final_update_refs() {`
`1158`	`1168`	`}`
`1159`	`1169`
`1160`	`1170`	`heap->rebuild_free_set(true /concurrent/);`
	`1171`	`+`
	`1172`	`+ {`
	`1173`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_update_refs_propagate_gc_state);`
	`1174`	`+ heap->propagate_gc_state_to_all_threads();`
	`1175`	`+ }`
`1161`	`1176`	`}`
`1162`	`1177`
`1163`	`1178`	`void ShenandoahConcurrentGC::op_final_roots() {`
`@@ -1182,6 +1197,11 @@ void ShenandoahConcurrentGC::op_final_roots() {`
`1182`	`1197`	`if (VerifyAfterGC) {`
`1183`	`1198`	`Universe::verify();`
`1184`	`1199`	`}`
	`1200`	`+`
	`1201`	`+ {`
	`1202`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_roots_propagate_gc_state);`
	`1203`	`+ heap->propagate_gc_state_to_all_threads();`
	`1204`	`+ }`
`1185`	`1205`	`}`
`1186`	`1206`
`1187`	`1207`	`void ShenandoahConcurrentGC::op_cleanup_complete() {`
Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,11 @@ void ShenandoahOldGC::op_final_mark() {`
`78`	`78`	`if (VerifyAfterGC) {`
`79`	`79`	`Universe::verify();`
`80`	`80`	`}`
	`81`	`+`
	`82`	`+ {`
	`83`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);`
	`84`	`+ heap->propagate_gc_state_to_all_threads();`
	`85`	`+ }`
`81`	`86`	`}`
`82`	`87`	`}`
`83`	`88`