runtime: make TestDebugLogInterleaving much more robust

The current test often doesn't actually generate enough interleaving
to result in multiple log shards. This CL rewrites this test to
forcibly create at least 10 log shards with interleaved log messages.
It also tests dlog's robustness to being held across M and P switches.

Change-Id: Ia913b17c0392384ff679832047f359945669bb15
Reviewed-on: https://go-review.googlesource.com/c/go/+/600699
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Carlos Amedee <[email protected]>
Auto-Submit: Austin Clements <[email protected]>

Author: aclements

src/runtime/debuglog_test.go

@@ -28,7 +28,6 @@ import (
 	"runtime"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"testing"
 )
 
@@ -82,28 +81,63 @@ func TestDebugLogSym(t *testing.T) {
 func TestDebugLogInterleaving(t *testing.T) {
 	skipDebugLog(t)
 	runtime.ResetDebugLog()
+
+	n1 := runtime.CountDebugLog()
+	t.Logf("number of log shards at start: %d", n1)
+
+	const limit = 1000
+	const concurrency = 10
+
+	// Start several goroutines writing to the log simultaneously.
 	var wg sync.WaitGroup
-	done := int32(0)
-	wg.Add(1)
-	go func() {
-		// Encourage main goroutine to move around to
-		// different Ms and Ps.
-		for atomic.LoadInt32(&done) == 0 {
-			runtime.Gosched()
-		}
-		wg.Done()
-	}()
-	var want strings.Builder
-	for i := 0; i < 1000; i++ {
-		runtime.Dlog().I(i).End()
-		fmt.Fprintf(&want, "[] %d\n", i)
-		runtime.Gosched()
+	i := 0
+	chans := make([]chan bool, concurrency)
+	for gid := range concurrency {
+		chans[gid] = make(chan bool)
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var log *runtime.Dlogger
+			for {
+				<-chans[gid]
+				if log != nil {
+					log.End()
+				}
+				next := chans[(gid+1)%len(chans)]
+				if i >= limit {
+					close(next)
+					break
+				}
+				// Log an entry, but *don't* release the log shard until its our
+				// turn again. This should result in at least n=concurrency log
+				// shards.
+				log = runtime.Dlog().I(i)
+				i++
+				// Wake up the next logger goroutine.
+				next <- true
+			}
+		}()
 	}
-	atomic.StoreInt32(&done, 1)
-	wg.Wait()
+	// Start the chain reaction.
+	chans[0] <- true
 
+	// Wait for them to finish and get the log.
+	wg.Wait()
 	gotFull := runtime.DumpDebugLog()
 	got := dlogCanonicalize(gotFull)
+
+	n2 := runtime.CountDebugLog()
+	t.Logf("number of log shards at end: %d", n2)
+	if n2 < concurrency {
+		t.Errorf("created %d log shards, expected >= %d", n2, concurrency)
+	}
+
+	// Construct the desired output.
+	var want strings.Builder
+	for i := 0; i < limit; i++ {
+		fmt.Fprintf(&want, "[] %d\n", i)
+	}
+
 	if got != want.String() {
 		// Since the timestamps are useful in understand
 		// failures of this test, we print the uncanonicalized

src/runtime/export_debuglog_test.go

@@ -48,3 +48,13 @@ func ResetDebugLog() {
 	}
 	startTheWorld(stw)
 }
+
+func CountDebugLog() int {
+	stw := stopTheWorld(stwForTestResetDebugLog)
+	i := 0
+	for l := allDloggers; l != nil; l = l.allLink {
+		i++
+	}
+	startTheWorld(stw)
+	return i
+}