test: tweak test to avoid unpreemptible loop with gccgo

This test contains a very tight loop with locking/unlocking that can
wind up as an unpreemptible when compiled with gccgo, depending on
inlining. Tweak the test slightly to avoid this problem.

Change-Id: I155fd2b4bfea961244eb6c6594c24ab03d32d41c
Reviewed-on: https://go-review.googlesource.com/c/go/+/193619
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/misc/cgo/test/test.go b/misc/cgo/test/test.go
index 4286fb9cdbe99ea1aa186dbb125819f17db4489e..0a26bfb5cf26d9160d81af9638d74cf97df93c9c 100644 (file)
--- a/misc/cgo/test/test.go
+++ b/misc/cgo/test/test.go
@@ -1950,11 +1950,20 @@ func test27660(t *testing.T) {
                        // increase the likelihood that the race described in #27660
                        // results in corruption of ThreadSanitizer's internal state
                        // and thus an assertion failure or segfault.
+                       i := 0
                        for ctx.Err() == nil {
                                j := rand.Intn(100)
                                locks[j].Lock()
                                ints[j]++
                                locks[j].Unlock()
+                               // needed for gccgo, to avoid creation of an
+                               // unpreemptible "fast path" in this loop. Choice
+                               // of (1<<24) is somewhat arbitrary.
+                               if i%(1<<24) == 0 {
+                                       runtime.Gosched()
+                               }
+                               i++
+
                        }
                }()
                time.Sleep(time.Millisecond)