src/runtime/proc_test.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package runtime_test
   6
   7 import (
   8         "fmt"
   9         "internal/race"
  10         "internal/testenv"
  11         "math"
  12         "net"
  13         "runtime"
  14         "runtime/debug"
  15         "strings"
  16         "sync"
  17         "sync/atomic"
  18         "syscall"
  19         "testing"
  20         "time"
  21 )
  22
  23 var stop = make(chan bool, 1)
  24
  25 func perpetuumMobile() {
  26         select {
  27         case <-stop:
  28         default:
  29                 go perpetuumMobile()
  30         }
  31 }
  32
  33 func TestStopTheWorldDeadlock(t *testing.T) {
  34         if runtime.GOARCH == "wasm" {
  35                 t.Skip("no preemption on wasm yet")
  36         }
  37         if testing.Short() {
  38                 t.Skip("skipping during short test")
  39         }
  40         maxprocs := runtime.GOMAXPROCS(3)
  41         compl := make(chan bool, 2)
  42         go func() {
  43                 for i := 0; i != 1000; i += 1 {
  44                         runtime.GC()
  45                 }
  46                 compl <- true
  47         }()
  48         go func() {
  49                 for i := 0; i != 1000; i += 1 {
  50                         runtime.GOMAXPROCS(3)
  51                 }
  52                 compl <- true
  53         }()
  54         go perpetuumMobile()
  55         <-compl
  56         <-compl
  57         stop <- true
  58         runtime.GOMAXPROCS(maxprocs)
  59 }
  60
  61 func TestYieldProgress(t *testing.T) {
  62         testYieldProgress(false)
  63 }
  64
  65 func TestYieldLockedProgress(t *testing.T) {
  66         testYieldProgress(true)
  67 }
  68
  69 func testYieldProgress(locked bool) {
  70         c := make(chan bool)
  71         cack := make(chan bool)
  72         go func() {
  73                 if locked {
  74                         runtime.LockOSThread()
  75                 }
  76                 for {
  77                         select {
  78                         case <-c:
  79                                 cack <- true
  80                                 return
  81                         default:
  82                                 runtime.Gosched()
  83                         }
  84                 }
  85         }()
  86         time.Sleep(10 * time.Millisecond)
  87         c <- true
  88         <-cack
  89 }
  90
  91 func TestYieldLocked(t *testing.T) {
  92         const N = 10
  93         c := make(chan bool)
  94         go func() {
  95                 runtime.LockOSThread()
  96                 for i := 0; i < N; i++ {
  97                         runtime.Gosched()
  98                         time.Sleep(time.Millisecond)
  99                 }
 100                 c <- true
 101                 // runtime.UnlockOSThread() is deliberately omitted
 102         }()
 103         <-c
 104 }
 105
 106 func TestGoroutineParallelism(t *testing.T) {
 107         if runtime.NumCPU() == 1 {
 108                 // Takes too long, too easy to deadlock, etc.
 109                 t.Skip("skipping on uniprocessor")
 110         }
 111         P := 4
 112         N := 10
 113         if testing.Short() {
 114                 P = 3
 115                 N = 3
 116         }
 117         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
 118         // If runtime triggers a forced GC during this test then it will deadlock,
 119         // since the goroutines can't be stopped/preempted.
 120         // Disable GC for this test (see issue #10958).
 121         defer debug.SetGCPercent(debug.SetGCPercent(-1))
 122         // SetGCPercent waits until the mark phase is over, but the runtime
 123         // also preempts at the start of the sweep phase, so make sure that's
 124         // done too. See #45867.
 125         runtime.GC()
 126         for try := 0; try < N; try++ {
 127                 done := make(chan bool)
 128                 x := uint32(0)
 129                 for p := 0; p < P; p++ {
 130                         // Test that all P goroutines are scheduled at the same time
 131                         go func(p int) {
 132                                 for i := 0; i < 3; i++ {
 133                                         expected := uint32(P*i + p)
 134                                         for atomic.LoadUint32(&x) != expected {
 135                                         }
 136                                         atomic.StoreUint32(&x, expected+1)
 137                                 }
 138                                 done <- true
 139                         }(p)
 140                 }
 141                 for p := 0; p < P; p++ {
 142                         <-done
 143                 }
 144         }
 145 }
 146
 147 // Test that all runnable goroutines are scheduled at the same time.
 148 func TestGoroutineParallelism2(t *testing.T) {
 149         //testGoroutineParallelism2(t, false, false)
 150         testGoroutineParallelism2(t, true, false)
 151         testGoroutineParallelism2(t, false, true)
 152         testGoroutineParallelism2(t, true, true)
 153 }
 154
 155 func testGoroutineParallelism2(t *testing.T, load, netpoll bool) {
 156         if runtime.NumCPU() == 1 {
 157                 // Takes too long, too easy to deadlock, etc.
 158                 t.Skip("skipping on uniprocessor")
 159         }
 160         P := 4
 161         N := 10
 162         if testing.Short() {
 163                 N = 3
 164         }
 165         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
 166         // If runtime triggers a forced GC during this test then it will deadlock,
 167         // since the goroutines can't be stopped/preempted.
 168         // Disable GC for this test (see issue #10958).
 169         defer debug.SetGCPercent(debug.SetGCPercent(-1))
 170         // SetGCPercent waits until the mark phase is over, but the runtime
 171         // also preempts at the start of the sweep phase, so make sure that's
 172         // done too. See #45867.
 173         runtime.GC()
 174         for try := 0; try < N; try++ {
 175                 if load {
 176                         // Create P goroutines and wait until they all run.
 177                         // When we run the actual test below, worker threads
 178                         // running the goroutines will start parking.
 179                         done := make(chan bool)
 180                         x := uint32(0)
 181                         for p := 0; p < P; p++ {
 182                                 go func() {
 183                                         if atomic.AddUint32(&x, 1) == uint32(P) {
 184                                                 done <- true
 185                                                 return
 186                                         }
 187                                         for atomic.LoadUint32(&x) != uint32(P) {
 188                                         }
 189                                 }()
 190                         }
 191                         <-done
 192                 }
 193                 if netpoll {
 194                         // Enable netpoller, affects schedler behavior.
 195                         laddr := "localhost:0"
 196                         if runtime.GOOS == "android" {
 197                                 // On some Android devices, there are no records for localhost,
 198                                 // see https://golang.org/issues/14486.
 199                                 // Don't use 127.0.0.1 for every case, it won't work on IPv6-only systems.
 200                                 laddr = "127.0.0.1:0"
 201                         }
 202                         ln, err := net.Listen("tcp", laddr)
 203                         if err != nil {
 204                                 defer ln.Close() // yup, defer in a loop
 205                         }
 206                 }
 207                 done := make(chan bool)
 208                 x := uint32(0)
 209                 // Spawn P goroutines in a nested fashion just to differ from TestGoroutineParallelism.
 210                 for p := 0; p < P/2; p++ {
 211                         go func(p int) {
 212                                 for p2 := 0; p2 < 2; p2++ {
 213                                         go func(p2 int) {
 214                                                 for i := 0; i < 3; i++ {
 215                                                         expected := uint32(P*i + p*2 + p2)
 216                                                         for atomic.LoadUint32(&x) != expected {
 217                                                         }
 218                                                         atomic.StoreUint32(&x, expected+1)
 219                                                 }
 220                                                 done <- true
 221                                         }(p2)
 222                                 }
 223                         }(p)
 224                 }
 225                 for p := 0; p < P; p++ {
 226                         <-done
 227                 }
 228         }
 229 }
 230
 231 func TestBlockLocked(t *testing.T) {
 232         const N = 10
 233         c := make(chan bool)
 234         go func() {
 235                 runtime.LockOSThread()
 236                 for i := 0; i < N; i++ {
 237                         c <- true
 238                 }
 239                 runtime.UnlockOSThread()
 240         }()
 241         for i := 0; i < N; i++ {
 242                 <-c
 243         }
 244 }
 245
 246 func TestTimerFairness(t *testing.T) {
 247         if runtime.GOARCH == "wasm" {
 248                 t.Skip("no preemption on wasm yet")
 249         }
 250
 251         done := make(chan bool)
 252         c := make(chan bool)
 253         for i := 0; i < 2; i++ {
 254                 go func() {
 255                         for {
 256                                 select {
 257                                 case c <- true:
 258                                 case <-done:
 259                                         return
 260                                 }
 261                         }
 262                 }()
 263         }
 264
 265         timer := time.After(20 * time.Millisecond)
 266         for {
 267                 select {
 268                 case <-c:
 269                 case <-timer:
 270                         close(done)
 271                         return
 272                 }
 273         }
 274 }
 275
 276 func TestTimerFairness2(t *testing.T) {
 277         if runtime.GOARCH == "wasm" {
 278                 t.Skip("no preemption on wasm yet")
 279         }
 280
 281         done := make(chan bool)
 282         c := make(chan bool)
 283         for i := 0; i < 2; i++ {
 284                 go func() {
 285                         timer := time.After(20 * time.Millisecond)
 286                         var buf [1]byte
 287                         for {
 288                                 syscall.Read(0, buf[0:0])
 289                                 select {
 290                                 case c <- true:
 291                                 case <-c:
 292                                 case <-timer:
 293                                         done <- true
 294                                         return
 295                                 }
 296                         }
 297                 }()
 298         }
 299         <-done
 300         <-done
 301 }
 302
 303 // The function is used to test preemption at split stack checks.
 304 // Declaring a var avoids inlining at the call site.
 305 var preempt = func() int {
 306         var a [128]int
 307         sum := 0
 308         for _, v := range a {
 309                 sum += v
 310         }
 311         return sum
 312 }
 313
 314 func TestPreemption(t *testing.T) {
 315         if runtime.GOARCH == "wasm" {
 316                 t.Skip("no preemption on wasm yet")
 317         }
 318
 319         // Test that goroutines are preempted at function calls.
 320         N := 5
 321         if testing.Short() {
 322                 N = 2
 323         }
 324         c := make(chan bool)
 325         var x uint32
 326         for g := 0; g < 2; g++ {
 327                 go func(g int) {
 328                         for i := 0; i < N; i++ {
 329                                 for atomic.LoadUint32(&x) != uint32(g) {
 330                                         preempt()
 331                                 }
 332                                 atomic.StoreUint32(&x, uint32(1-g))
 333                         }
 334                         c <- true
 335                 }(g)
 336         }
 337         <-c
 338         <-c
 339 }
 340
 341 func TestPreemptionGC(t *testing.T) {
 342         if runtime.GOARCH == "wasm" {
 343                 t.Skip("no preemption on wasm yet")
 344         }
 345
 346         // Test that pending GC preempts running goroutines.
 347         P := 5
 348         N := 10
 349         if testing.Short() {
 350                 P = 3
 351                 N = 2
 352         }
 353         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P + 1))
 354         var stop uint32
 355         for i := 0; i < P; i++ {
 356                 go func() {
 357                         for atomic.LoadUint32(&stop) == 0 {
 358                                 preempt()
 359                         }
 360                 }()
 361         }
 362         for i := 0; i < N; i++ {
 363                 runtime.Gosched()
 364                 runtime.GC()
 365         }
 366         atomic.StoreUint32(&stop, 1)
 367 }
 368
 369 func TestAsyncPreempt(t *testing.T) {
 370         if !runtime.PreemptMSupported {
 371                 t.Skip("asynchronous preemption not supported on this platform")
 372         }
 373         output := runTestProg(t, "testprog", "AsyncPreempt")
 374         want := "OK\n"
 375         if output != want {
 376                 t.Fatalf("want %s, got %s\n", want, output)
 377         }
 378 }
 379
 380 func TestGCFairness(t *testing.T) {
 381         output := runTestProg(t, "testprog", "GCFairness")
 382         want := "OK\n"
 383         if output != want {
 384                 t.Fatalf("want %s, got %s\n", want, output)
 385         }
 386 }
 387
 388 func TestGCFairness2(t *testing.T) {
 389         output := runTestProg(t, "testprog", "GCFairness2")
 390         want := "OK\n"
 391         if output != want {
 392                 t.Fatalf("want %s, got %s\n", want, output)
 393         }
 394 }
 395
 396 func TestNumGoroutine(t *testing.T) {
 397         output := runTestProg(t, "testprog", "NumGoroutine")
 398         want := "1\n"
 399         if output != want {
 400                 t.Fatalf("want %q, got %q", want, output)
 401         }
 402
 403         buf := make([]byte, 1<<20)
 404
 405         // Try up to 10 times for a match before giving up.
 406         // This is a fundamentally racy check but it's important
 407         // to notice if NumGoroutine and Stack are _always_ out of sync.
 408         for i := 0; ; i++ {
 409                 // Give goroutines about to exit a chance to exit.
 410                 // The NumGoroutine and Stack below need to see
 411                 // the same state of the world, so anything we can do
 412                 // to keep it quiet is good.
 413                 runtime.Gosched()
 414
 415                 n := runtime.NumGoroutine()
 416                 buf = buf[:runtime.Stack(buf, true)]
 417
 418                 // To avoid double-counting "goroutine" in "goroutine $m [running]:"
 419                 // and "created by $func in goroutine $n", remove the latter
 420                 output := strings.ReplaceAll(string(buf), "in goroutine", "")
 421                 nstk := strings.Count(output, "goroutine ")
 422                 if n == nstk {
 423                         break
 424                 }
 425                 if i >= 10 {
 426                         t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump: %s", n, nstk, buf)
 427                 }
 428         }
 429 }
 430
 431 func TestPingPongHog(t *testing.T) {
 432         if runtime.GOARCH == "wasm" {
 433                 t.Skip("no preemption on wasm yet")
 434         }
 435         if testing.Short() {
 436                 t.Skip("skipping in -short mode")
 437         }
 438         if race.Enabled {
 439                 // The race detector randomizes the scheduler,
 440                 // which causes this test to fail (#38266).
 441                 t.Skip("skipping in -race mode")
 442         }
 443
 444         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
 445         done := make(chan bool)
 446         hogChan, lightChan := make(chan bool), make(chan bool)
 447         hogCount, lightCount := 0, 0
 448
 449         run := func(limit int, counter *int, wake chan bool) {
 450                 for {
 451                         select {
 452                         case <-done:
 453                                 return
 454
 455                         case <-wake:
 456                                 for i := 0; i < limit; i++ {
 457                                         *counter++
 458                                 }
 459                                 wake <- true
 460                         }
 461                 }
 462         }
 463
 464         // Start two co-scheduled hog goroutines.
 465         for i := 0; i < 2; i++ {
 466                 go run(1e6, &hogCount, hogChan)
 467         }
 468
 469         // Start two co-scheduled light goroutines.
 470         for i := 0; i < 2; i++ {
 471                 go run(1e3, &lightCount, lightChan)
 472         }
 473
 474         // Start goroutine pairs and wait for a few preemption rounds.
 475         hogChan <- true
 476         lightChan <- true
 477         time.Sleep(100 * time.Millisecond)
 478         close(done)
 479         <-hogChan
 480         <-lightChan
 481
 482         // Check that hogCount and lightCount are within a factor of
 483         // 20, which indicates that both pairs of goroutines handed off
 484         // the P within a time-slice to their buddy. We can use a
 485         // fairly large factor here to make this robust: if the
 486         // scheduler isn't working right, the gap should be ~1000X
 487         // (was 5, increased to 20, see issue 52207).
 488         const factor = 20
 489         if hogCount/factor > lightCount || lightCount/factor > hogCount {
 490                 t.Fatalf("want hogCount/lightCount in [%v, %v]; got %d/%d = %g", 1.0/factor, factor, hogCount, lightCount, float64(hogCount)/float64(lightCount))
 491         }
 492 }
 493
 494 func BenchmarkPingPongHog(b *testing.B) {
 495         if b.N == 0 {
 496                 return
 497         }
 498         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
 499
 500         // Create a CPU hog
 501         stop, done := make(chan bool), make(chan bool)
 502         go func() {
 503                 for {
 504                         select {
 505                         case <-stop:
 506                                 done <- true
 507                                 return
 508                         default:
 509                         }
 510                 }
 511         }()
 512
 513         // Ping-pong b.N times
 514         ping, pong := make(chan bool), make(chan bool)
 515         go func() {
 516                 for j := 0; j < b.N; j++ {
 517                         pong <- <-ping
 518                 }
 519                 close(stop)
 520                 done <- true
 521         }()
 522         go func() {
 523                 for i := 0; i < b.N; i++ {
 524                         ping <- <-pong
 525                 }
 526                 done <- true
 527         }()
 528         b.ResetTimer()
 529         ping <- true // Start ping-pong
 530         <-stop
 531         b.StopTimer()
 532         <-ping // Let last ponger exit
 533         <-done // Make sure goroutines exit
 534         <-done
 535         <-done
 536 }
 537
 538 var padData [128]uint64
 539
 540 func stackGrowthRecursive(i int) {
 541         var pad [128]uint64
 542         pad = padData
 543         for j := range pad {
 544                 if pad[j] != 0 {
 545                         return
 546                 }
 547         }
 548         if i != 0 {
 549                 stackGrowthRecursive(i - 1)
 550         }
 551 }
 552
 553 func TestPreemptSplitBig(t *testing.T) {
 554         if testing.Short() {
 555                 t.Skip("skipping in -short mode")
 556         }
 557         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
 558         stop := make(chan int)
 559         go big(stop)
 560         for i := 0; i < 3; i++ {
 561                 time.Sleep(10 * time.Microsecond) // let big start running
 562                 runtime.GC()
 563         }
 564         close(stop)
 565 }
 566
 567 func big(stop chan int) int {
 568         n := 0
 569         for {
 570                 // delay so that gc is sure to have asked for a preemption
 571                 for i := 0; i < 1e9; i++ {
 572                         n++
 573                 }
 574
 575                 // call bigframe, which used to miss the preemption in its prologue.
 576                 bigframe(stop)
 577
 578                 // check if we've been asked to stop.
 579                 select {
 580                 case <-stop:
 581                         return n
 582                 }
 583         }
 584 }
 585
 586 func bigframe(stop chan int) int {
 587         // not splitting the stack will overflow.
 588         // small will notice that it needs a stack split and will
 589         // catch the overflow.
 590         var x [8192]byte
 591         return small(stop, &x)
 592 }
 593
 594 func small(stop chan int, x *[8192]byte) int {
 595         for i := range x {
 596                 x[i] = byte(i)
 597         }
 598         sum := 0
 599         for i := range x {
 600                 sum += int(x[i])
 601         }
 602
 603         // keep small from being a leaf function, which might
 604         // make it not do any stack check at all.
 605         nonleaf(stop)
 606
 607         return sum
 608 }
 609
 610 func nonleaf(stop chan int) bool {
 611         // do something that won't be inlined:
 612         select {
 613         case <-stop:
 614                 return true
 615         default:
 616                 return false
 617         }
 618 }
 619
 620 func TestSchedLocalQueue(t *testing.T) {
 621         runtime.RunSchedLocalQueueTest()
 622 }
 623
 624 func TestSchedLocalQueueSteal(t *testing.T) {
 625         runtime.RunSchedLocalQueueStealTest()
 626 }
 627
 628 func TestSchedLocalQueueEmpty(t *testing.T) {
 629         if runtime.NumCPU() == 1 {
 630                 // Takes too long and does not trigger the race.
 631                 t.Skip("skipping on uniprocessor")
 632         }
 633         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
 634
 635         // If runtime triggers a forced GC during this test then it will deadlock,
 636         // since the goroutines can't be stopped/preempted during spin wait.
 637         defer debug.SetGCPercent(debug.SetGCPercent(-1))
 638         // SetGCPercent waits until the mark phase is over, but the runtime
 639         // also preempts at the start of the sweep phase, so make sure that's
 640         // done too. See #45867.
 641         runtime.GC()
 642
 643         iters := int(1e5)
 644         if testing.Short() {
 645                 iters = 1e2
 646         }
 647         runtime.RunSchedLocalQueueEmptyTest(iters)
 648 }
 649
 650 func benchmarkStackGrowth(b *testing.B, rec int) {
 651         b.RunParallel(func(pb *testing.PB) {
 652                 for pb.Next() {
 653                         stackGrowthRecursive(rec)
 654                 }
 655         })
 656 }
 657
 658 func BenchmarkStackGrowth(b *testing.B) {
 659         benchmarkStackGrowth(b, 10)
 660 }
 661
 662 func BenchmarkStackGrowthDeep(b *testing.B) {
 663         benchmarkStackGrowth(b, 1024)
 664 }
 665
 666 func BenchmarkCreateGoroutines(b *testing.B) {
 667         benchmarkCreateGoroutines(b, 1)
 668 }
 669
 670 func BenchmarkCreateGoroutinesParallel(b *testing.B) {
 671         benchmarkCreateGoroutines(b, runtime.GOMAXPROCS(-1))
 672 }
 673
 674 func benchmarkCreateGoroutines(b *testing.B, procs int) {
 675         c := make(chan bool)
 676         var f func(n int)
 677         f = func(n int) {
 678                 if n == 0 {
 679                         c <- true
 680                         return
 681                 }
 682                 go f(n - 1)
 683         }
 684         for i := 0; i < procs; i++ {
 685                 go f(b.N / procs)
 686         }
 687         for i := 0; i < procs; i++ {
 688                 <-c
 689         }
 690 }
 691
 692 func BenchmarkCreateGoroutinesCapture(b *testing.B) {
 693         b.ReportAllocs()
 694         for i := 0; i < b.N; i++ {
 695                 const N = 4
 696                 var wg sync.WaitGroup
 697                 wg.Add(N)
 698                 for i := 0; i < N; i++ {
 699                         i := i
 700                         go func() {
 701                                 if i >= N {
 702                                         b.Logf("bad") // just to capture b
 703                                 }
 704                                 wg.Done()
 705                         }()
 706                 }
 707                 wg.Wait()
 708         }
 709 }
 710
 711 // warmupScheduler ensures the scheduler has at least targetThreadCount threads
 712 // in its thread pool.
 713 func warmupScheduler(targetThreadCount int) {
 714         var wg sync.WaitGroup
 715         var count int32
 716         for i := 0; i < targetThreadCount; i++ {
 717                 wg.Add(1)
 718                 go func() {
 719                         atomic.AddInt32(&count, 1)
 720                         for atomic.LoadInt32(&count) < int32(targetThreadCount) {
 721                                 // spin until all threads started
 722                         }
 723
 724                         // spin a bit more to ensure they are all running on separate CPUs.
 725                         doWork(time.Millisecond)
 726                         wg.Done()
 727                 }()
 728         }
 729         wg.Wait()
 730 }
 731
 732 func doWork(dur time.Duration) {
 733         start := time.Now()
 734         for time.Since(start) < dur {
 735         }
 736 }
 737
 738 // BenchmarkCreateGoroutinesSingle creates many goroutines, all from a single
 739 // producer (the main benchmark goroutine).
 740 //
 741 // Compared to BenchmarkCreateGoroutines, this causes different behavior in the
 742 // scheduler because Ms are much more likely to need to steal work from the
 743 // main P rather than having work in the local run queue.
 744 func BenchmarkCreateGoroutinesSingle(b *testing.B) {
 745         // Since we are interested in stealing behavior, warm the scheduler to
 746         // get all the Ps running first.
 747         warmupScheduler(runtime.GOMAXPROCS(0))
 748         b.ResetTimer()
 749
 750         var wg sync.WaitGroup
 751         wg.Add(b.N)
 752         for i := 0; i < b.N; i++ {
 753                 go func() {
 754                         wg.Done()
 755                 }()
 756         }
 757         wg.Wait()
 758 }
 759
 760 func BenchmarkClosureCall(b *testing.B) {
 761         sum := 0
 762         off1 := 1
 763         for i := 0; i < b.N; i++ {
 764                 off2 := 2
 765                 func() {
 766                         sum += i + off1 + off2
 767                 }()
 768         }
 769         _ = sum
 770 }
 771
 772 func benchmarkWakeupParallel(b *testing.B, spin func(time.Duration)) {
 773         if runtime.GOMAXPROCS(0) == 1 {
 774                 b.Skip("skipping: GOMAXPROCS=1")
 775         }
 776
 777         wakeDelay := 5 * time.Microsecond
 778         for _, delay := range []time.Duration{
 779                 0,
 780                 1 * time.Microsecond,
 781                 2 * time.Microsecond,
 782                 5 * time.Microsecond,
 783                 10 * time.Microsecond,
 784                 20 * time.Microsecond,
 785                 50 * time.Microsecond,
 786                 100 * time.Microsecond,
 787         } {
 788                 b.Run(delay.String(), func(b *testing.B) {
 789                         if b.N == 0 {
 790                                 return
 791                         }
 792                         // Start two goroutines, which alternate between being
 793                         // sender and receiver in the following protocol:
 794                         //
 795                         // - The receiver spins for `delay` and then does a
 796                         // blocking receive on a channel.
 797                         //
 798                         // - The sender spins for `delay+wakeDelay` and then
 799                         // sends to the same channel. (The addition of
 800                         // `wakeDelay` improves the probability that the
 801                         // receiver will be blocking when the send occurs when
 802                         // the goroutines execute in parallel.)
 803                         //
 804                         // In each iteration of the benchmark, each goroutine
 805                         // acts once as sender and once as receiver, so each
 806                         // goroutine spins for delay twice.
 807                         //
 808                         // BenchmarkWakeupParallel is used to estimate how
 809                         // efficiently the scheduler parallelizes goroutines in
 810                         // the presence of blocking:
 811                         //
 812                         // - If both goroutines are executed on the same core,
 813                         // an increase in delay by N will increase the time per
 814                         // iteration by 4*N, because all 4 delays are
 815                         // serialized.
 816                         //
 817                         // - Otherwise, an increase in delay by N will increase
 818                         // the time per iteration by 2*N, and the time per
 819                         // iteration is 2 * (runtime overhead + chan
 820                         // send/receive pair + delay + wakeDelay). This allows
 821                         // the runtime overhead, including the time it takes
 822                         // for the unblocked goroutine to be scheduled, to be
 823                         // estimated.
 824                         ping, pong := make(chan struct{}), make(chan struct{})
 825                         start := make(chan struct{})
 826                         done := make(chan struct{})
 827                         go func() {
 828                                 <-start
 829                                 for i := 0; i < b.N; i++ {
 830                                         // sender
 831                                         spin(delay + wakeDelay)
 832                                         ping <- struct{}{}
 833                                         // receiver
 834                                         spin(delay)
 835                                         <-pong
 836                                 }
 837                                 done <- struct{}{}
 838                         }()
 839                         go func() {
 840                                 for i := 0; i < b.N; i++ {
 841                                         // receiver
 842                                         spin(delay)
 843                                         <-ping
 844                                         // sender
 845                                         spin(delay + wakeDelay)
 846                                         pong <- struct{}{}
 847                                 }
 848                                 done <- struct{}{}
 849                         }()
 850                         b.ResetTimer()
 851                         start <- struct{}{}
 852                         <-done
 853                         <-done
 854                 })
 855         }
 856 }
 857
 858 func BenchmarkWakeupParallelSpinning(b *testing.B) {
 859         benchmarkWakeupParallel(b, func(d time.Duration) {
 860                 end := time.Now().Add(d)
 861                 for time.Now().Before(end) {
 862                         // do nothing
 863                 }
 864         })
 865 }
 866
 867 // sysNanosleep is defined by OS-specific files (such as runtime_linux_test.go)
 868 // to sleep for the given duration. If nil, dependent tests are skipped.
 869 // The implementation should invoke a blocking system call and not
 870 // call time.Sleep, which would deschedule the goroutine.
 871 var sysNanosleep func(d time.Duration)
 872
 873 func BenchmarkWakeupParallelSyscall(b *testing.B) {
 874         if sysNanosleep == nil {
 875                 b.Skipf("skipping on %v; sysNanosleep not defined", runtime.GOOS)
 876         }
 877         benchmarkWakeupParallel(b, func(d time.Duration) {
 878                 sysNanosleep(d)
 879         })
 880 }
 881
 882 type Matrix [][]float64
 883
 884 func BenchmarkMatmult(b *testing.B) {
 885         b.StopTimer()
 886         // matmult is O(N**3) but testing expects O(b.N),
 887         // so we need to take cube root of b.N
 888         n := int(math.Cbrt(float64(b.N))) + 1
 889         A := makeMatrix(n)
 890         B := makeMatrix(n)
 891         C := makeMatrix(n)
 892         b.StartTimer()
 893         matmult(nil, A, B, C, 0, n, 0, n, 0, n, 8)
 894 }
 895
 896 func makeMatrix(n int) Matrix {
 897         m := make(Matrix, n)
 898         for i := 0; i < n; i++ {
 899                 m[i] = make([]float64, n)
 900                 for j := 0; j < n; j++ {
 901                         m[i][j] = float64(i*n + j)
 902                 }
 903         }
 904         return m
 905 }
 906
 907 func matmult(done chan<- struct{}, A, B, C Matrix, i0, i1, j0, j1, k0, k1, threshold int) {
 908         di := i1 - i0
 909         dj := j1 - j0
 910         dk := k1 - k0
 911         if di >= dj && di >= dk && di >= threshold {
 912                 // divide in two by y axis
 913                 mi := i0 + di/2
 914                 done1 := make(chan struct{}, 1)
 915                 go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
 916                 matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)
 917                 <-done1
 918         } else if dj >= dk && dj >= threshold {
 919                 // divide in two by x axis
 920                 mj := j0 + dj/2
 921                 done1 := make(chan struct{}, 1)
 922                 go matmult(done1, A, B, C, i0, i1, j0, mj, k0, k1, threshold)
 923                 matmult(nil, A, B, C, i0, i1, mj, j1, k0, k1, threshold)
 924                 <-done1
 925         } else if dk >= threshold {
 926                 // divide in two by "k" axis
 927                 // deliberately not parallel because of data races
 928                 mk := k0 + dk/2
 929                 matmult(nil, A, B, C, i0, i1, j0, j1, k0, mk, threshold)
 930                 matmult(nil, A, B, C, i0, i1, j0, j1, mk, k1, threshold)
 931         } else {
 932                 // the matrices are small enough, compute directly
 933                 for i := i0; i < i1; i++ {
 934                         for j := j0; j < j1; j++ {
 935                                 for k := k0; k < k1; k++ {
 936                                         C[i][j] += A[i][k] * B[k][j]
 937                                 }
 938                         }
 939                 }
 940         }
 941         if done != nil {
 942                 done <- struct{}{}
 943         }
 944 }
 945
 946 func TestStealOrder(t *testing.T) {
 947         runtime.RunStealOrderTest()
 948 }
 949
 950 func TestLockOSThreadNesting(t *testing.T) {
 951         if runtime.GOARCH == "wasm" {
 952                 t.Skip("no threads on wasm yet")
 953         }
 954
 955         go func() {
 956                 e, i := runtime.LockOSCounts()
 957                 if e != 0 || i != 0 {
 958                         t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
 959                         return
 960                 }
 961                 runtime.LockOSThread()
 962                 runtime.LockOSThread()
 963                 runtime.UnlockOSThread()
 964                 e, i = runtime.LockOSCounts()
 965                 if e != 1 || i != 0 {
 966                         t.Errorf("want locked counts 1, 0; got %d, %d", e, i)
 967                         return
 968                 }
 969                 runtime.UnlockOSThread()
 970                 e, i = runtime.LockOSCounts()
 971                 if e != 0 || i != 0 {
 972                         t.Errorf("want locked counts 0, 0; got %d, %d", e, i)
 973                         return
 974                 }
 975         }()
 976 }
 977
 978 func TestLockOSThreadExit(t *testing.T) {
 979         testLockOSThreadExit(t, "testprog")
 980 }
 981
 982 func testLockOSThreadExit(t *testing.T, prog string) {
 983         output := runTestProg(t, prog, "LockOSThreadMain", "GOMAXPROCS=1")
 984         want := "OK\n"
 985         if output != want {
 986                 t.Errorf("want %q, got %q", want, output)
 987         }
 988
 989         output = runTestProg(t, prog, "LockOSThreadAlt")
 990         if output != want {
 991                 t.Errorf("want %q, got %q", want, output)
 992         }
 993 }
 994
 995 func TestLockOSThreadAvoidsStatePropagation(t *testing.T) {
 996         want := "OK\n"
 997         skip := "unshare not permitted\n"
 998         output := runTestProg(t, "testprog", "LockOSThreadAvoidsStatePropagation", "GOMAXPROCS=1")
 999         if output == skip {
1000                 t.Skip("unshare syscall not permitted on this system")
1001         } else if output != want {
1002                 t.Errorf("want %q, got %q", want, output)
1003         }
1004 }
1005
1006 func TestLockOSThreadTemplateThreadRace(t *testing.T) {
1007         testenv.MustHaveGoRun(t)
1008
1009         exe, err := buildTestProg(t, "testprog")
1010         if err != nil {
1011                 t.Fatal(err)
1012         }
1013
1014         iterations := 100
1015         if testing.Short() {
1016                 // Reduce run time to ~100ms, with much lower probability of
1017                 // catching issues.
1018                 iterations = 5
1019         }
1020         for i := 0; i < iterations; i++ {
1021                 want := "OK\n"
1022                 output := runBuiltTestProg(t, exe, "LockOSThreadTemplateThreadRace")
1023                 if output != want {
1024                         t.Fatalf("run %d: want %q, got %q", i, want, output)
1025                 }
1026         }
1027 }
1028
1029 // fakeSyscall emulates a system call.
1030 //
1031 //go:nosplit
1032 func fakeSyscall(duration time.Duration) {
1033         runtime.Entersyscall()
1034         for start := runtime.Nanotime(); runtime.Nanotime()-start < int64(duration); {
1035         }
1036         runtime.Exitsyscall()
1037 }
1038
1039 // Check that a goroutine will be preempted if it is calling short system calls.
1040 func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) {
1041         if runtime.GOARCH == "wasm" {
1042                 t.Skip("no preemption on wasm yet")
1043         }
1044
1045         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
1046
1047         iterations := 10
1048         if testing.Short() {
1049                 iterations = 1
1050         }
1051         const (
1052                 maxDuration = 5 * time.Second
1053                 nroutines   = 8
1054         )
1055
1056         for i := 0; i < iterations; i++ {
1057                 c := make(chan bool, nroutines)
1058                 stop := uint32(0)
1059
1060                 start := time.Now()
1061                 for g := 0; g < nroutines; g++ {
1062                         go func(stop *uint32) {
1063                                 c <- true
1064                                 for atomic.LoadUint32(stop) == 0 {
1065                                         fakeSyscall(syscallDuration)
1066                                 }
1067                                 c <- true
1068                         }(&stop)
1069                 }
1070                 // wait until all goroutines have started.
1071                 for g := 0; g < nroutines; g++ {
1072                         <-c
1073                 }
1074                 atomic.StoreUint32(&stop, 1)
1075                 // wait until all goroutines have finished.
1076                 for g := 0; g < nroutines; g++ {
1077                         <-c
1078                 }
1079                 duration := time.Since(start)
1080
1081                 if duration > maxDuration {
1082                         t.Errorf("timeout exceeded: %v (%v)", duration, maxDuration)
1083                 }
1084         }
1085 }
1086
1087 func TestPreemptionAfterSyscall(t *testing.T) {
1088         if runtime.GOOS == "plan9" {
1089                 testenv.SkipFlaky(t, 41015)
1090         }
1091
1092         for _, i := range []time.Duration{10, 100, 1000} {
1093                 d := i * time.Microsecond
1094                 t.Run(fmt.Sprint(d), func(t *testing.T) {
1095                         testPreemptionAfterSyscall(t, d)
1096                 })
1097         }
1098 }
1099
1100 func TestGetgThreadSwitch(t *testing.T) {
1101         runtime.RunGetgThreadSwitchTest()
1102 }
1103
1104 // TestNetpollBreak tests that netpollBreak can break a netpoll.
1105 // This test is not particularly safe since the call to netpoll
1106 // will pick up any stray files that are ready, but it should work
1107 // OK as long it is not run in parallel.
1108 func TestNetpollBreak(t *testing.T) {
1109         if runtime.GOMAXPROCS(0) == 1 {
1110                 t.Skip("skipping: GOMAXPROCS=1")
1111         }
1112
1113         // Make sure that netpoll is initialized.
1114         runtime.NetpollGenericInit()
1115
1116         start := time.Now()
1117         c := make(chan bool, 2)
1118         go func() {
1119                 c <- true
1120                 runtime.Netpoll(10 * time.Second.Nanoseconds())
1121                 c <- true
1122         }()
1123         <-c
1124         // Loop because the break might get eaten by the scheduler.
1125         // Break twice to break both the netpoll we started and the
1126         // scheduler netpoll.
1127 loop:
1128         for {
1129                 runtime.Usleep(100)
1130                 runtime.NetpollBreak()
1131                 runtime.NetpollBreak()
1132                 select {
1133                 case <-c:
1134                         break loop
1135                 default:
1136                 }
1137         }
1138         if dur := time.Since(start); dur > 5*time.Second {
1139                 t.Errorf("netpollBreak did not interrupt netpoll: slept for: %v", dur)
1140         }
1141 }
1142
1143 // TestBigGOMAXPROCS tests that setting GOMAXPROCS to a large value
1144 // doesn't cause a crash at startup. See issue 38474.
1145 func TestBigGOMAXPROCS(t *testing.T) {
1146         t.Parallel()
1147         output := runTestProg(t, "testprog", "NonexistentTest", "GOMAXPROCS=1024")
1148         // Ignore error conditions on small machines.
1149         for _, errstr := range []string{
1150                 "failed to create new OS thread",
1151                 "cannot allocate memory",
1152         } {
1153                 if strings.Contains(output, errstr) {
1154                         t.Skipf("failed to create 1024 threads")
1155                 }
1156         }
1157         if !strings.Contains(output, "unknown function: NonexistentTest") {
1158                 t.Errorf("output:\n%s\nwanted:\nunknown function: NonexistentTest", output)
1159         }
1160 }