runtime/sched: revise for go1.12

Update #3

Author: changkun

content/11-pkg/syscall/syscall.md

@@ -346,8 +346,11 @@ func reentersyscall(pc, sp uintptr) {
 	_g_.m.syscalltick = _g_.m.p.ptr().syscalltick
 	_g_.sysblocktraced = true
 	_g_.m.mcache = nil
-	_g_.m.p.ptr().m = 0
-	atomic.Store(&_g_.m.p.ptr().status, _Psyscall)
+	pp := _g_.m.p.ptr()
+	pp.m = 0
+	_g_.m.oldp.set(pp)
+	_g_.m.p = 0
+	atomic.Store(&pp.status, _Psyscall)
 	if sched.gcwaiting != 0 {
 		systemstack(entersyscall_gcwait)
 		save(pc, sp)
@@ -362,7 +365,7 @@ TODO:
 
 ```go
 //go:nosplit
-func exitsyscallfast() bool {
+func exitsyscallfast(oldp *p) bool {
 	_g_ := getg()
 
 	// Freezetheworld sets stopwait but does not retake P's.
@@ -375,6 +378,7 @@ func exitsyscallfast() bool {
 	// Try to re-acquire the last P.
 	if _g_.m.p != 0 && _g_.m.p.ptr().status == _Psyscall && atomic.Cas(&_g_.m.p.ptr().status, _Psyscall, _Prunning) {
 		// There's a cpu for us, so we can run.
+		wirep(oldp)
 		exitsyscallfast_reacquired()
 		return true
 	}
@@ -427,8 +431,9 @@ func exitsyscall() {
 	}
 
 	_g_.waitsince = 0
-	oldp := _g_.m.p.ptr()
-	if exitsyscallfast() {
+	oldp := _g_.m.oldp.ptr()
+	_g_.m.oldp = 0
+	if exitsyscallfast(oldp) {
 		if _g_.m.mcache == nil {
 			throw("lost mcache")
 		}
@@ -454,6 +459,12 @@ func exitsyscall() {
 			_g_.stackguard0 = _g_.stack.lo + _StackGuard
 		}
 		_g_.throwsplit = false
+
+		if sched.disable.user && !schedEnabled(_g_) {
+			// Scheduling of this goroutine is disabled.
+			Gosched()
+		}
+
 		return
 	}
 

content/3-main.md

@@ -77,8 +77,7 @@ func main() {
 		}
 	}()
 
-	// 记录程序的启动时间，必须在 runtime.init 之后调用
-	// 因为 nanotime 在某些平台上依赖于 startNano。
+	// 记录程序的启动时间
 	runtimeInitTime = nanotime()
 
 	// 启动垃圾回收器后台操作
@@ -196,7 +195,7 @@ func runtime_init()
 		// 有关可用的 cpu 功能的信息。
 		// 在 runtime.cpuinit 中启动时设置。
 		// 运行时之外的包不应使用这些包因为它们不是外部 api。
-		// TODO: deprecate these; use internal/cpu directly.
+		// 启动时在 asm_{386,amd64,amd64p32}.s 中设置
 		processorVersionInfo uint32
 		isIntel              bool
 		lfenceBeforeRdtsc    bool

content/4-sched/basic.md

@@ -97,14 +97,14 @@ type m struct {
 	caughtsig     guintptr // goroutine 在 fatal signal 中运行
 	p             puintptr // attached p for executing go code (nil if not executing go code)
 	nextp         puintptr
+	oldp          puintptr // 执行系统调用之前绑定的 p
 	id            int64
 	mallocing     int32
 	throwing      int32
 	preemptoff    string // 如果不为空串 ""，继续让当前 g 运行在该 M 上
 	locks         int32
 	dying         int32
 	profilehz     int32
-	helpgc        int32
 	spinning      bool // m 当前没有运行 work 且正处于寻找 work 的活跃状态
 	blocked       bool // m 阻塞在一个 note 上
 	inwb          bool // m 正在执行 write barrier
@@ -210,8 +210,10 @@ type p struct {
 	runnext guintptr
 
 	// 有效的 G (状态 == Gdead)
-	gfree    *g
-	gfreecnt int32
+	gfree struct {
+		gList
+		n int32
+	}
 
 	sudogcache []*sudog
 	sudogbuf   [128]*sudog
@@ -247,7 +249,7 @@ type p struct {
 
 	runSafePointFn uint32 // 如果为 1, 则在下一个 safe-point 运行 sched.safePointFn
 
-	pad [sys.CacheLineSize]byte // 无实际用处，只是用于防止 P 的 false sharing
+	pad cpu.CacheLinePad
 }
 ```
 
@@ -404,15 +406,28 @@ type schedt struct {
 	nmspinning uint32   // 见 proc.go 中关于 "工作线程 parking/unparking" 的注释.
 
 	// 全局 runnable G 队列
-	runqhead guintptr
-	runqtail guintptr
+	runq     gQueue
 	runqsize int32
 
+	// disable 控制了选择性的禁止调度器
+	//
+	// 使用 schedEnableUser 来控制此这个
+	//
+	// disable 受到 sched.lock 保护
+	disable struct {
+		// 用户禁用用户 goroutine 的调度
+		user     bool
+		runnable gQueue // 即将发生的 runable Gs
+		n        int32  // runable 的数量
+	}
+
 	// 有效 dead G 的全局缓存.
-	gflock       mutex
-	gfreeStack   *g
-	gfreeNoStack *g
-	ngfree       int32
+	gFree struct {
+		lock    mutex
+		stack   gList // 包含栈的 Gs
+		noStack gList // 没有栈的 Gs
+		n       int32
+	}
 
 	// sudog 结构的集中缓存
 	sudoglock  mutex

content/4-sched/exec.md

@@ -43,8 +43,8 @@ func mstart() {
 	mstart1()
 
 	// 退出线程
-	if GOOS == "windows" || GOOS == "solaris" || GOOS == "plan9" || GOOS == "darwin" {
-		// 由于 windows, solaris, darwin 和 plan9 总是系统分配的栈，在在 mstart 之前放进 _g_.stack 的
+	if GOOS == "windows" || GOOS == "solaris" || GOOS == "plan9" || GOOS == "darwin" || GOOS == "aix" {
+		// 由于 windows, solaris, darwin, aix 和 plan9 总是系统分配的栈，在在 mstart 之前放进 _g_.stack 的
 		// 因此上面的逻辑还没有设置 osStack。
 		osStack = true
 	}
@@ -86,12 +86,8 @@ func mstart1() {
 		fn()
 	}
 
-	// GC startTheWorld 会检查 spinning M 是否少于并发标记需求
-	// 新建 m，设置 m.helpgc = -1，加入闲置队列等待唤醒
-	if _g_.m.helpgc != 0 {
-		_g_.m.helpgc = 0
-		stopm()
-	} else if _g_.m != &m0 {
+	// 如果当前 m 并非 m0，则要求绑定 p
+	if _g_.m != &m0 {
 		// 绑定 p
 		acquirep(_g_.m.nextp.ptr())
 		_g_.m.nextp = 0
@@ -137,27 +133,27 @@ m 与 p 的绑定过程只是简单的将 p 链表中的 p ，保存到 m 中的
 //go:yeswritebarrierrec
 func acquirep(_p_ *p) {
 	// 此处不允许 write barrier
-	acquirep1(_p_)
+	wirep(_p_)
 
 	// 已经获取了 p，因此之后允许 write barrier
-	_g_ := getg()
-
-	// 递交 mcache 给 m
-	_g_.m.mcache = _p_.mcache
+	//
+	// 在 P 可以从一个潜在设置的 mcache 分配前执行偏好的 mcache flush
+	_p_.mcache.prepareForSweep()
 
 	if trace.enabled {
 		traceProcStart()
 	}
 }
-// acquirep1 为 acquirep 的实际获取 p 的第一步。
+// wirep 为 acquirep 的实际获取 p 的第一步，它关联了当前的 M 到 P 上。
 // 之所以进行拆分是因为我们可以为这个部分驳回 write barrier
 //go:nowritebarrierrec
-func acquirep1(_p_ *p) {
+//go:nosplit
+func wirep(_p_ *p) {
 	_g_ := getg()
 
-	// 检查，确实没有 p
+	// 检查 确实没有 p
 	if _g_.m.p != 0 || _g_.m.mcache != nil {
-		throw("acquirep: already in go")
+		throw("wirep: already in go")
 	}
 
 	// 检查 m 是否正常，并检查要获取的 p 的状态
@@ -166,8 +162,8 @@ func acquirep1(_p_ *p) {
 		if _p_.m != 0 {
 			id = _p_.m.ptr().id
 		}
-		print("acquirep: p->m=", _p_.m, "(", id, ") p->status=", _p_.status, "\n")
-		throw("acquirep: invalid p state")
+		print("wirep: p->m=", _p_.m, "(", id, ") p->status=", _p_.status, "\n")
+		throw("wirep: invalid p state")
 	}
 
 	// 正式获取 p
@@ -207,7 +203,6 @@ func stopm() {
 		throw("stopm spinning")
 	}
 
-retry:
 	// 将 m 放回到 空闲列表中，因为我们马上就要 park 了
 	lock(&sched.lock)
 	mput(_g_.m)
@@ -219,17 +214,6 @@ retry:
 	// 清除 unpark 的 note
 	noteclear(&_g_.m.park)
 
-	// 如果需要 helpgc
-	if _g_.m.helpgc != 0 {
-		// helpgc() 会设置 _g_.m.p 与 _g_.m.mcache，因此我们会 acquire 一个 P 进行
-		gchelper()
-		// 撤销 helpgc() 的影响
-		_g_.m.helpgc = 0
-		_g_.m.mcache = nil
-		_g_.m.p = 0
-		goto retry
-	}
-
 	// 此时已经被 unpark，说明有任务要执行
 	// 立即 acquire P
 	acquirep(_g_.m.nextp.ptr())
@@ -238,10 +222,7 @@ retry:
 ```
 
 它的流程也非常简单，将 m 放回至空闲列表中，而后使用 note 注册一个 park 通知，
-阻塞到它重新被 unpark；如果在阻塞结束后，恰好需要 helpgc，则会重新被阻塞。
-
-至此，可以看出 helpgc 已经对 m 的 park/unpark 以及 mstart 产生影响，好在下一个版本中
-helpgc 的机制会被移除，我们留到后面的垃圾回收器中再详细讨论。
+阻塞到它重新被 unpark。
 
 ## 核心调度
 
@@ -332,6 +313,23 @@ top:
 		resetspinning()
 	}
 
+	if sched.disable.user && !schedEnabled(gp) {
+		// Scheduling of this goroutine is disabled. Put it on
+		// the list of pending runnable goroutines for when we
+		// re-enable user scheduling and look again.
+		lock(&sched.lock)
+		if schedEnabled(gp) {
+			// Something re-enabled scheduling while we
+			// were acquiring the lock.
+			unlock(&sched.lock)
+		} else {
+			sched.disable.runnable.pushBack(gp)
+			sched.disable.n++
+			unlock(&sched.lock)
+			goto top
+		}
+	}
+
 	if gp.lockedm != 0 {
 		// 如果 g 需要 lock 到 m 上，则会将当前的 p
 		// 给这个要 lock 的 g
@@ -616,7 +614,7 @@ func goexit0(gp *g) {
 
 	// 切换当前的 g 为 _Gdead
 	casgstatus(gp, _Grunning, _Gdead)
-	if isSystemGoroutine(gp) {
+	if isSystemGoroutine(gp, false) {
 		atomic.Xadd(&sched.ngsys, -1)
 	}
 
@@ -720,25 +718,14 @@ func globrunqget(_p_ *p, max int32) *g {
 
 	// 修改本地队列的剩余空间
 	sched.runqsize -= n
-
-	// 如果已经确定要放满，那么队尾指针置空
-	if sched.runqsize == 0 {
-		sched.runqtail = 0
-	}
-
 	// 拿到全局队列队头 g
-	gp := sched.runqhead.ptr()
-
-	// 修改全局队列队头指针
-	sched.runqhead = gp.schedlink
-
+	gp := sched.runq.pop()
 	// 计数
 	n--
 
 	// 继续取剩下的 n-1 个全局队列放入本地队列
 	for ; n > 0; n-- {
-		gp1 := sched.runqhead.ptr()
-		sched.runqhead = gp1.schedlink
+		gp1 := sched.runq.pop()
 		runqput(_p_, gp1, false)
 	}
 	return gp
@@ -773,15 +760,15 @@ func runqget(_p_ *p) (gp *g, inheritTime bool) {
 	// 没有 next
 	for {
 		// 本地队列是空，返回 nil
-		h := atomic.Load(&_p_.runqhead) // load-acquire, 与其他消费者同步
+		h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, 与其他消费者同步
 		t := _p_.runqtail
 		if t == h {
 			return nil, false
 		}
 
 		// 从本地队列中以 cas 方式拿一个
 		gp := _p_.runq[h%uint32(len(_p_.runq))].ptr()
-		if atomic.Cas(&_p_.runqhead, h, h+1) { // cas-release, 提交消费
+		if atomic.CasRel(&_p_.runqhead, h, h+1) { // cas-release, 提交消费
 			return gp, false
 		}
 	}
@@ -844,8 +831,8 @@ top:
 	// 如果有任何类型的逻辑竞争与被阻塞的线程（例如它已经从 netpoll 返回，但尚未设置 lastpoll）
 	// 该线程无论如何都将阻塞 netpoll。
 	if netpollinited() && atomic.Load(&netpollWaiters) > 0 && atomic.Load64(&sched.lastpoll) != 0 {
-		if gp := netpoll(false); gp != nil { // 无阻塞
-			// netpoll 返回 schedlink 连接的 goroutine 链表
+		if list := netpoll(false); !list.empty() { // 无阻塞
+			gp := list.pop()
 			injectglist(gp.schedlink.ptr())
 			casgstatus(gp, _Gwaiting, _Grunnable)
 			if trace.enabled {
@@ -907,10 +894,10 @@ stop:
 	}
 
 	// 仅限于 wasm
-	// 检查一个 goroutine 是否在等待 WebAssembly 宿主机回调
-	// 如果是，暂停执行直到触发回调
-	if pauseSchedulerUntilCallback() {
-		// 回调触发后，至少一个 goroutine 被唤醒
+	// 如果一个回调返回后没有其他 goroutine 是苏醒的
+	// 则暂停执行直到回调被触发。
+	if beforeIdle() {
+		// 至少一个 goroutine 被唤醒
 		goto top
 	}