Go语言调度器之调度main goroutine（14）

func mstart() {    _g_ := getg() //_g_ = g0    //对于启动过程来说，g0的stack.lo早已完成初始化，所以onStack = false    osStack := _g_.stack.lo == 0    if osStack {        // Initialize stack bounds from system stack.        // Cgo may have left stack size in stack.hi.        // minit may update the stack bounds.        size := _g_.stack.hi        if size == 0 {            size = 8192 * sys.StackGuardMultiplier        }        _g_.stack.hi = uintptr(noescape(unsafe.Pointer(&size)))        _g_.stack.lo = _g_.stack.hi - size + 1024    }    // Initialize stack guards so that we can start calling    // both Go and C functions with stack growth prologues.    _g_.stackguard0 = _g_.stack.lo + _StackGuard    _g_.stackguard1 = _g_.stackguard0        mstart1()    // Exit this thread.    if GOOS == "windows" || GOOS == "solaris" || GOOS == "plan9" || GOOS == "darwin" || GOOS == "aix" {        // Window, Solaris, Darwin, AIX and Plan 9 always system-allocate        // the stack, but put it in _g_.stack before mstart,        // so the logic above hasn't set osStack yet.        osStack = true    }    mexit(osStack)}

func mstart1() {    _g_ := getg()  //启动过程时 _g_ = m0的g0    if _g_ != _g_.m.g0 {        throw("bad runtime·mstart")    }    // Record the caller for use as the top of stack in mcall and    // for terminating the thread.    // We're never coming back to mstart1 after we call schedule,    // so other calls can reuse the current frame.    //getcallerpc()获取mstart1执行完的返回地址    //getcallersp()获取调用mstart1时的栈顶地址    save(getcallerpc(), getcallersp())    asminit()  //在AMD64 Linux平台中，这个函数什么也没做，是个空函数    minit()    //与信号相关的初始化，目前不需要关心    // Install signal handlers; after minit so that minit can    // prepare the thread to be able to handle the signals.    if _g_.m == &m0 { //启动时_g_.m是m0，所以会执行下面的mstartm0函数        mstartm0() //也是信号相关的初始化，现在我们不关注    }    if fn := _g_.m.mstartfn; fn != nil { //初始化过程中fn == nil        fn()    }    if _g_.m != &m0 {// m0已经绑定了allp[0]，不是m0的话还没有p，所以需要获取一个p        acquirep(_g_.m.nextp.ptr())        _g_.m.nextp = 0    }        //schedule函数永远不会返回    schedule()}

// save updates getg().sched to refer to pc and sp so that a following// gogo will restore pc and sp.//// save must not have write barriers because invoking a write barrier// can clobber getg().sched.////go:nosplit//go:nowritebarrierrecfunc save(pc, sp uintptr) {    _g_ := getg()    _g_.sched.pc = pc //再次运行时的指令地址    _g_.sched.sp = sp //再次运行时到栈顶    _g_.sched.lr = 0    _g_.sched.ret = 0    _g_.sched.g = guintptr(unsafe.Pointer(_g_))    // We need to ensure ctxt is zero, but can't have a write    // barrier here. However, it should always already be zero.    // Assert that.    if _g_.sched.ctxt != nil {        badctxt()    }}

// One round of scheduler: find a runnable goroutine and execute it.// Never returns.func schedule() {    _g_ := getg()  //_g_ = 每个工作线程m对应的g0，初始化时是m0的g0    //......    var gp *g      //......        if gp == nil {        // Check the global runnable queue once in a while to ensure fairness.        // Otherwise two goroutines can completely occupy the local runqueue        // by constantly respawning each other.        //为了保证调度的公平性，每进行61次调度就需要优先从全局运行队列中获取goroutine，        //因为如果只调度本地队列中的g，那么全局运行队列中的goroutine将得不到运行        if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {            lock(&sched.lock) //所有工作线程都能访问全局运行队列，所以需要加锁            gp = globrunqget(_g_.m.p.ptr(), 1) //从全局运行队列中获取1个goroutine            unlock(&sched.lock)        }    }    if gp == nil {        //从与m关联的p的本地运行队列中获取goroutine        gp, inheritTime = runqget(_g_.m.p.ptr())        if gp != nil && _g_.m.spinning {            throw("schedule: spinning with local work")        }    }    if gp == nil {        //如果从本地运行队列和全局运行队列都没有找到需要运行的goroutine，        //则调用findrunnable函数从其它工作线程的运行队列中偷取，如果偷取不到，则当前工作线程进入睡眠，        //直到获取到需要运行的goroutine之后findrunnable函数才会返回。      gp, inheritTime = findrunnable() // blocks until work is available    }    //跟启动无关的代码.....    //当前运行的是runtime的代码，函数调用栈使用的是g0的栈空间    //调用execte切换到gp的代码和栈空间去运行    execute(gp, inheritTime)  }

// Schedules gp to run on the current M.// If inheritTime is true, gp inherits the remaining time in the// current time slice. Otherwise, it starts a new time slice.// Never returns.//// Write barriers are allowed because this is called immediately after// acquiring a P in several places.////go:yeswritebarrierrecfunc execute(gp *g, inheritTime bool) {    _g_ := getg() //g0    //设置待运行g的状态为_Grunning    casgstatus(gp, _Grunnable, _Grunning)      //......        //把g和m关联起来    _g_.m.curg = gp     gp.m = _g_.m    //......    //gogo完成从g0到gp真正的切换    gogo(&gp.sched)}

# func gogo(buf *gobuf)# restore state from Gobuf; longjmpTEXT runtime·gogo(SB), NOSPLIT, $16-8    #buf = &gp.sched    MOVQ  buf+0(FP), BX   # BX = buf      #gobuf->g --> dx register    MOVQ  gobuf_g(BX), DX  # DX = gp.sched.g      #下面这行代码没有实质作用，检查gp.sched.g是否是nil，如果是nil进程会crash死掉    MOVQ  0(DX), CX   # make sure g != nil      get_tls(CX)       #把要运行的g的指针放入线程本地存储，这样后面的代码就可以通过线程本地存储    #获取到当前正在执行的goroutine的g结构体对象，从而找到与之关联的m和p    MOVQ  DX, g(CX)      #把CPU的SP寄存器设置为sched.sp，完成了栈的切换    MOVQ  gobuf_sp(BX), SP  # restore SP      #下面三条同样是恢复调度上下文到CPU相关寄存器    MOVQ  gobuf_ret(BX), AX    MOVQ  gobuf_ctxt(BX), DX    MOVQ  gobuf_bp(BX), BP      #清空sched的值，因为我们已把相关值放入CPU对应的寄存器了，不再需要，这样做可以少gc的工作量    MOVQ  $0, gobuf_sp(BX)  # clear to help garbage collector    MOVQ  $0, gobuf_ret(BX)    MOVQ  $0, gobuf_ctxt(BX)    MOVQ  $0, gobuf_bp(BX)      #把sched.pc值放入BX寄存器    MOVQ  gobuf_pc(BX), BX      #JMP把BX寄存器的包含的地址值放入CPU的IP寄存器，于是，CPU跳转到该地址继续执行指令，    JMP BX

MOVQ     buf+0(FP), BX    # &gp.sched --> BX

MOVQ    gobuf_g(BX), DX  # gp.sched.g --> DX

MOVQ    0(DX), CX    # make sure g != nil

get_tls(CX) #把DX值也就是需要运行的goroutine的指针写入线程本地存储之中#运行这条指令之前，线程本地存储存放的是g0的地址MOVQ  DX, g(CX)

MOVQ    gobuf_sp(BX), SP   # restore SP

#下面三条同样是恢复调度上下文到CPU相关寄存器  MOVQ  gobuf_ret(BX), AX #系统调用的返回值放入AX寄存器  MOVQ  gobuf_ctxt(BX), DX  MOVQ  gobuf_bp(BX), BP    //清空gp.sched中不再需要的值，因为我们已把相关值放入CPU对应的寄存器了，不再需要，这样做可以少gc的工作量  MOVQ  $0, gobuf_sp(BX)  // clear to help garbage collector  MOVQ  $0, gobuf_ret(BX)  MOVQ  $0, gobuf_ctxt(BX)  MOVQ  $0, gobuf_bp(BX)

MOVQ    gobuf_pc(BX), BX

JMP   BX

// The main goroutine.func main() {    g := getg()  // g = main goroutine，不再是g0了    ......    // Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.    // Using decimal instead of binary GB and MB because    // they look nicer in the stack overflow failure message.    if sys.PtrSize == 8 { //64位系统上每个goroutine的栈最大可达1G        maxstacksize = 1000000000    } else {        maxstacksize = 250000000    }    // Allow newproc to start new Ms.    mainStarted = true    if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon        //现在执行的是main goroutine，所以使用的是main goroutine的栈，需要切换到g0栈去执行newm()        systemstack(func() {            //创建监控线程，该线程独立于调度器，不需要跟p关联即可运行             newm(sysmon, nil)        })    }        ......    //调用runtime包的初始化函数，由编译器实现    runtime_init() // must be before defer    // Record when the world started.    runtimeInitTime = nanotime()    gcenable()  //开启垃圾回收器    ......    //main 包的初始化函数，也是由编译器实现，会递归的调用我们import进来的包的初始化函数    fn := main_init // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime    fn()    ......        //调用main.main函数    fn = main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime    fn()        ......    //进入系统调用，退出进程，可以看出main goroutine并未返回，而是直接进入系统调用退出进程了    exit(0)        //保护性代码，如果exit意外返回，下面的代码也会让该进程crash死掉    for {        var x *int32        *x = 0    }}