Source file src/runtime/proc_test.go

Documentation: runtime

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

View as plain text