《Go 语言运行时原理》2.3 抢占式调度与 sysmon

//go:noinline
func longLoop(iters int) uint64 {
	var x uint64 = 1
	for i := 0; i < iters; i++ {
		x = x*6364136223846793005 + 1442695040888963407
		x ^= x >> 33
	}
	return x
}

func main() {
	runtime.GOMAXPROCS(2)
	const iters = 900_000_000 // 校准到约 1 秒的无调用工作
	go longLoop(iters)
	time.Sleep(50 * time.Millisecond) // 让死循环占住一个 P
	start := time.Now()
	runtime.GC()                      // STW 必须等这个 P 停下来
	fmt.Printf("runtime.GC() wall time = %v\n", time.Since(start))
	os.Exit(0)
}

for i in 1 2 3; do GODEBUG=asyncpreemptoff=0 ./preemptgc; done
for i in 1 2 3; do GODEBUG=asyncpreemptoff=1 ./preemptgc; done

runtime.GC() wall time = 482.125µs
runtime.GC() wall time = 419.416µs
runtime.GC() wall time = 300.083µs
runtime.GC() wall time = 1.81662225s
runtime.GC() wall time = 1.728799292s
runtime.GC() wall time = 1.691802417s

runtime.GOMAXPROCS(1)
r, w, _ := os.Pipe()
var iters atomic.Uint64
go func() { // A：阻塞在 syscall.Read
	buf := make([]byte, 1)
	syscall.Read(int(r.Fd()), buf)
	done <- true
}()
go func() { // B：CPU 工作，必须能推进
	for i := 0; i < 40_000_000; i++ {
		iters.Add(1)
	}
}()
time.Sleep(200 * time.Millisecond)
w.Write([]byte("x")) // 解除 A 的阻塞

./sysmon

GOMAXPROCS=1, B iterations while A in syscall = 40000000

go tool trace -d=footprint trace.out

GoSyscallBegin       53     0.84%   13     5.33%
GoBlock              34     0.54%   8      3.28%
ProcStart            23     0.37%   4      1.64%
GoSyscallEndBlocked  7      0.11%   2      0.82%
ProcStop             4      0.06%   2      0.82%

// src/runtime/proc.go:6648（片段）
if retake(now) != 0 {
	idle = 0
}
// check if we need to force a GC
if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && forcegc.idle.Load() {
	...
}

grep -n "netpoll(0)\|sysmonUpdateGOMAXPROCS\|scavenger.sysmonWake\|retake(now)\|gcTrigger{kind: gcTriggerTime" proc.go

6622:			list, delta := netpoll(0) // non-blocking - returns list of goroutines
6639:			sysmonUpdateGOMAXPROCS()
6642:		if scavenger.sysmonWake.Load() != 0 {
6648:		if retake(now) != 0 {
6654:		if t := (gcTrigger{kind: gcTriggerTime, now: now}); t.test() && forcegc.idle.Load() {

// src/runtime/proc.go:6681（片段）
const forcePreemptNS = 10 * 1000 * 1000 // 10ms
...
schedt := int64(pp.schedtick)
if int64(pd.schedtick) != schedt {
	pd.schedtick = uint32(schedt)
	pd.schedwhen = now
} else if pd.schedwhen+forcePreemptNS <= now {
	preemptone(pp)
	// If pp is in a syscall, preemptone doesn't work.
	sysretake = true
}

// src/runtime/proc.go:6917
func preemptone(pp *p) bool {
	mp := pp.m.ptr()
	if mp == nil || mp == getg().m {
		return false
	}
	gp := mp.curg
	if gp == nil || gp == mp.g0 {
		return false
	}
	if readgstatus(gp)&^_Gscan == _Gsyscall {
		return false // 系统调用中的 G 不抢占，改为夺 P
	}
	gp.preempt = true
	gp.stackguard0 = stackPreempt // 协作式：折叠进栈溢出检查
	if preemptMSupported && debug.asyncpreemptoff == 0 {
		pp.preempt = true
		preemptM(mp) // 异步：给 M 发信号
	}
	return true
}

// src/runtime/signal_unix.go:369（片段）
func preemptM(mp *m) {
	if mp.signalPending.CompareAndSwap(0, 1) {
		// 避免对同一 M 重复发信号造成 live-lock（darwin 上曾出现）
		signalM(mp, sigPreempt)
	}
}

// src/runtime/preempt.go:317（片段）
func asyncPreempt2() {
	mcall(func(gp *g) {
		gp.asyncSafePoint = true
		xRegSave(gp) // 把扩展寄存器状态从 P 挪到 G
		if gp.preemptStop {
			preemptPark(gp)
		} else {
			gopreempt_m(gp)
		}
	})
}