go/src/runtime/proc_test.go

var stop …

func perpetuumMobile() { … }

func TestStopTheWorldDeadlock(t *testing.T) { … }

func TestYieldProgress(t *testing.T) { … }

func TestYieldLockedProgress(t *testing.T) { … }

func testYieldProgress(locked bool) { … }

func TestYieldLocked(t *testing.T) { … }

func TestGoroutineParallelism(t *testing.T) { … }

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

func testGoroutineParallelism2(t *testing.T, load, netpoll bool) { … }

func TestBlockLocked(t *testing.T) { … }

func TestTimerFairness(t *testing.T) { … }

func TestTimerFairness2(t *testing.T) { … }

var preempt …

func TestPreemption(t *testing.T) { … }

func TestPreemptionGC(t *testing.T) { … }

func TestAsyncPreempt(t *testing.T) { … }

func TestGCFairness(t *testing.T) { … }

func TestGCFairness2(t *testing.T) { … }

func TestNumGoroutine(t *testing.T) { … }

func TestPingPongHog(t *testing.T) { … }

func BenchmarkPingPongHog(b *testing.B) { … }

var padData …

func stackGrowthRecursive(i int) { … }

func TestPreemptSplitBig(t *testing.T) { … }

func big(stop chan int) int { … }

func bigframe(stop chan int) int { … }

func small(stop chan int, x *[8192]byte) int { … }

func nonleaf(stop chan int) bool { … }

func TestSchedLocalQueue(t *testing.T) { … }

func TestSchedLocalQueueSteal(t *testing.T) { … }

func TestSchedLocalQueueEmpty(t *testing.T) { … }

func benchmarkStackGrowth(b *testing.B, rec int) { … }

func BenchmarkStackGrowth(b *testing.B) { … }

func BenchmarkStackGrowthDeep(b *testing.B) { … }

func BenchmarkCreateGoroutines(b *testing.B) { … }

func BenchmarkCreateGoroutinesParallel(b *testing.B) { … }

func benchmarkCreateGoroutines(b *testing.B, procs int) { … }

func BenchmarkCreateGoroutinesCapture(b *testing.B) { … }

// warmupScheduler ensures the scheduler has at least targetThreadCount threads
// in its thread pool.
func warmupScheduler(targetThreadCount int) { … }

func doWork(dur time.Duration) { … }

// 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) { … }

func BenchmarkClosureCall(b *testing.B) { … }

func benchmarkWakeupParallel(b *testing.B, spin func(time.Duration)) { … }

func BenchmarkWakeupParallelSpinning(b *testing.B) { … }

var sysNanosleep …

func BenchmarkWakeupParallelSyscall(b *testing.B) { … }

type Matrix …

func BenchmarkMatmult(b *testing.B) { … }

func makeMatrix(n int) Matrix { … }

func matmult(done chan<- struct{ … }

func TestStealOrder(t *testing.T) { … }

func TestLockOSThreadNesting(t *testing.T) { … }

func TestLockOSThreadExit(t *testing.T) { … }

func testLockOSThreadExit(t *testing.T, prog string) { … }

func TestLockOSThreadAvoidsStatePropagation(t *testing.T) { … }

func TestLockOSThreadTemplateThreadRace(t *testing.T) { … }

// fakeSyscall emulates a system call.
//
//go:nosplit
func fakeSyscall(duration time.Duration) { … }

// Check that a goroutine will be preempted if it is calling short system calls.
func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) { … }

func TestPreemptionAfterSyscall(t *testing.T) { … }

func TestGetgThreadSwitch(t *testing.T) { … }

// 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) { … }

// TestBigGOMAXPROCS tests that setting GOMAXPROCS to a large value
// doesn't cause a crash at startup. See issue 38474.
func TestBigGOMAXPROCS(t *testing.T) { … }