| // 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 ( |
| "math" |
| "runtime" |
| "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 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(t, false) |
| } |
| |
| func TestYieldLockedProgress(t *testing.T) { |
| testYieldProgress(t, true) |
| } |
| |
| func testYieldProgress(t *testing.T, 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) { |
| P := 4 |
| N := 10 |
| if testing.Short() { |
| P = 3 |
| N = 3 |
| } |
| defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P)) |
| 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 |
| } |
| } |
| } |
| |
| 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) { |
| 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) { |
| 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) { |
| // 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) { |
| // 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 TestGCFairness(t *testing.T) { |
| output := executeTest(t, testGCFairnessSource, nil) |
| want := "OK\n" |
| if output != want { |
| t.Fatalf("want %s, got %s\n", want, output) |
| } |
| } |
| |
| const testGCFairnessSource = ` |
| package main |
| |
| import ( |
| "fmt" |
| "os" |
| "runtime" |
| "time" |
| ) |
| |
| func main() { |
| runtime.GOMAXPROCS(1) |
| f, err := os.Open("/dev/null") |
| if os.IsNotExist(err) { |
| // This test tests what it is intended to test only if writes are fast. |
| // If there is no /dev/null, we just don't execute the test. |
| fmt.Println("OK") |
| return |
| } |
| if err != nil { |
| fmt.Println(err) |
| os.Exit(1) |
| } |
| for i := 0; i < 2; i++ { |
| go func() { |
| for { |
| f.Write([]byte(".")) |
| } |
| }() |
| } |
| time.Sleep(10 * time.Millisecond) |
| fmt.Println("OK") |
| } |
| ` |
| |
| func stackGrowthRecursive(i int) { |
| var pad [128]uint64 |
| if i != 0 && pad[0] == 0 { |
| stackGrowthRecursive(i - 1) |
| } |
| } |
| |
| func TestPreemptSplitBig(t *testing.T) { |
| if testing.Short() { |
| t.Skip("skipping in -short mode") |
| } |
| 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.TestSchedLocalQueue1() |
| } |
| |
| func TestSchedLocalQueueSteal(t *testing.T) { |
| runtime.TestSchedLocalQueueSteal1() |
| } |
| |
| 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 |
| } |
| } |
| |
| 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{}{} |
| } |
| } |