Golang-bootstrap分析

红太狼 2022-04-06 08:37 324阅读 0赞

> 这篇博客主要分析golang程序的引导程序启动流程。

# 1. 环境 #

要分析runtime相关内部机制，首先从系统启动开始。首先准备分析环境：golang、OS、gdb  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]

# 2. 引导程序宏观流程 #

在go代码里面，用户逻辑从main.main()开始，那么runtime如何启动？怎么初始化？初始化做了哪些工作呢？

这里我们从函数运行的起点开始分析。我们先编写一个最简单的go代码：

package main
    
    import "fmt"
    
    func main() { 
    	fmt.Println("hello,golang")
    }

这是最简单的一个源码版本了，然后生成可执行文件，使用GDB动态查看即可。

$go build -o test2
    $gdb test2

先用go build编译可执行文件，然后用GDB命令gdb test2进入调试分析源码界面。

使用gdb命令可以获取到系统的Entry Point然后找到函数入口。发现是在

(gdb) info symbol 0x1051fd0
    _rt0_amd64_darwin in section .text

在rt0\_darwin\_amd64.s里面：

TEXT _rt0_amd64_darwin(SB),NOSPLIT,$-8
    	JMP	_rt0_amd64(SB)

然后在：asm\_amd64.s里面发现了\_rt0\_amd64代码段，如下：

TEXT _rt0_amd64(SB),NOSPLIT,$-8
    	MOVQ	0(SP), DI	// argc
    	LEAQ	8(SP), SI	// argv
    	JMP	runtime·rt0_go(SB)

最后调用了runtime.runtime·rt0\_go，系统初始化主要逻辑也是在这个地方(已删减不重要逻辑)；  
具体的源码见 [asm\_amd64.s][asm_amd64.s]

TEXT runtime·rt0_go(SB),NOSPLIT,$0
    	......
    	CALL	runtime·args(SB)
    	CALL	runtime·osinit(SB)
    	CALL	runtime·schedinit(SB)
    
    	// create a new goroutine to start program
    	MOVQ	$runtime·mainPC(SB), AX		// entry
    	PUSHQ	AX
    	PUSHQ	$0			// arg size
    	CALL	runtime·newproc(SB)
    	POPQ	AX
    	POPQ	AX
    
    	// start this M
    	CALL	runtime·mstart(SB)
    
    	CALL	runtime·abort(SB)	// mstart should never return
    	RET
    
    	// Prevent dead-code elimination of debugCallV1, which is
    	// intended to be called by debuggers.
    	MOVQ	$runtime·debugCallV1(SB), AX
    	RET

在完成命令行初始化、OS初始化、调度器初始化之后。使用newproc创建一个goroutine放入待运行队列。然后mstart让主线程进入任务调度模式，从队列提出main goroutine并执行。

**bootstrap overview**  
![bootstrap][]

# 3. 初始化流程 #

初始化的流程里面，命令行初始化和OS初始化与调度器的机制关系不大，这里就不做主要讲解，这里主要关心调度器的初始化，初始化函数schedinit()在runtime/proc.go 这个源码里面。

## 3.1 schedule init ##

初始化的代码在proc.go里面的schedule\_init函数，源码如下(只保留核心流程代码)：

// The bootstrap sequence is:
    //
    // call osinit
    // call schedinit
    // make & queue new G
    // call runtime·mstart
    //
    // The new G calls runtime·main.
    func schedinit() { 
    	// M最大数量限制
    	sched.maxmcount = 10000
    	
    	// 内存相关初始化
    	stackinit()
    	mallocinit()
    	// m相关初始化
    	mcommoninit(_g_.m)
    	// 命令参数和环境初始化
    	goargs()
    	goenvs()
    	// GC 初始化
    	gcinit()
    	// 设置GOMAXPROCS
    	procs := ncpu
    	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 { 
    		procs = n
    	}
    	if procresize(procs) != nil { 
    		throw("unknown runnable goroutine during bootstrap")
    	}
    }

调度器的初始化主要相关内容上面注释都描述的比较清楚了，主要是初始化栈空间分配器, GC, 按cpu核心数量或GOMAXPROCS的值生成P等。

特别要主要的是生成P的操作在procresize函数里面，如果在runtime需要更改P的数量也是调用这个函数。这个函数主要逻辑如下源码：

// Returns list of Ps with local work, they need to be scheduled by the caller.
    func procresize(nprocs int32) *p { 
    	// 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
    		}
    		unlock(&allpLock)
    	}
    
    	// initialize new P's
    	for i := int32(0); i < nprocs; i++ { 
    		pp := allp[i]
    		if pp == nil { 
    			pp = new(p)
    			pp.id = i
    			pp.status = _Pgcstop
    			pp.sudogcache = pp.sudogbuf[:0]
    			for i := range pp.deferpool { 
    				pp.deferpool[i] = pp.deferpoolbuf[i][:0]
    			}
    			pp.wbBuf.reset()
    			atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
    		}
    		if pp.mcache == nil { 
    			if old == 0 && i == 0 { 
    				if getg().m.mcache == nil { 
    					throw("missing mcache?")
    				}
    				pp.mcache = getg().m.mcache // bootstrap
    			} else { 
    				pp.mcache = allocmcache()
    			}
    		}
    	}
    
    	// free unused P's
    	for i := nprocs; i < old; i++ { 
    		p := allp[i]
    		// move all runnable goroutines to the global queue
    		for p.runqhead != p.runqtail { 
    			// pop from tail of local queue
    			p.runqtail--
    			gp := p.runq[p.runqtail%uint32(len(p.runq))].ptr()
    			// push onto head of global queue
    			globrunqputhead(gp)
    		}
    		if p.runnext != 0 { 
    			globrunqputhead(p.runnext.ptr())
    			p.runnext = 0
    		}
    		// if there's a background worker, make it runnable and put
    		// it on the global queue so it can clean itself up
    		if gp := p.gcBgMarkWorker.ptr(); gp != nil { 
    			casgstatus(gp, _Gwaiting, _Grunnable)
    			if trace.enabled { 
    				traceGoUnpark(gp, 0)
    			}
    			globrunqput(gp)
    			// This assignment doesn't race because the
    			// world is stopped.
    			p.gcBgMarkWorker.set(nil)
    		}
    		// Flush p's write barrier buffer.
    		if gcphase != _GCoff { 
    			wbBufFlush1(p)
    			p.gcw.dispose()
    		}
    		for i := range p.sudogbuf { 
    			p.sudogbuf[i] = nil
    		}
    		p.sudogcache = p.sudogbuf[:0]
    		for i := range p.deferpool { 
    			for j := range p.deferpoolbuf[i] { 
    				p.deferpoolbuf[i][j] = nil
    			}
    			p.deferpool[i] = p.deferpoolbuf[i][:0]
    		}
    		freemcache(p.mcache)
    		p.mcache = nil
    		gfpurge(p)
    		traceProcFree(p)
    		if raceenabled { 
    			raceprocdestroy(p.racectx)
    			p.racectx = 0
    		}
    		p.gcAssistTime = 0
    		p.status = _Pdead
    		// 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]
    		unlock(&allpLock)
    	}
    
    	_g_ := getg()
    	if _g_.m.p != 0 && _g_.m.p.ptr().id < nprocs { 
    		// continue to use the current P
    		_g_.m.p.ptr().status = _Prunning
    	} else { 
    		// release the current P and acquire allp[0]
    		if _g_.m.p != 0 { 
    			_g_.m.p.ptr().m = 0
    		}
    		_g_.m.p = 0
    		_g_.m.mcache = nil
    		p := allp[0]
    		p.m = 0
    		p.status = _Pidle
    		acquirep(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
    }

主要逻辑如下：

*  如果新的GOMAXPROCS的值大于已有的全局变量里面P的数量，那么需要扩容
    
     *  加锁allpLock然后重新生成新的GOMAXPROCS数量的P数组，并将原来已有的P数组copy过来，重新构造P数组之后释放allpLock锁
 *  初始化并new新的P(GOMAXPROCS数量大于old P数量)
 *  如果GOMAXPROCS小于old P数量，那么旧的P需要free掉，free时候涉及到一些P持有相关资源的释放和转移
    
     *  move all runnable goroutines to the global queue(contain local queue and p.runnext)
     *  if there’s a background worker, make it runnable and put it on the global queue so it can clean itself up
     *  release related cache
     *  mark P state Pdead
 *  重新赋值runtime.allp
 *  如果当前g的P仍然有效，那么继续使用当前P，如果当前g的P已经被release，那么选择runtime.allp\[0\]作为当前g的新P。
 *  更新runtime.allp的状态机为Pidle

当我们更新GOMAXPROCS数量时候，调度器会被加上全局锁，也会出发Stop the World。所以除了系统启动时候调用外，不建议在其余地方触发这个函数，十分影响性能。

## 3.2 runtime.main ##

完成核心初始化之后创建并执行main goroutine，其实也就是runtime.main函数。

有一个概念需要区分清楚，前面描述的初始化属于内核层面的初始化，还有一种初始化属于用户层面逻辑初始化，包括runtime包、标准库、用户、第三方包初始化函数。逻辑层面的初始化可能关系到很多的同步关系，代码依赖等等。

函数的核心代码如下：proc.go\#main

// The main goroutine.
    func main() { 
    	// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
    	if sys.PtrSize == 8 { 
    		maxstacksize = 1000000000
    	} else { 
    		maxstacksize = 250000000
    	}
    
    	// Allow newproc to start new Ms.
    	mainStarted = true
    	
    	// 启动后台监控线程
    	if GOARCH != "wasm" {  // no threads on wasm yet, so no sysmon
    		systemstack(func() { 
    			newm(sysmon, nil)
    		})
    	}
    	// runtime包里面的初始化函数
    	runtime_init() // must be before defer
    	
    	// Record when the world started. Must be after runtime_init
    	// because nanotime on some platforms depends on startNano.
    	runtimeInitTime = nanotime()
    	//启动GC
    	gcenable()
    	//执行用户、标准库，三方包里面的初始化函数
    	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()
    	// 如果是库方式就不执行用户入口函数
    	if isarchive || islibrary { 
    		// A program compiled with -buildmode=c-archive or c-shared
    		// has a main, but it is not executed.
    		return
    	}
    	//执行用户入口函数
    	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()
    	// 退出进程
    	exit(0)
    	for { 
    		var x *int32
    		*x = 0
    	}
    }

有几个需要注意的点：  
1）goroutine的栈最大值是1G(64位系统)  
2）会启动一个后台监控线程，这个监控线程也是完成抢占式调度的地方  
3）目标是runtime.init、main.init、以及main.main这个入口函数

runtime.init函数和main.init由编译器编译生成，负责调用所有的初始化函数。

runtime.init函数仅仅负责runtime包，  
main.init函数负责用户、标准库和第三方所有init函数，  
所有初始化都在main goroutine中完成  
全部初始化完成再执行main.main函数。

快速导览：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]: /images/20220406/f70317fc518a420c8dc0a1af33ebb5f9.png
[asm_amd64.s]: https://github.com/golang/go/blob/dev.boringcrypto.go1.11/src/runtime/asm_amd64.s
[bootstrap]: /images/20220406/9fc6f59810b842cbb9b892d001f7a146.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]: /images/20220406/6e4983e4b09f48328743e1341e167585.png