var (
   m0 m // 代表第一個(gè)起來的線程，即主線程
   g0 g // m0的g0，即 m0.g0 = &g0
   
   allgs   []*g    // 保存所有的g
   allglen uintptr // 所有g(shù)的長度
   
   
   allm       *m     // 保存所有的m
   gomaxprocs int32  // p的最大個(gè)數(shù)，默認(rèn)等于 ncpu
   ncpu       int32  // 程序啟動(dòng)時(shí)，會(huì)調(diào)用osinit函數(shù)獲得此值
   sched      schedt // 調(diào)度器的結(jié)構(gòu)體對(duì)象，全局僅此一份
)

package main

import "fmt"

func main() {
	fmt.Println("hello world")
}

// create istack out of the given (operating system) stack.
// _cgo_init may update stackguard.
MOVQ   $runtime·g0(SB), DI        // g0的地址存放在DI寄存器
LEAQ   (-64*1024+104)(SP), BX     // BX=SP-64*1024+104
MOVQ   BX, g_stackguard0(DI)      // g0.stackguard0=SP-64*1024+104
MOVQ   BX, g_stackguard1(DI)      // g0.stackguard1=SP-64*1024+104
MOVQ   BX, (g_stack+stack_lo)(DI) // g0.stack.lo=SP-64*1024+104
MOVQ   SP, (g_stack+stack_hi)(DI) // g0.stack.hi=SP

#ifdef GOARCH_amd64
#define    get_tls(r) MOVQ TLS, r
#define    g(r)   0(r)(TLS*1)
#endif

// The bootstrap sequence is:
//
// call osinit
// call schedinit
// make & queue new G
// call runtime·mstart
//
// The new G calls runtime·main.
func schedinit() {
   // a lot of lock init
   ...

   // raceinit must be the first call to race detector.
   // In particular, it must be done before mallocinit below calls racemapshadow.
   // getg函數(shù)源碼沒有定義，在編譯的時(shí)候由編譯器插入，類似下面的代碼
   // get_tls(CX)
   // MOVQ g(CX), BX
   _g_ := getg()  // 獲取的 _g_ = &g0
   if raceenabled {
      _g_.racectx, raceprocctx0 = raceinit()
   }

   sched.maxmcount = 10000  // 操作系統(tǒng)線程個(gè)數(shù)最多為10000

   // a lot of init
   ...
   
   // 初始化m0
   mcommoninit(_g_.m, -1)
   
   // 一些其他設(shè)置，暫時(shí)忽略
   ...
   
   sched.lastpoll = uint64(nanotime())
   // p的數(shù)目確定
   procs := ncpu
   if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
      procs = n
   }
   // 初始化p
   if procresize(procs) != nil {
      throw("unknown runnable goroutine during bootstrap")
   }
   
   ...
}

// Pre-allocated ID may be passed as 'id', or omitted by passing -1.
func mcommoninit(mp *m, id int64) {
   _g_ := getg() // _g_ = &g0

   // g0 stack won't make sense for user (and is not necessary unwindable).
   if _g_ != _g_.m.g0 {
      callers(1, mp.createstack[:])
   }

   lock(&sched.lock)

   if id >= 0 {
      mp.id = id
   } else {
      mp.id = mReserveID() // 初次從mReserveID()獲取到的id=0
   }

   // random初始化，用于竊取 G
   lo := uint32(int64Hash(uint64(mp.id), fastrandseed))
   hi := uint32(int64Hash(uint64(cputicks()), ^fastrandseed))
   if lo|hi == 0 {
      hi = 1
   }
   // Same behavior as for 1.17.
   // TODO: Simplify ths.
   if goarch.BigEndian {
      mp.fastrand = uint64(lo)<<32 | uint64(hi)
   } else {
      mp.fastrand = uint64(hi)<<32 | uint64(lo)
   }

   // 創(chuàng)建用于信號(hào)處理的gsignal，只是簡單的從堆上分配一個(gè)g結(jié)構(gòu)體對(duì)象,然后把棧設(shè)置好就返回了
   mpreinit(mp)
   if mp.gsignal != nil {
      mp.gsignal.stackguard1 = mp.gsignal.stack.lo + _StackGuard
   }

   // 把m0掛入全局鏈表allm中
   // Add to allm so garbage collector doesn't free g->m
   // when it is just in a register or thread-local storage.
   mp.alllink = allm

   // NumCgoCall() iterates over allm w/o schedlock,
   // so we need to publish it safely.
   atomicstorep(unsafe.Pointer(&allm), unsafe.Pointer(mp))
   unlock(&sched.lock)

   // Allocate memory to hold a cgo traceback if the cgo call crashes.
   if iscgo || GOOS == "solaris" || GOOS == "illumos" || GOOS == "windows" {
      mp.cgoCallers = new(cgoCallers)
   }
}

func procresize(nprocs int32) *p {
   ...

   old := gomaxprocs // 系統(tǒng)初始化的時(shí)候， gomaxprocs=0
   if old < 0 || nprocs <= 0 {
      throw("procresize: invalid arg")
   }
   
   ...

   // 看看是否需要擴(kuò)大allp，初始化時(shí)len(allp)=0，所以肯定會(huì)增長
   // Grow allp if necessary.
   if nprocs > int32(len(allp)) {
      // Synchronize with retake, which could be running
      // concurrently since it doesn't run on a P.
      lock(&allpLock)
      if nprocs <= int32(cap(allp)) {
         allp = allp[:nprocs]
      } else {
         nallp := make([]*p, nprocs)
         // Copy everything up to allp's cap so we
         // never lose old allocated Ps.
         copy(nallp, allp[:cap(allp)])
         allp = nallp
      }

      if maskWords <= int32(cap(idlepMask)) {
         idlepMask = idlepMask[:maskWords]
         timerpMask = timerpMask[:maskWords]
      } else {
         nidlepMask := make([]uint32, maskWords)
         // No need to copy beyond len, old Ps are irrelevant.
         copy(nidlepMask, idlepMask)
         idlepMask = nidlepMask

         ntimerpMask := make([]uint32, maskWords)
         copy(ntimerpMask, timerpMask)
         timerpMask = ntimerpMask
      }
      unlock(&allpLock)
   }

   // 初始化這些P
   // initialize new P's
   for i := old; i < nprocs; i++ {
      pp := allp[i]
      if pp == nil {
         pp = new(p)
      }
      pp.init(i)
      atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
   }

   _g_ := getg() // _g_ = g0
   if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs { // 初始化時(shí)m0.p=0，所以不會(huì)進(jìn)這個(gè)分支
      // continue to use the current P
      _g_.m.p.ptr().status = _Prunning
      _g_.m.p.ptr().mcache.prepareForSweep()
   } else {
      // release the current P and acquire allp[0].
      //
      // We must do this before destroying our current P
      // because p.destroy itself has write barriers, so we
      // need to do that from a valid P.
      if _g_.m.p != 0 {
         if trace.enabled {
            // Pretend that we were descheduled
            // and then scheduled again to keep
            // the trace sane.
            traceGoSched()
            traceProcStop(_g_.m.p.ptr())
         }
         _g_.m.p.ptr().m = 0
      }
      _g_.m.p = 0
      p := allp[0]
      p.m = 0
      p.status = _Pidle
      acquirep(p) // 把p和m0關(guān)聯(lián)起來         
      if trace.enabled {
         traceGoStart()
      }
   }

   // g.m.p is now set, so we no longer need mcache0 for bootstrapping.
   mcache0 = nil

   // 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
   }

   // Trim allp.
   if int32(len(allp)) != nprocs {
      lock(&allpLock)
      allp = allp[:nprocs]
      idlepMask = idlepMask[:maskWords]
      timerpMask = timerpMask[:maskWords]
      unlock(&allpLock)
   }

   // 將所有的空閑的p放入空閑鏈表
   var runnablePs *p
   for i := nprocs - 1; i >= 0; i-- {
      p := allp[i]
      if _g_.m.p.ptr() == p {
         continue
      }
      p.status = _Pidle
      if runqempty(p) {
         pidleput(p)
      } else {
         p.m.set(mget())
         p.link.set(runnablePs)
         runnablePs = p
      }
   }
   stealOrder.reset(uint32(nprocs))
   var int32p *int32 = &gomaxprocs // make compiler check that gomaxprocs is an int32
   atomic.Store((*uint32)(unsafe.Pointer(int32p)), uint32(nprocs))
   return runnablePs
}