接着上文我们继续

本文需要大量对函数栈帧的理解 直通车:

上文我们进行到了schedinit函数，这是 runtime·rt0_go 函数里的一步

golang 从启动到调度循环建立 （2） - 知乎 - 图1

上面展示了 schedinit 执行完之后 g0 m0 p(…) 都已经初始化完毕 并互相绑定 全局链表allp allm 等也初始化完成。

那接下我们要做什么？正题开始: 启动 main goroutine 正式干活了

main goroutine 来了

  1. TEXT runtime·rt0_go(SB),NOSPLIT,$0
  2.     ***
  3.            上个章节代码
  4.         ***
  5.     //TODO 参数初始化 栈空余的16利用
  6.     CALL    runtime·args(SB)
  7.     //TODO 初始化系统核心数
  8.     CALL    runtime·osinit(SB)
  9.     //TODO 开始初始化调度器
  10.     CALL    runtime·schedinit(SB)
  12.     // create a new goroutine to start program
  13.     //mainPC 代表的main函数的地址 main函数保存在AX
  14.     MOVQ    $runtime·mainPC(SB), AX        // entry
  15.     //压栈 参数AX
  16.     PUSHQ    AX
  17.     //size main函数入参size main函数没有参数 为0
  18.     PUSHQ    $0            // arg size
  19.     //调用关键函数 newproc 创建main goroutine
  20.     CALL    runtime·newproc(SB)
  21.     POPQ    AX
  22.     POPQ    AX
  24.     // start this M
  25.     CALL    runtime·mstart(SB)
  26.     //主循环里调用了 schedule 不会返回 故出错了直接crash
  27.     CALL    runtime·abort(SB)    // mstart should never return
  28.     RET
  29.     //栈顶指针恢复 **
  31.     // Prevent dead-code elimination of debugCallV1, which is
  32.     // intended to be called by debuggers.
  33.     MOVQ    $runtime·debugCallV1(SB), AX
  34.     RET
  36. DATA    runtime·mainPC+0(SB)/8,$runtime·main(SB)
  37. GLOBL    runtime·mainPC(SB),RODATA,$8

大概描述了一下过程

  1. 获取 main 函数的地址 并放入 AX 寄存器
  2. 发起函数调用 runtime.newproc 创建 main goroutine
  3. 启动调度循环
  4. 防止循环失败 crash

现在我们开始 newproc 核心函数的解析

  1. /*
  2.   newproc用于创建一个新的g 并运行fn函数
  3.   而我们根据函数调用栈分析得知 当前栈在被调用函数的栈帧上
  4.   故新的goroutine需要进行fn函数的参数拷贝,而拷贝就要知道参数大小 所以一个是size 一个是fn代表被调函数
  5.  */
  6. //go:nosplit
  7. func newproc(siz int32, fn *funcval) {
  8.     //获取fn函数的参数
  9.     argp := add(unsafe.Pointer(&fn), sys.PtrSize)
  10.     //获取当前g 启动时为g0
  11.     gp := getg()
  12.     //获取调用者的指令地址 调用newproc 由call指令压栈的返回地址 POPQ AX
  13.     pc := getcallerpc()
  14.     //切换到g0栈 执行 但是本身就在g0栈 忽略
  15.     systemstack(func() {
  16.         newproc1(fn, argp, siz, gp, pc)
  17.     })
  18. }

主要操作在 newproc1 里

  1. /*
  2.   被调函数,g0栈上的参数（启动过程),size,原协程g,返回地址
  3.  */
  4. func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) {
  5.     //获取当前g 启动时为g0
  6.     _g_ := getg()
  8.     if fn == nil {
  9.         //crash
  10.         _g_.m.throwing = -1 // do not dump full stacks
  11.         throw("go of nil func value")
  12.     }
  13.     //内存对齐相关
  14.     acquirem() // disable preemption because it can be holding p in a local var
  15.     siz := narg
  16.     siz = (siz + 7) &^ 7
  18.     // We could allocate a larger initial stack if necessary.
  19.     // Not worth it: this is almost always an error.
  20.     // 4*sizeof(uintreg): extra space added below
  21.     // sizeof(uintreg): caller's LR (arm) or return address (x86, in gostartcall).
  22.     if siz >= _StackMin-4*sys.RegSize-sys.RegSize {
  23.         throw("newproc: function arguments too large for new goroutine")
  24.     }
  26.     _p_ := _g_.m.p.ptr()
  27.     //从gfree里看看有没有g p的local
  28.     newg := gfget(_p_)
  29.     if newg == nil {
  30.         //分配新的g 2048b
  31.         newg = malg(_StackMin)
  32.         //cas控制状态切换 为 dead状态
  33.         casgstatus(newg, _Gidle, _Gdead)
  34.         //放入全局变量allgs中
  35.         allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
  36.     }
  37.     //栈分配检查
  38.     if newg.stack.hi == 0 {
  39.         throw("newproc1: newg missing stack")
  40.     }
  41.     //状态检查
  42.     if readgstatus(newg) != _Gdead {
  43.         throw("newproc1: new g is not Gdead")
  44.     }
  45.     //内存对齐
  46.     totalSize := 4*sys.RegSize + uintptr(siz) + sys.MinFrameSize // extra space in case of reads slightly beyond frame
  47.     totalSize += -totalSize & (sys.SpAlign - 1)                  // align to spAlign
  48.     sp := newg.stack.hi - totalSize
  49.     //确定参数入栈位置
  50.     spArg := sp
  51.     if usesLR {
  52.         // caller's LR
  53.         *(*uintptr)(unsafe.Pointer(sp)) = 0
  54.         prepGoExitFrame(sp)
  55.         spArg += sys.MinFrameSize
  56.     }
  57.     if narg > 0 {
  58.         //从g0拷贝参数到 新的g栈 栈到栈copy
  59.         memmove(unsafe.Pointer(spArg), argp, uintptr(narg))
  60.         // This is a stack-to-stack copy. If write barriers
  61.         // are enabled and the source stack is grey (the
  62.         // destination is always black), then perform a
  63.         // barrier copy. We do this *after* the memmove
  64.         // because the destination stack may have garbage on
  65.         // it.
  66.         if writeBarrier.needed && !_g_.m.curg.gcscandone {
  67.             f := findfunc(fn.fn)
  68.             stkmap := (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))
  69.             if stkmap.nbit > 0 {
  70.                 // We're in the prologue, so it's always stack map index 0.
  71.                 bv := stackmapdata(stkmap, 0)
  72.                 bulkBarrierBitmap(spArg, spArg, uintptr(bv.n)*sys.PtrSize, 0, bv.bytedata)
  73.             }
  74.         }
  75.     }
  76.     //清空newg的sched gobuf 上下文保存相关的
  77.     memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
  78.     //设置gobuf寄存器相关
  79.     newg.sched.sp = sp
  80.     newg.stktopsp = sp
  81.     //设置调度的执行开始指令 获取goexit的地址后增加1个地址的偏移
  82.     newg.sched.pc = funcPC(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
  83.     newg.sched.g = guintptr(unsafe.Pointer(newg))
  84.     gostartcallfn(&newg.sched, fn)

记录下当前状态

golang 从启动到调度循环建立 （2） - 知乎 - 图2

gostartcallfn

  1. //拆解出了包含在 funcval 结构体里的函数指针
  2. //调用gostartcall
  3. func gostartcallfn(gobuf *gobuf, fv *funcval) {
  4.     var fn unsafe.Pointer
  5.     if fv != nil {
  6.         fn = unsafe.Pointer(fv.fn)
  7.     } else {
  8.         fn = unsafe.Pointer(funcPC(nilfunc))
  9.     }
  10.     gostartcall(gobuf, fn, unsafe.Pointer(fv))
  11. }

gostartcall

  1. func gostartcall(buf *gobuf, fn, ctxt unsafe.Pointer) {
  2.     //g的栈顶 现在入栈的只有fn的参数 通过拷贝
  3.     sp := buf.sp
  4.     if sys.RegSize > sys.PtrSize {
  5.         sp -= sys.PtrSize
  6.         *(*uintptr)(unsafe.Pointer(sp)) = 0
  7.     }
  8.     //预留返回地址空间
  9.     sp -= sys.PtrSize
  10.     //装入goexit函数 等于把goexit函数插入栈顶
  11.     *(*uintptr)(unsafe.Pointer(sp)) = buf.pc
  12.     buf.sp = sp
  13.     buf.pc = uintptr(fn)
  14.     buf.ctxt = ctxt
  15. }

上面的gostartcallfn、gostartcall 主要就做了一件事情
把 goexit 函数强行插入 newg 的栈顶，等 newg 结束后方便进行清扫的工作

初始化完 newg 的 sched gobuf

golang 从启动到调度循环建立 （2） - 知乎 - 图3

  1.        //修改运行状态为runnable cas修改
  2.     casgstatus(newg, _Gdead, _Grunnable)
  3.     if _p_.goidcache == _p_.goidcacheend {
  4.         // Sched.goidgen is the last allocated id,
  5.         // this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
  6.         // At startup sched.goidgen=0, so main goroutine receives goid=1.
  7.         _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
  8.         _p_.goidcache -= _GoidCacheBatch - 1
  9.         _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
  10.     }
  11.     //goid ~
  12.     newg.goid = int64(_p_.goidcache)
  13.     _p_.goidcache++
  14.     if raceenabled {
  15.         newg.racectx = racegostart(callerpc)
  16.     }
  17.     if trace.enabled {
  18.         traceGoCreate(newg, newg.startpc)
  19.     }
  20.     //放入本地p的待运行队列
  21.     runqput(_p_, newg, true)

修改状态 放入本地运行队列 p

  1. //next为假 把g放到可运行队列的尾部
  2. //next为真 把g放到p.runnext
  3. //满了放到全局g队列
  4. func runqput(_p_ *p, gp *g, next bool) {
  5.     if randomizeScheduler && next && fastrand()%2 == 0 {
  6.         next = false
  7.     }
  8.     if next {
  9.     retryNext:
  10.         oldnext := _p_.runnext
  11.         //cas操作是否有其他的并发操作
  12.         //修改当前p的runnext 为新的g
  13.         if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
  14.             goto retryNext
  15.         }
  16.         if oldnext == 0 {
  17.             return
  18.         }
  19.         //取出旧的g丢到队列尾部
  20.         gp = oldnext.ptr()
  21.     }
  23. retry:
  24.     h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with consumers
  25.     t := _p_.runqtail
  26.     //如果p本地队列未满 入队
  27.     if t-h < uint32(len(_p_.runq)) {
  28.         _p_.runq[t%uint32(len(_p_.runq))].set(gp)
  29.         atomic.StoreRel(&_p_.runqtail, t+1) // store-release, makes the item available for consumption
  30.         return
  31.     }
  32.     //本地队列慢了，放入全局队列
  33.     if runqputslow(_p_, gp, h, t) {
  34.         return
  35.     }
  36.     // the queue is not full, now the put above must succeed
  37.     goto retry
  38. }

这里不展开分析 属于调度相关的源码，后面我们再进行专项调度代码的分析

这里我们已经做到了，新创建了一个 goroutine，设置好了 sched 成员的 sp 和 pc 字段，并且将其添加到了 p0 的本地可运行队列，坐等调度器的调度。

golang 从启动到调度循环建立 （2） - 知乎 - 图4

还剩余这个两个主要的 call 了，现在开始准备启动调度循环

mstart(0) 里调用了 mstart1

  1. func mstart1() {
  2.     //启动时为g0
  3.     _g_ := getg()
  5.     if _g_ != _g_.m.g0 {
  6.         throw("bad runtime·mstart")
  7.     }
  9.     // Record the caller for use as the top of stack in mcall and
  10.     // for terminating the thread.
  11.     // We're never coming back to mstart1 after we call schedule,
  12.     // so other calls can reuse the current frame.
  13.     //调用schedule之后永远不会返回 所以复用栈帧
  14.     //准备调度前保存调度信息到g0.sched
  15.     save(getcallerpc(), getcallersp())
  16.     asminit()
  17.     minit()
  19.     // Install signal handlers; after minit so that minit can
  20.     // prepare the thread to be able to handle the signals.
  21.     if _g_.m == &m0 {
  22.         mstartm0()
  23.     }
  25.     //执行启动函数 g0fn为nil
  26.     if fn := _g_.m.mstartfn; fn != nil {
  27.         fn()
  28.     }
  30.     if _g_.m != &m0 {
  31.         acquirep(_g_.m.nextp.ptr())
  32.         _g_.m.nextp = 0
  33.     }
  34.     // 进入调度循环。永不返回
  35.     schedule()
  36. }

主要做的是协程切换时一些寄存器信息的保存和处理，之后开始调用 schedule 进入调度循环

golang 从启动到调度循环建立 （2） - 知乎 - 图5

简单看下调度循环吧

  1. func schedule() {
  2.     //每个m对应的工作线程 启动时为m0的g0
  3.     _g_ := getg()
  5.     if _g_.m.locks != 0 {
  6.         throw("schedule: holding locks")
  7.     }
  9.     if _g_.m.lockedg != 0 {
  10.         stoplockedm()
  11.         execute(_g_.m.lockedg.ptr(), false) // Never returns.
  12.     }
  14.     ...
  16.     var gp *g
  17.     var inheritTime bool
  19.     ...
  21.     if gp == nil {
  22.         // Check the global runnable queue once in a while to ensure fairness.
  23.         // Otherwise two goroutines can completely occupy the local runqueue
  24.         // by constantly respawning each other.
  25.         //防止全局队列的g被饿死 所以写死61次就要从全局队列中获取
  26.         if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
  27.             lock(&sched.lock)
  28.             gp = globrunqget(_g_.m.p.ptr(), 1)
  29.             unlock(&sched.lock)
  30.         }
  31.     }
  32.     //从p的local queue里面获取g
  33.     if gp == nil {
  34.         gp, inheritTime = runqget(_g_.m.p.ptr())
  35.         // We can see gp != nil here even if the M is spinning,
  36.         // if checkTimers added a local goroutine via goready.
  37.     }
  38.     if gp == nil {
  39.         //全局队列和本地队列都没有找到 从其他的工作线程进行偷取 偷不到当前工作线程睡眠 block阻塞等待获取到可以运行的g
  40.         gp, inheritTime = findrunnable() // blocks until work is available
  41.     }
  43.     // This thread is going to run a goroutine and is not spinning anymore,
  44.     // so if it was marked as spinning we need to reset it now and potentially
  45.     // start a new spinning M.
  46.     //清空自旋状态
  47.     if _g_.m.spinning {
  48.         resetspinning()
  49.     }
  51.         ...
  53.     //执行goroutine的被调函数
  54.     //切换栈空间回到newG的栈和栈空间去执行
  55.     execute(gp, inheritTime)
  56. }

摘抄了部分关键代码块，最后开始执行 execute 函数切换到 newG 开始执行

  1. func execute(gp *g, inheritTime bool) {
  2.     //当前获取的是g0
  3.     _g_ := getg()
  5.     // 关联gp和m
  6.     _g_.m.curg = gp
  7.     gp.m = _g_.m
  8.     //修改运行状态 cas ==> _Grunning
  9.     casgstatus(gp, _Grunnable, _Grunning)
  10.     gp.waitsince = 0
  11.     gp.preempt = false
  12.     gp.stackguard0 = gp.stack.lo + _StackGuard
  13.     if !inheritTime {
  14.         //调度次数+1
  15.         _g_.m.p.ptr().schedtick++
  16.     }
  17.         //核心函数
  18.         //完成栈切换
  19.         //cpu执行权转让
  20.     gogo(&gp.sched)
  21. }

gogo 函数是一个汇编函数 这样可以精确地控制 cpu 寄存器和函数栈帧切换

  1. TEXT runtime·gogo(SB), NOSPLIT, $16-8
  2.     //buf = &gp.sched 进入bx
  3.     MOVQ    buf+0(FP), BX        // gobuf
  4.     //DX  = gp.sched.g
  5.     MOVQ    gobuf_g(BX), DX
  6.     MOVQ    0(DX), CX        // make sure g != nil
  7.     //把tls保存在CX寄存器上
  8.     get_tls(CX)
  9.     //gp.sched.g 放到tls0
  10.     MOVQ    DX, g(CX)
  11.     //设置cpu的sp寄存器为 sched.sp 栈切换
  12.     MOVQ    gobuf_sp(BX), SP    // restore SP
  13.     //恢复调度上下文
  14.     MOVQ    gobuf_ret(BX), AX
  15.     MOVQ    gobuf_ctxt(BX), DX
  16.     MOVQ    gobuf_bp(BX), BP
  17.     //清空原上下文
  18.     MOVQ    $0, gobuf_sp(BX)    // clear to help garbage collector
  19.     MOVQ    $0, gobuf_ret(BX)
  20.     MOVQ    $0, gobuf_ctxt(BX)
  21.     MOVQ    $0, gobuf_bp(BX)
  22.     //把sched.pc 指令值放入BX寄存器
  23.     MOVQ    gobuf_pc(BX), BX
  24.     //调到 sched.pc 开始执行
  25.     JMP    BX

从 g0 栈切换到 newg 栈 并把之前保存好的 sched 插入到对应的寄存器中，清空原来的 sched
减少 gc 的压力，最后 JMP 开始执行 main 函数。

简单用一张图表示下全部过程

golang 从启动到调度循环建立 （2） - 知乎 - 图6
https://zhuanlan.zhihu.com/p/425005455