runtime: drain local runq when dedicated mark worker runs

When the dedicated mark worker runs, the scheduler won't run on that P
again until GC runs out of mark work. As a result, any goroutines in
that P's local run queue are stranded until another P steals them. In
a normally operating system this may take a long time, and in a 100%
busy system, the scheduler never attempts to steal from another P.

Fix this by draining the local run queue into the global run queue if
the dedicated mark worker has run for long enough. We don't do this
immediately upon scheduling the dedicated mark worker in order to
avoid destroying locality if the mark worker runs for a short time.
Instead, the scheduler delays draining the run queue until the mark
worker gets its first preemption request (and otherwise ignores the
preemption request).

Fixes #20011.

Change-Id: I13067194b2f062b8bdef25cb75e4143b7fb6bb73
Reviewed-on: https://go-review.googlesource.com/46610
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rick Hudson <rlh@golang.org>

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 22e8c313176eac8fed9b7ab39d45db83eec47a37..705fe697bb449551d448b75ba7989945ae7d02e8 100644 (file)
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -688,9 +688,6 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
                // This P is now dedicated to marking until the end of
                // the concurrent mark phase.
                _p_.gcMarkWorkerMode = gcMarkWorkerDedicatedMode
-               // TODO(austin): This P isn't going to run anything
-               // else for a while, so kick everything out of its run
-               // queue.
        } else {
                if !decIfPositive(&c.fractionalMarkWorkersNeeded) {
                        // No more workers are need right now.
@@ -1773,6 +1770,25 @@ func gcBgMarkWorker(_p_ *p) {
                        default:
                                throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")
                        case gcMarkWorkerDedicatedMode:
+                               gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
+                               if gp.preempt {
+                                       // We were preempted. This is
+                                       // a useful signal to kick
+                                       // everything out of the run
+                                       // queue so it can run
+                                       // somewhere else.
+                                       lock(&sched.lock)
+                                       for {
+                                               gp, _ := runqget(_p_)
+                                               if gp == nil {
+                                                       break
+                                               }
+                                               globrunqput(gp)
+                                       }
+                                       unlock(&sched.lock)
+                               }
+                               // Go back to draining, this time
+                               // without preemption.
                                gcDrain(&_p_.gcw, gcDrainNoBlock|gcDrainFlushBgCredit)
                        case gcMarkWorkerFractionalMode:
                                gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)