c++/modules: Propagate TYPE_CANONICAL for partial specialisations [PR113814]

[official-gcc.git] / libgo / go / runtime / proc_test.go

// Copyright 2011 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 runtime_test

import (
        "fmt"
        "internal/race"
        "internal/testenv"
        "math"
        "net"
        "runtime"
        "runtime/debug"
        "strings"
        "sync"
        "sync/atomic"
        "syscall"
        "testing"
        "time"
)

var stop = make(chan bool, 1)

func perpetuumMobile() {
        select {
        case <-stop:
        default:
                go perpetuumMobile()
        }
}

func TestStopTheWorldDeadlock(t *testing.T) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }
        if testing.Short() {
                t.Skip("skipping during short test")
        }
        maxprocs := runtime.GOMAXPROCS(3)
        compl := make(chan bool, 2)
        go func() {
                for i := 0; i != 1000; i += 1 {
                        runtime.GC()
                }
                compl <- true
        }()
        go func() {
                for i := 0; i != 1000; i += 1 {
                        runtime.GOMAXPROCS(3)
                }
                compl <- true
        }()
        go perpetuumMobile()
        <-compl
        <-compl
        stop <- true
        runtime.GOMAXPROCS(maxprocs)
}

func TestYieldProgress(t *testing.T) {
        testYieldProgress(false)
}

func TestYieldLockedProgress(t *testing.T) {
        testYieldProgress(true)
}

func testYieldProgress(locked bool) {
        c := make(chan bool)
        cack := make(chan bool)
        go func() {
                if locked {
                        runtime.LockOSThread()
                }
                for {
                        select {
                        case <-c:
                                cack <- true
                                return
                        default:
                                runtime.Gosched()
                        }
                }
        }()
        time.Sleep(10 * time.Millisecond)
        c <- true
        <-cack
}

func TestYieldLocked(t *testing.T) {
        const N = 10
        c := make(chan bool)
        go func() {
                runtime.LockOSThread()
                for i := 0; i < N; i++ {
                        runtime.Gosched()
                        time.Sleep(time.Millisecond)
                }
                c <- true
                // runtime.UnlockOSThread() is deliberately omitted
        }()
        <-c
}

func TestGoroutineParallelism(t *testing.T) {
        if runtime.NumCPU() == 1 {
                // Takes too long, too easy to deadlock, etc.
                t.Skip("skipping on uniprocessor")
        }
        P := 4
        N := 10
        if testing.Short() {
                P = 3
                N = 3
        }
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
        // If runtime triggers a forced GC during this test then it will deadlock,
        // since the goroutines can't be stopped/preempted.
        // Disable GC for this test (see issue #10958).
        defer debug.SetGCPercent(debug.SetGCPercent(-1))
        // SetGCPercent waits until the mark phase is over, but the runtime
        // also preempts at the start of the sweep phase, so make sure that's
        // done too. See #45867.
        runtime.GC()
        for try := 0; try < N; try++ {
                done := make(chan bool)
                x := uint32(0)
                for p := 0; p < P; p++ {
                        // Test that all P goroutines are scheduled at the same time
                        go func(p int) {
                                for i := 0; i < 3; i++ {
                                        expected := uint32(P*i + p)
                                        for atomic.LoadUint32(&x) != expected {
                                        }
                                        atomic.StoreUint32(&x, expected+1)
                                }
                                done <- true
                        }(p)
                }
                for p := 0; p < P; p++ {
                        <-done
                }
        }
}

// Test that all runnable goroutines are scheduled at the same time.
func TestGoroutineParallelism2(t *testing.T) {
        //testGoroutineParallelism2(t, false, false)
        testGoroutineParallelism2(t, true, false)
        testGoroutineParallelism2(t, false, true)
        testGoroutineParallelism2(t, true, true)
}

func testGoroutineParallelism2(t *testing.T, load, netpoll bool) {
        if runtime.NumCPU() == 1 {
                // Takes too long, too easy to deadlock, etc.
                t.Skip("skipping on uniprocessor")
        }
        P := 4
        N := 10
        if testing.Short() {
                N = 3
        }
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
        // If runtime triggers a forced GC during this test then it will deadlock,
        // since the goroutines can't be stopped/preempted.
        // Disable GC for this test (see issue #10958).
        defer debug.SetGCPercent(debug.SetGCPercent(-1))
        // SetGCPercent waits until the mark phase is over, but the runtime
        // also preempts at the start of the sweep phase, so make sure that's
        // done too. See #45867.
        runtime.GC()
        for try := 0; try < N; try++ {
                if load {
                        // Create P goroutines and wait until they all run.
                        // When we run the actual test below, worker threads
                        // running the goroutines will start parking.
                        done := make(chan bool)
                        x := uint32(0)
                        for p := 0; p < P; p++ {
                                go func() {
                                        if atomic.AddUint32(&x, 1) == uint32(P) {
                                                done <- true
                                                return
                                        }
                                        for atomic.LoadUint32(&x) != uint32(P) {
                                        }
                                }()
                        }
                        <-done
                }
                if netpoll {
                        // Enable netpoller, affects schedler behavior.
                        laddr := "localhost:0"
                        if runtime.GOOS == "android" {
                                // On some Android devices, there are no records for localhost,
                                // see https://golang.org/issues/14486.
                                // Don't use 127.0.0.1 for every case, it won't work on IPv6-only systems.
                                laddr = "127.0.0.1:0"
                        }
                        ln, err := net.Listen("tcp", laddr)
                        if err != nil {
                                defer ln.Close() // yup, defer in a loop
                        }
                }
                done := make(chan bool)
                x := uint32(0)
                // Spawn P goroutines in a nested fashion just to differ from TestGoroutineParallelism.
                for p := 0; p < P/2; p++ {
                        go func(p int) {
                                for p2 := 0; p2 < 2; p2++ {
                                        go func(p2 int) {
                                                for i := 0; i < 3; i++ {
                                                        expected := uint32(P*i + p*2 + p2)
                                                        for atomic.LoadUint32(&x) != expected {
                                                        }
                                                        atomic.StoreUint32(&x, expected+1)
                                                }
                                                done <- true
                                        }(p2)
                                }
                        }(p)
                }
                for p := 0; p < P; p++ {
                        <-done
                }
        }
}

func TestBlockLocked(t *testing.T) {
        const N = 10
        c := make(chan bool)
        go func() {
                runtime.LockOSThread()
                for i := 0; i < N; i++ {
                        c <- true
                }
                runtime.UnlockOSThread()
        }()
        for i := 0; i < N; i++ {
                <-c
        }
}

func TestTimerFairness(t *testing.T) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }

        done := make(chan bool)
        c := make(chan bool)
        for i := 0; i < 2; i++ {
                go func() {
                        for {
                                select {
                                case c <- true:
                                case <-done:
                                        return
                                }
                        }
                }()
        }

        timer := time.After(20 * time.Millisecond)
        for {
                select {
                case <-c:
                case <-timer:
                        close(done)
                        return
                }
        }
}

func TestTimerFairness2(t *testing.T) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }

        done := make(chan bool)
        c := make(chan bool)
        for i := 0; i < 2; i++ {
                go func() {
                        timer := time.After(20 * time.Millisecond)
                        var buf [1]byte
                        for {
                                syscall.Read(0, buf[0:0])
                                select {
                                case c <- true:
                                case <-c:
                                case <-timer:
                                        done <- true
                                        return
                                }
                        }
                }()
        }
        <-done
        <-done
}

// The function is used to test preemption at split stack checks.
// Declaring a var avoids inlining at the call site.
var preempt = func() int {
        var a [128]int
        sum := 0
        for _, v := range a {
                sum += v
        }
        return sum
}

func TestPreemption(t *testing.T) {
        if runtime.Compiler == "gccgo" {
                t.Skip("gccgo does not implement preemption")
        }
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }

        // Test that goroutines are preempted at function calls.
        N := 5
        if testing.Short() {
                N = 2
        }
        c := make(chan bool)
        var x uint32
        for g := 0; g < 2; g++ {
                go func(g int) {
                        for i := 0; i < N; i++ {
                                for atomic.LoadUint32(&x) != uint32(g) {
                                        preempt()
                                }
                                atomic.StoreUint32(&x, uint32(1-g))
                        }
                        c <- true
                }(g)
        }
        <-c
        <-c
}

func TestPreemptionGC(t *testing.T) {
        if runtime.Compiler == "gccgo" {
                t.Skip("gccgo does not implement preemption")
        }
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }

        // Test that pending GC preempts running goroutines.
        P := 5
        N := 10
        if testing.Short() {
                P = 3
                N = 2
        }
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P + 1))
        var stop uint32
        for i := 0; i < P; i++ {
                go func() {
                        for atomic.LoadUint32(&stop) == 0 {
                                preempt()
                        }
                }()
        }
        for i := 0; i < N; i++ {
                runtime.Gosched()
                runtime.GC()
        }
        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"
        if output != want {
                t.Fatalf("want %s, got %s\n", want, output)
        }
}

func TestGCFairness2(t *testing.T) {
        output := runTestProg(t, "testprog", "GCFairness2")
        want := "OK\n"
        if output != want {
                t.Fatalf("want %s, got %s\n", want, output)
        }
}

func TestNumGoroutine(t *testing.T) {
        output := runTestProg(t, "testprog", "NumGoroutine")
        want := "1\n"
        if output != want {
                t.Fatalf("want %q, got %q", want, output)
        }

        buf := make([]byte, 1<<20)

        // Try up to 10 times for a match before giving up.
        // This is a fundamentally racy check but it's important
        // to notice if NumGoroutine and Stack are _always_ out of sync.
        for i := 0; ; i++ {
                // Give goroutines about to exit a chance to exit.
                // The NumGoroutine and Stack below need to see
                // the same state of the world, so anything we can do
                // to keep it quiet is good.
                runtime.Gosched()

                n := runtime.NumGoroutine()
                buf = buf[:runtime.Stack(buf, true)]

                nstk := strings.Count(string(buf), "goroutine ")
                if n == nstk {
                        break
                }
                if i >= 10 {
                        t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump: %s", n, nstk, buf)
                }
        }
}

func TestPingPongHog(t *testing.T) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }
        if testing.Short() {
                t.Skip("skipping in -short mode")
        }
        if race.Enabled {
                // The race detector randomizes the scheduler,
                // which causes this test to fail (#38266).
                t.Skip("skipping in -race mode")
        }

        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
        done := make(chan bool)
        hogChan, lightChan := make(chan bool), make(chan bool)
        hogCount, lightCount := 0, 0

        run := func(limit int, counter *int, wake chan bool) {
                for {
                        select {
                        case <-done:
                                return

                        case <-wake:
                                for i := 0; i < limit; i++ {
                                        *counter++
                                }
                                wake <- true
                        }
                }
        }

        // Start two co-scheduled hog goroutines.
        for i := 0; i < 2; i++ {
                go run(1e6, &hogCount, hogChan)
        }

        // Start two co-scheduled light goroutines.
        for i := 0; i < 2; i++ {
                go run(1e3, &lightCount, lightChan)
        }

        // Start goroutine pairs and wait for a few preemption rounds.
        hogChan <- true
        lightChan <- true
        time.Sleep(100 * time.Millisecond)
        close(done)
        <-hogChan
        <-lightChan

        // Check that hogCount and lightCount are within a factor of
        // 5, which indicates that both pairs of goroutines handed off
        // the P within a time-slice to their buddy. We can use a
        // fairly large factor here to make this robust: if the
        // scheduler isn't working right, the gap should be ~1000X.
        const factor = 5
        if hogCount > lightCount*factor || lightCount > hogCount*factor {
                t.Fatalf("want hogCount/lightCount in [%v, %v]; got %d/%d = %g", 1.0/factor, factor, hogCount, lightCount, float64(hogCount)/float64(lightCount))
        }
}

func BenchmarkPingPongHog(b *testing.B) {
        if b.N == 0 {
                return
        }
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))

        // Create a CPU hog
        stop, done := make(chan bool), make(chan bool)
        go func() {
                for {
                        select {
                        case <-stop:
                                done <- true
                                return
                        default:
                        }
                }
        }()

        // Ping-pong b.N times
        ping, pong := make(chan bool), make(chan bool)
        go func() {
                for j := 0; j < b.N; j++ {
                        pong <- <-ping
                }
                close(stop)
                done <- true
        }()
        go func() {
                for i := 0; i < b.N; i++ {
                        ping <- <-pong
                }
                done <- true
        }()
        b.ResetTimer()
        ping <- true // Start ping-pong
        <-stop
        b.StopTimer()
        <-ping // Let last ponger exit
        <-done // Make sure goroutines exit
        <-done
        <-done
}

var padData [128]uint64

func stackGrowthRecursive(i int) {
        var pad [128]uint64
        pad = padData
        for j := range pad {
                if pad[j] != 0 {
                        return
                }
        }
        if i != 0 {
                stackGrowthRecursive(i - 1)
        }
}

func TestPreemptSplitBig(t *testing.T) {
        if testing.Short() {
                t.Skip("skipping in -short mode")
        }
        t.Skip("gccgo does not implement preemption")
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
        stop := make(chan int)
        go big(stop)
        for i := 0; i < 3; i++ {
                time.Sleep(10 * time.Microsecond) // let big start running
                runtime.GC()
        }
        close(stop)
}

func big(stop chan int) int {
        n := 0
        for {
                // delay so that gc is sure to have asked for a preemption
                for i := 0; i < 1e9; i++ {
                        n++
                }

                // call bigframe, which used to miss the preemption in its prologue.
                bigframe(stop)

                // check if we've been asked to stop.
                select {
                case <-stop:
                        return n
                }
        }
}

func bigframe(stop chan int) int {
        // not splitting the stack will overflow.
        // small will notice that it needs a stack split and will
        // catch the overflow.
        var x [8192]byte
        return small(stop, &x)
}

func small(stop chan int, x *[8192]byte) int {
        for i := range x {
                x[i] = byte(i)
        }
        sum := 0
        for i := range x {
                sum += int(x[i])
        }

        // keep small from being a leaf function, which might
        // make it not do any stack check at all.
        nonleaf(stop)

        return sum
}

func nonleaf(stop chan int) bool {
        // do something that won't be inlined:
        select {
        case <-stop:
                return true
        default:
                return false
        }
}

func TestSchedLocalQueue(t *testing.T) {
        runtime.RunSchedLocalQueueTest()
}

func TestSchedLocalQueueSteal(t *testing.T) {
        runtime.RunSchedLocalQueueStealTest()
}

func TestSchedLocalQueueEmpty(t *testing.T) {
        if runtime.NumCPU() == 1 {
                // Takes too long and does not trigger the race.
                t.Skip("skipping on uniprocessor")
        }
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))

        // If runtime triggers a forced GC during this test then it will deadlock,
        // since the goroutines can't be stopped/preempted during spin wait.
        defer debug.SetGCPercent(debug.SetGCPercent(-1))
        // SetGCPercent waits until the mark phase is over, but the runtime
        // also preempts at the start of the sweep phase, so make sure that's
        // done too. See #45867.
        runtime.GC()

        iters := int(1e5)
        if testing.Short() {
                iters = 1e2
        }
        runtime.RunSchedLocalQueueEmptyTest(iters)
}

func benchmarkStackGrowth(b *testing.B, rec int) {
        b.RunParallel(func(pb *testing.PB) {
                for pb.Next() {
                        stackGrowthRecursive(rec)
                }
        })
}

func BenchmarkStackGrowth(b *testing.B) {
        benchmarkStackGrowth(b, 10)
}

func BenchmarkStackGrowthDeep(b *testing.B) {
        benchmarkStackGrowth(b, 1024)
}

func BenchmarkCreateGoroutines(b *testing.B) {
        benchmarkCreateGoroutines(b, 1)
}

func BenchmarkCreateGoroutinesParallel(b *testing.B) {
        benchmarkCreateGoroutines(b, runtime.GOMAXPROCS(-1))
}

func benchmarkCreateGoroutines(b *testing.B, procs int) {
        c := make(chan bool)
        var f func(n int)
        f = func(n int) {
                if n == 0 {
                        c <- true
                        return
                }
                go f(n - 1)
        }
        for i := 0; i < procs; i++ {
                go f(b.N / procs)
        }
        for i := 0; i < procs; i++ {
                <-c
        }
}

func BenchmarkCreateGoroutinesCapture(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
                const N = 4
                var wg sync.WaitGroup
                wg.Add(N)
                for i := 0; i < N; i++ {
                        i := i
                        go func() {
                                if i >= N {
                                        b.Logf("bad") // just to capture b
                                }
                                wg.Done()
                        }()
                }
                wg.Wait()
        }
}

// warmupScheduler ensures the scheduler has at least targetThreadCount threads
// in its thread pool.
func warmupScheduler(targetThreadCount int) {
        var wg sync.WaitGroup
        var count int32
        for i := 0; i < targetThreadCount; i++ {
                wg.Add(1)
                go func() {
                        atomic.AddInt32(&count, 1)
                        for atomic.LoadInt32(&count) < int32(targetThreadCount) {
                                // spin until all threads started
                        }

                        // spin a bit more to ensure they are all running on separate CPUs.
                        doWork(time.Millisecond)
                        wg.Done()
                }()
        }
        wg.Wait()
}

func doWork(dur time.Duration) {
        start := time.Now()
        for time.Since(start) < dur {
        }
}

// BenchmarkCreateGoroutinesSingle creates many goroutines, all from a single
// producer (the main benchmark goroutine).
//
// Compared to BenchmarkCreateGoroutines, this causes different behavior in the
// scheduler because Ms are much more likely to need to steal work from the
// main P rather than having work in the local run queue.
func BenchmarkCreateGoroutinesSingle(b *testing.B) {
        // Since we are interested in stealing behavior, warm the scheduler to
        // get all the Ps running first.
        warmupScheduler(runtime.GOMAXPROCS(0))
        b.ResetTimer()

        var wg sync.WaitGroup
        wg.Add(b.N)
        for i := 0; i < b.N; i++ {
                go func() {
                        wg.Done()
                }()
        }
        wg.Wait()
}

func BenchmarkClosureCall(b *testing.B) {
        sum := 0
        off1 := 1
        for i := 0; i < b.N; i++ {
                off2 := 2
                func() {
                        sum += i + off1 + off2
                }()
        }
        _ = sum
}

func benchmarkWakeupParallel(b *testing.B, spin func(time.Duration)) {
        if runtime.GOMAXPROCS(0) == 1 {
                b.Skip("skipping: GOMAXPROCS=1")
        }

        wakeDelay := 5 * time.Microsecond
        for _, delay := range []time.Duration{
                0,
                1 * time.Microsecond,
                2 * time.Microsecond,
                5 * time.Microsecond,
                10 * time.Microsecond,
                20 * time.Microsecond,
                50 * time.Microsecond,
                100 * time.Microsecond,
        } {
                b.Run(delay.String(), func(b *testing.B) {
                        if b.N == 0 {
                                return
                        }
                        // Start two goroutines, which alternate between being
                        // sender and receiver in the following protocol:
                        //
                        // - The receiver spins for `delay` and then does a
                        // blocking receive on a channel.
                        //
                        // - The sender spins for `delay+wakeDelay` and then
                        // sends to the same channel. (The addition of
                        // `wakeDelay` improves the probability that the
                        // receiver will be blocking when the send occurs when
                        // the goroutines execute in parallel.)
                        //
                        // In each iteration of the benchmark, each goroutine
                        // acts once as sender and once as receiver, so each
                        // goroutine spins for delay twice.
                        //
                        // BenchmarkWakeupParallel is used to estimate how
                        // efficiently the scheduler parallelizes goroutines in
                        // the presence of blocking:
                        //
                        // - If both goroutines are executed on the same core,
                        // an increase in delay by N will increase the time per
                        // iteration by 4*N, because all 4 delays are
                        // serialized.
                        //
                        // - Otherwise, an increase in delay by N will increase
                        // the time per iteration by 2*N, and the time per
                        // iteration is 2 * (runtime overhead + chan
                        // send/receive pair + delay + wakeDelay). This allows
                        // the runtime overhead, including the time it takes
                        // for the unblocked goroutine to be scheduled, to be
                        // estimated.
                        ping, pong := make(chan struct{}), make(chan struct{})
                        start := make(chan struct{})
                        done := make(chan struct{})
                        go func() {
                                <-start
                                for i := 0; i < b.N; i++ {
                                        // sender
                                        spin(delay + wakeDelay)
                                        ping <- struct{}{}
                                        // receiver
                                        spin(delay)
                                        <-pong
                                }
                                done <- struct{}{}
                        }()
                        go func() {
                                for i := 0; i < b.N; i++ {
                                        // receiver
                                        spin(delay)
                                        <-ping
                                        // sender
                                        spin(delay + wakeDelay)
                                        pong <- struct{}{}
                                }
                                done <- struct{}{}
                        }()
                        b.ResetTimer()
                        start <- struct{}{}
                        <-done
                        <-done
                })
        }
}

func BenchmarkWakeupParallelSpinning(b *testing.B) {
        benchmarkWakeupParallel(b, func(d time.Duration) {
                end := time.Now().Add(d)
                for time.Now().Before(end) {
                        // do nothing
                }
        })
}

// sysNanosleep is defined by OS-specific files (such as runtime_linux_test.go)
// to sleep for the given duration. If nil, dependent tests are skipped.
// The implementation should invoke a blocking system call and not
// call time.Sleep, which would deschedule the goroutine.
var sysNanosleep func(d time.Duration)

func BenchmarkWakeupParallelSyscall(b *testing.B) {
        if sysNanosleep == nil {
                b.Skipf("skipping on %v; sysNanosleep not defined", runtime.GOOS)
        }
        benchmarkWakeupParallel(b, func(d time.Duration) {
                sysNanosleep(d)
        })
}

type Matrix [][]float64

func BenchmarkMatmult(b *testing.B) {
        b.StopTimer()
        // matmult is O(N**3) but testing expects O(b.N),
        // so we need to take cube root of b.N
        n := int(math.Cbrt(float64(b.N))) + 1
        A := makeMatrix(n)
        B := makeMatrix(n)
        C := makeMatrix(n)
        b.StartTimer()
        matmult(nil, A, B, C, 0, n, 0, n, 0, n, 8)
}

func makeMatrix(n int) Matrix {
        m := make(Matrix, n)
        for i := 0; i < n; i++ {
                m[i] = make([]float64, n)
                for j := 0; j < n; j++ {
                        m[i][j] = float64(i*n + j)
                }
        }
        return m
}

func matmult(done chan<- struct{}, A, B, C Matrix, i0, i1, j0, j1, k0, k1, threshold int) {
        di := i1 - i0
        dj := j1 - j0
        dk := k1 - k0
        if di >= dj && di >= dk && di >= threshold {
                // divide in two by y axis
                mi := i0 + di/2
                done1 := make(chan struct{}, 1)
                go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
                matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)
                <-done1
        } else if dj >= dk && dj >= threshold {
                // divide in two by x axis
                mj := j0 + dj/2
                done1 := make(chan struct{}, 1)
                go matmult(done1, A, B, C, i0, i1, j0, mj, k0, k1, threshold)
                matmult(nil, A, B, C, i0, i1, mj, j1, k0, k1, threshold)
                <-done1
        } else if dk >= threshold {
                // divide in two by "k" axis
                // deliberately not parallel because of data races
                mk := k0 + dk/2
                matmult(nil, A, B, C, i0, i1, j0, j1, k0, mk, threshold)
                matmult(nil, A, B, C, i0, i1, j0, j1, mk, k1, threshold)
        } else {
                // the matrices are small enough, compute directly
                for i := i0; i < i1; i++ {
                        for j := j0; j < j1; j++ {
                                for k := k0; k < k1; k++ {
                                        C[i][j] += A[i][k] * B[k][j]
                                }
                        }
                }
        }
        if done != nil {
                done <- struct{}{}
        }
}

func TestStealOrder(t *testing.T) {
        runtime.RunStealOrderTest()
}

func TestLockOSThreadNesting(t *testing.T) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no threads on wasm yet")
        }

        go func() {
                e, i := runtime.LockOSCounts()
                if e != 0 || i != 0 {
                        t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
                        return
                }
                runtime.LockOSThread()
                runtime.LockOSThread()
                runtime.UnlockOSThread()
                e, i = runtime.LockOSCounts()
                if e != 1 || i != 0 {
                        t.Errorf("want locked counts 1, 0; got %d, %d", e, i)
                        return
                }
                runtime.UnlockOSThread()
                e, i = runtime.LockOSCounts()
                if e != 0 || i != 0 {
                        t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
                        return
                }
        }()
}

func TestLockOSThreadExit(t *testing.T) {
        testLockOSThreadExit(t, "testprog")
}

func testLockOSThreadExit(t *testing.T, prog string) {
        output := runTestProg(t, prog, "LockOSThreadMain", "GOMAXPROCS=1")
        want := "OK\n"
        if output != want {
                t.Errorf("want %q, got %q", want, output)
        }

        output = runTestProg(t, prog, "LockOSThreadAlt")
        if output != want {
                t.Errorf("want %q, got %q", want, output)
        }
}

func TestLockOSThreadAvoidsStatePropagation(t *testing.T) {
        want := "OK\n"
        skip := "unshare not permitted\n"
        output := runTestProg(t, "testprog", "LockOSThreadAvoidsStatePropagation", "GOMAXPROCS=1")
        if output == skip {
                t.Skip("unshare syscall not permitted on this system")
        } else if output != want {
                t.Errorf("want %q, got %q", want, output)
        }
}

func TestLockOSThreadTemplateThreadRace(t *testing.T) {
        testenv.MustHaveGoRun(t)

        exe, err := buildTestProg(t, "testprog")
        if err != nil {
                t.Fatal(err)
        }

        iterations := 100
        if testing.Short() {
                // Reduce run time to ~100ms, with much lower probability of
                // catching issues.
                iterations = 5
        }
        for i := 0; i < iterations; i++ {
                want := "OK\n"
                output := runBuiltTestProg(t, exe, "LockOSThreadTemplateThreadRace")
                if output != want {
                        t.Fatalf("run %d: want %q, got %q", i, want, output)
                }
        }
}

// fakeSyscall emulates a system call.
//go:nosplit
func fakeSyscall(duration time.Duration) {
        runtime.Entersyscall()
        for start := runtime.Nanotime(); runtime.Nanotime()-start < int64(duration); {
        }
        runtime.Exitsyscall()
}

// Check that a goroutine will be preempted if it is calling short system calls.
func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) {
        if runtime.GOARCH == "wasm" {
                t.Skip("no preemption on wasm yet")
        }

        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))

        interations := 10
        if testing.Short() {
                interations = 1
        }
        const (
                maxDuration = 5 * time.Second
                nroutines   = 8
        )

        for i := 0; i < interations; i++ {
                c := make(chan bool, nroutines)
                stop := uint32(0)

                start := time.Now()
                for g := 0; g < nroutines; g++ {
                        go func(stop *uint32) {
                                c <- true
                                for atomic.LoadUint32(stop) == 0 {
                                        fakeSyscall(syscallDuration)
                                }
                                c <- true
                        }(&stop)
                }
                // wait until all goroutines have started.
                for g := 0; g < nroutines; g++ {
                        <-c
                }
                atomic.StoreUint32(&stop, 1)
                // wait until all goroutines have finished.
                for g := 0; g < nroutines; g++ {
                        <-c
                }
                duration := time.Since(start)

                if duration > maxDuration {
                        t.Errorf("timeout exceeded: %v (%v)", duration, maxDuration)
                }
        }
}

func TestPreemptionAfterSyscall(t *testing.T) {
        if runtime.GOOS == "plan9" {
                testenv.SkipFlaky(t, 41015)
        }

        for _, i := range []time.Duration{10, 100, 1000} {
                d := i * time.Microsecond
                t.Run(fmt.Sprint(d), func(t *testing.T) {
                        testPreemptionAfterSyscall(t, d)
                })
        }
}

func TestGetgThreadSwitch(t *testing.T) {
        runtime.RunGetgThreadSwitchTest()
}

// TestNetpollBreak tests that netpollBreak can break a netpoll.
// This test is not particularly safe since the call to netpoll
// will pick up any stray files that are ready, but it should work
// OK as long it is not run in parallel.
func TestNetpollBreak(t *testing.T) {
        if runtime.GOMAXPROCS(0) == 1 {
                t.Skip("skipping: GOMAXPROCS=1")
        }

        // Make sure that netpoll is initialized.
        runtime.NetpollGenericInit()

        start := time.Now()
        c := make(chan bool, 2)
        go func() {
                c <- true
                runtime.Netpoll(10 * time.Second.Nanoseconds())
                c <- true
        }()
        <-c
        // Loop because the break might get eaten by the scheduler.
        // Break twice to break both the netpoll we started and the
        // scheduler netpoll.
loop:
        for {
                runtime.Usleep(100)
                runtime.NetpollBreak()
                runtime.NetpollBreak()
                select {
                case <-c:
                        break loop
                default:
                }
        }
        if dur := time.Since(start); dur > 5*time.Second {
                t.Errorf("netpollBreak did not interrupt netpoll: slept for: %v", dur)
        }
}

// TestBigGOMAXPROCS tests that setting GOMAXPROCS to a large value
// doesn't cause a crash at startup. See issue 38474.
func TestBigGOMAXPROCS(t *testing.T) {
        t.Parallel()
        output := runTestProg(t, "testprog", "NonexistentTest", "GOMAXPROCS=1024")
        // Ignore error conditions on small machines.
        for _, errstr := range []string{
                "failed to create new OS thread",
                "cannot allocate memory",
        } {
                if strings.Contains(output, errstr) {
                        t.Skipf("failed to create 1024 threads")
                }
        }
        if !strings.Contains(output, "unknown function: NonexistentTest") {
                t.Errorf("output:\n%s\nwanted:\nunknown function: NonexistentTest", output)
        }
}