Go源码分析(四)调度器

// The bootstrap sequence is:
//
//	call osinit
//	call schedinit
//	make & queue new G
//	call runtime·mstart
//
// The new G calls runtime·main.
func schedinit() {
	// raceinit must be the first call to race detector.
	// In particular, it must be done before mallocinit below calls racemapshadow.
	// G的初始化
	_g_ := getg()
	if raceenabled {
		_g_.racectx, raceprocctx0 = raceinit()
	}

	sched.maxmcount = 10000
	
	// M的初始化
	mcommoninit(_g_.m)
	// cpu初始化
	cpuinit()       // must run before alginit
	.......
	// P的初始化
	procs := ncpu
	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
		procs = n
	}
	......
}

// src/runtime/runtime2.go
type p struct {
	id          int32
	status      uint32 // P的状态，pidle、prunning、pgcstop、psyscall
	......
	mcache      *mcache
	raceprocctx uintptr

	// PPool
	deferpool    [5][]*_defer // pool of available defer structs of different sizes (see panic.go)
	deferpoolbuf [5][32]*_defer

	// Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
	goidcache    uint64
	goidcacheend uint64

	// Queue of runnable goroutines. Accessed without lock.
	runqhead uint32
	runqtail uint32
	runq     [256]guintptr
	// runnext, if non-nil, is a runnable G that was ready'd by
	// the current G and should be run next instead of what's in
	// runq if there's time remaining in the running G's time
	// slice. It will inherit the time left in the current time
	// slice. If a set of goroutines is locked in a
	// communicate-and-wait pattern, this schedules that set as a
	// unit and eliminates the (potentially large) scheduling
	// latency that otherwise arises from adding the ready'd
	// goroutines to the end of the run queue.
	runnext guintptr

	// Available G's (status == Gdead)
	gFree struct {
		gList
		n int32
	}
	......
}

// src/runtime/proc.go
// init initializes pp, which may be a freshly allocated p or a
// previously destroyed p, and transitions it to status _Pgcstop.
func (pp *p) init(id int32) {
	pp.id = id
	pp.status = _Pgcstop
	......
}

// src/runtime/proc.go  method procresize 
if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs {
		// continue to use the current P
		_g_.m.p.ptr().status = _Prunning
		_g_.m.p.ptr().mcache.prepareForSweep()
	} else {
   	.......
		p.status = _Pidle
		......
	}

// src/runtime/proc.go  method acquirep
func acquirep(_p_ *p) {
	// Do the part that isn't allowed to have write barriers.
	wirep(_p_)
	.....
}
func wirep(_p_ *p) {
	......
	_p_.status = _Prunning
}

// src/runtime/proc.go  method releasep 
func releasep() *p {
	......
	_p_.status = _Pidle
	return _p_
}

// 通过entersyscall P由_Prunning变为_Psyscall
func entersyscall() {
	reentersyscall(getcallerpc(), getcallersp())
}

// 通过exitsyscall --> exitsyscallfast --> wirep; P由_Psyscall变为_Prunning
func exitsyscall() {
	......
	exitsyscallfast
	.....
}
//go:nosplit
func exitsyscallfast(oldp *p) bool {
......
// Try to re-acquire the last P.
	if oldp != nil && oldp.status == _Psyscall && atomic.Cas(&oldp.status, _Psyscall, _Pidle) {
		// There's a cpu for us, so we can run.
		wirep(oldp)
		exitsyscallfast_reacquired()
		return true
	}
}
func wirep(_p_ *p) {
	......
	_p_.status = _Prunning
}

// src/runtime/proc.go  method destroy 
func (pp *p) destroy() {
	......
	pp.status = _Pdead
}

	// src/runtime/proc.go  method procresize当中有一处 
	// release resources from unused P's
	for i := nprocs; i < old; i++ {
		p := allp[i]
		p.destroy()
		// can't free P itself because it can be referenced by an M in syscall
	}

// src/runtime/runtime2.go
type m struct {
	g0      *g     // goroutine with scheduling stack
	morebuf gobuf  // gobuf arg to morestack
	divmod  uint32 // div/mod denominator for arm - known to liblink

	// Fields not known to debuggers.
	procid        uint64       // for debuggers, but offset not hard-coded
	gsignal       *g           // signal-handling g
	goSigStack    gsignalStack // Go-allocated signal handling stack
	sigmask       sigset       // storage for saved signal mask
	tls           [6]uintptr   // thread-local storage (for x86 extern register)
	mstartfn      func()
	curg          *g       // current running goroutine
	caughtsig     guintptr // goroutine running during fatal signal
	p             puintptr // attached p for executing go code (nil if not executing go code)
......
	spinning      bool // m is out of work and is actively looking for work
......
	alllink       *m // on allm
	schedlink     muintptr
}

func mspinning() {
	// startm's caller incremented nmspinning. Set the new M's spinning.
	getg().m.spinning = true
}
//go:nowritebarrierrec
func startm(_p_ *p, spinning bool) {}

// Stops execution of the current m until new work is available.
// Returns with acquired P.
func stopm() {......}

// Create a new g running fn with siz bytes of arguments.
// Put it on the queue of g's waiting to run.
// The compiler turns a go statement into a call to this.
// Cannot split the stack because it assumes that the arguments
// are available sequentially after &fn; they would not be
// copied if a stack split occurred.
//go:nosplit
func newproc(siz int32, fn *funcval) {
	argp := add(unsafe.Pointer(&fn), sys.PtrSize)
	gp := getg()
	pc := getcallerpc()
	systemstack(func() {
		newproc1(fn, (*uint8)(argp), siz, gp, pc)
	})
}

// GRQ
type schedt struct{
	....
		// 全局的G队列
    runq     gQueue
		runqsize int32
	....
}

// LRQ
type p struct{
	// Queue of runnable goroutines. Accessed without lock.
	runqhead uint32
	runqtail uint32
	runq     [256]guintptr
}

	// If about to schedule a not-normal goroutine (a GCworker or tracereader),
	// wake a P if there is one.
	if tryWakeP {
		if atomic.Load(&sched.npidle) != 0 && atomic.Load(&sched.nmspinning) == 0 {
			wakep()
		}
	}

	execute(gp, inheritTime)

	casgstatus(gp, _Grunnable, _Grunning)

	_g_.m.curg = gp
	gp.m = _g_.m

// Finishes execution of the current goroutine.
func goexit1() {
	if raceenabled {
		racegoend()
	}
	if trace.enabled {
		traceGoEnd()
	}
	// 这里调用goexit0
	mcall(goexit0)
}

// goexit continuation on g0.
func goexit0(gp *g) {
	_g_ := getg()
	.......
	schedule()
}

// goexit continuation on g0.
func goexit0(gp *g) {
	_g_ := getg()

	// 切换gp的状态，从running变为dead
	casgstatus(gp, _Grunning, _Gdead)
	......
	// 解绑M
	gp.m = nil
	locked := gp.lockedm != 0
	gp.lockedm = 0
	// 清空_g_.m里面的持有g
	_g_.m.lockedg = 0
	gp.paniconfault = false
	// 将各种变更都置为nil
	gp._defer = nil // should be true already but just in case.
	gp._panic = nil // non-nil for Goexit during panic. points at stack-allocated data.
	gp.writebuf = nil
	gp.waitreason = 0
	gp.param = nil
	gp.labels = nil
	gp.timer = nil

	// Note that gp's stack scan is now "valid" because it has no
	// stack.
	gp.gcscanvalid = true
	// 丢弃g
	dropg()

  // 处理p里面的g队列
	gfput(_g_.m.p.ptr(), gp)
	.....
	// 再次开始调度
	schedule()
}