Stop-the-world latency during Garbage Collection in G-M-P scheduler

Answer

Yes. When a GC cycle begins, the Go runtime first flushes every P’s local run queue to the global run queue. Only after this flush does it enter the stop‑the‑world (STW) phase and pause all M threads. When a P is detached from its M during the pause, its local queue is already empty; all goroutines are in the global queue, so work‑stealing continues normally, albeit with a minor loss of locality.

Confirmed Facts (Go 1.20+)

• The GC start routine performs a global flush of all local run queues before invoking runtime.stopTheWorld.
• During an STW pause the scheduler stops all M threads, but P objects remain in memory and can be re‑attached when the pause ends.
• Work‑stealing remains functional because all goroutines are already in the global queue; the only impact is reduced cache locality for goroutines that would have run on the detached P.

Practical Verification

1. Run a workload that triggers GC frequently, e.g. go test -bench=..

   GODEBUG=gctrace=1,trace=1 go test -bench=.

2. Inspect the trace output for the sequence:

   sched: flush
   sched: stop the world
   

   This confirms the flush occurs before the pause.
3. Use go tool pprof -http=:6060 to view runtime stats and verify that all goroutines are present in the global queue during a GC pause.
4. Measure scheduling latency before and after GC to quantify any drop in work‑stealing efficiency.

Impact on Work‑Stealing

Because all goroutines are already in the global queue, other P objects can continue to steal work without interruption. The only observable effect is a slight decrease in locality: goroutines that would have run on the detached P now start on a different P, potentially missing cache warm‑ups. In practice, this latency is usually negligible unless the application is extremely sensitive to cache locality or has a very high number of blocking syscalls that inflate M counts.

What We Still Need

To give a more precise recommendation for your environment, could you provide a recent GC trace or the number of OS threads (M) your application creates during peak load? This will help assess whether the observed latency spikes are within normal bounds or if tuning GOGC or reducing blocking calls is warranted.