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

William Kemper · William Kemper · commit 15bdf9282c3b · 2025-04-04T17:48:02.000Z
Backport-of: 01bd7e4
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp
@@ -689,6 +689,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() {
@@ -756,6 +761,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) {
@@ -1153,6 +1163,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() {
@@ -1177,6 +1192,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
@@ -85,6 +85,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
@@ -129,6 +129,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
@@ -80,6 +80,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(conc_uncommit,                                  "Concurrent Uncommit")             \
   f(pacing,                                         "Pacing")                          \
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahVMOperations.cpp b/src/hotspot/share/gc/shenandoah/shenandoahVMOperations.cpp
@@ -84,47 +84,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
`@@ -689,6 +689,11 @@ void ShenandoahConcurrentGC::op_init_mark() {`
`689`	`689`	`if (ShenandoahPacing) {`
`690`	`690`	`heap->pacer()->setup_for_mark();`
`691`	`691`	`}`
	`692`	`+`
	`693`	`+ {`
	`694`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::init_propagate_gc_state);`
	`695`	`+ heap->propagate_gc_state_to_all_threads();`
	`696`	`+ }`
`692`	`697`	`}`
`693`	`698`
`694`	`699`	`void ShenandoahConcurrentGC::op_mark_roots() {`
`@@ -756,6 +761,11 @@ void ShenandoahConcurrentGC::op_final_mark() {`
`756`	`761`	`}`
`757`	`762`	`}`
`758`	`763`	`}`
	`764`	`+`
	`765`	`+ {`
	`766`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);`
	`767`	`+ heap->propagate_gc_state_to_all_threads();`
	`768`	`+ }`
`759`	`769`	`}`
`760`	`770`
`761`	`771`	`bool ShenandoahConcurrentGC::has_in_place_promotions(ShenandoahHeap* heap) {`
`@@ -1153,6 +1163,11 @@ void ShenandoahConcurrentGC::op_final_update_refs() {`
`1153`	`1163`	`}`
`1154`	`1164`
`1155`	`1165`	`heap->rebuild_free_set(true /concurrent/);`
	`1166`	`+`
	`1167`	`+ {`
	`1168`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_update_refs_propagate_gc_state);`
	`1169`	`+ heap->propagate_gc_state_to_all_threads();`
	`1170`	`+ }`
`1156`	`1171`	`}`
`1157`	`1172`
`1158`	`1173`	`void ShenandoahConcurrentGC::op_final_roots() {`
`@@ -1177,6 +1192,11 @@ void ShenandoahConcurrentGC::op_final_roots() {`
`1177`	`1192`	`if (VerifyAfterGC) {`
`1178`	`1193`	`Universe::verify();`
`1179`	`1194`	`}`
	`1195`	`+`
	`1196`	`+ {`
	`1197`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_roots_propagate_gc_state);`
	`1198`	`+ heap->propagate_gc_state_to_all_threads();`
	`1199`	`+ }`
`1180`	`1200`	`}`
`1181`	`1201`
`1182`	`1202`	`void ShenandoahConcurrentGC::op_cleanup_complete() {`
Original file line number	Diff line number	Diff line change
`@@ -80,6 +80,11 @@ void ShenandoahOldGC::op_final_mark() {`
`80`	`80`	`if (VerifyAfterGC) {`
`81`	`81`	`Universe::verify();`
`82`	`82`	`}`
	`83`	`+`
	`84`	`+ {`
	`85`	`+ ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::final_mark_propagate_gc_state);`
	`86`	`+ heap->propagate_gc_state_to_all_threads();`
	`87`	`+ }`
`83`	`88`	`}`
`84`	`89`	`}`
`85`	`90`