runtime: add a test for asynchronous safe points

This adds a test of preempting a loop containing no synchronous safe
points for STW and stack scanning.

We couldn't add this test earlier because it requires scheduler, STW,
and stack scanning preemption to all be working.

For #10958, #24543.

Change-Id: I73292db78ca3d14aab11bdafd26d03986920ef0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/201777
Run-TryBot: Austin Clements <austin@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 831f3f13d4bd2fec2fe2dde761a98d1700dc1920..3c1b4db7504b3f1fb5fd7d9d05dadd366f030ecd 100644 (file)
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -42,6 +42,8 @@ var PhysHugePageSize = physHugePageSize
 
 var NetpollGenericInit = netpollGenericInit
 
+const PreemptMSupported = preemptMSupported
+
 type LFNode struct {
        Next    uint64
        Pushcnt uintptr

diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go
index 9b80ce31e5d69bd98218e404249be942c584d6fc..acee7a181936ce1fd38d5247a55b0673d8dacaaa 100644 (file)
--- a/src/runtime/proc_test.go
+++ b/src/runtime/proc_test.go
@@ -356,6 +356,17 @@ func TestPreemptionGC(t *testing.T) {
        atomic.StoreUint32(&stop, 1)
 }
 
+func TestAsyncPreempt(t *testing.T) {
+       if !runtime.PreemptMSupported {
+               t.Skip("asynchronous preemption not supported on this platform")
+       }
+       output := runTestProg(t, "testprog", "AsyncPreempt")
+       want := "OK\n"
+       if output != want {
+               t.Fatalf("want %s, got %s\n", want, output)
+       }
+}
+
 func TestGCFairness(t *testing.T) {
        output := runTestProg(t, "testprog", "GCFairness")
        want := "OK\n"

diff --git a/src/runtime/testdata/testprog/preempt.go b/src/runtime/testdata/testprog/preempt.go
new file mode 100644 (file)
index 0000000..cf004fc
--- /dev/null
+++ b/src/runtime/testdata/testprog/preempt.go
@@ -0,0 +1,44 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+       "runtime"
+       "runtime/debug"
+       "sync/atomic"
+)
+
+func init() {
+       register("AsyncPreempt", AsyncPreempt)
+}
+
+func AsyncPreempt() {
+       // Run with just 1 GOMAXPROCS so the runtime is required to
+       // use scheduler preemption.
+       runtime.GOMAXPROCS(1)
+       // Disable GC so we have complete control of what we're testing.
+       debug.SetGCPercent(-1)
+
+       // Start a goroutine with no sync safe-points.
+       var ready uint32
+       go func() {
+               for {
+                       atomic.StoreUint32(&ready, 1)
+               }
+       }()
+
+       // Wait for the goroutine to stop passing through sync
+       // safe-points.
+       for atomic.LoadUint32(&ready) == 0 {
+               runtime.Gosched()
+       }
+
+       // Run a GC, which will have to stop the goroutine for STW and
+       // for stack scanning. If this doesn't work, the test will
+       // deadlock and timeout.
+       runtime.GC()
+
+       println("OK")
+}