深入理解Go调度器：调度器的初始化（五）

1
2
3

// src/runtime/rt0_linux_amd64.s
TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
     JMP _rt0_amd64(SB)

1
2
3
4
5
6
7
8
9

// src/runtime/asm_amd64.s#L11
// _rt0_amd64 is common startup code for most amd64 systems when using
// internal linking. This is the entry point for the program from the
// kernel for an ordinary -buildmode=exe program. The stack holds the
// number of arguments and the C-style argv.
TEXT _rt0_amd64(SB),NOSPLIT,$-8
	MOVQ	0(SP), DI	// argc,用的 MOVQ,即将argc值加载到 DI 上
	LEAQ	8(SP), SI	// argv,注意用的 LEAQ,即将argv的地址加载到 SI 上
	JMP	runtime·rt0_go(SB)

1
2
3
4
5
6
7
8

TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
	// copy arguments forward on an even stack
	MOVQ	DI, AX		// argc, AX = argc
	MOVQ	SI, BX		// argv, BX = &argv
	SUBQ	$(5*8), SP		// 3args 2auto 预留 40个字节
	ANDQ	$~15, SP    // 调整栈顶寄存器，使其按 16 字节对齐
	MOVQ	AX, 24(SP)  // argc 放到 SP + 24 字节处
	MOVQ	BX, 32(SP)  // &argv 放到 SP + 32 字节处

1
2
3
4
5
6
7
8

	// 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 - 64K + 104
	MOVQ	BX, g_stackguard0(DI)   // g_stackguard0 = SP - 64K + 104
	MOVQ	BX, g_stackguard1(DI)   // g_stackguard0 = SP - 64K + 104
	MOVQ	BX, (g_stack+stack_lo)(DI)  // g0.stack.lo = SP - 64K + 104
	MOVQ	SP, (g_stack+stack_hi)(DI)  // g0.stack.hi = SP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

LEAQ	runtime·m0+m_tls(SB), DI  // DI = &m0.tls, 即将 m0 tls 成员地址放入 DI 寄存器
CALL	runtime·settls(SB)        // 调用 settls 设置工作线程 m 的本地存储

// store through it, to make sure it works
// 验证是否可以工作，如果有问题则 abrot 退出程序
get_tls(BX)  // 获取 fs 段基地址并放入 BX 寄存器，也就是m0.tls[1]的地址，get_tls 的代码由编译器生成
MOVQ	$0x123, g(BX)  // 
MOVQ	runtime·m0+m_tls(SB), AX // AX = m0.tls[0]
CMPQ	AX, $0x123    
JEQ 2(PC)
CALL	runtime·abort(SB)

1
2
3
4
5
6

get_tls(BX)  // 获取 fs 段基地址并放入 BX 寄存器，也就是m0.tls[0]的地址，get_tls 的代码由编译器生成
MOVQ	$0x123, g(BX)  // 将常量 0x123 放入 BX 中
MOVQ	runtime·m0+m_tls(SB), AX // AX = m0.tls[0]
CMPQ	AX, $0x123    // 比较 AX 的值是否与 0x123 相等
JEQ 2(PC)           // 相等则跳过第 6 行代码
CALL	runtime·abort(SB) // 不想当，直接 abort

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// set the per-goroutine and per-mach "registers"
get_tls(BX)
LEAQ	runtime·g0(SB), CX  // 将 g0 的地址放入 CX, 即CX = &g0
MOVQ	CX, g(BX)           // 将 g0 的地址放入线程的本地存储，即 m0.tls[0] = &g0
LEAQ	runtime·m0(SB), AX  // 将 m0 的地址放入 AX

// save m->g0 = g0
MOVQ	CX, m_g0(AX)   // m0.g0 = &g0
// save m0 to g0->m
MOVQ	AX, g_m(CX)    // g0.m = &m0

1
2
3

m0.tls[0] = &g0
m0.g0 = &g0
g0.m = &m0

1
2
3
4
5
6
7

	MOVL	24(SP), AX		// copy argc
	MOVL	AX, 0(SP)
	MOVQ	32(SP), AX		// copy argv
	MOVQ	AX, 8(SP)
	CALL	runtime·args(SB)
	CALL	runtime·osinit(SB)
	CALL	runtime·schedinit(SB)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// src/runtime/proc.go#L677
// The bootstrap sequence is:
//
//	call osinit
//	call schedinit
//	make & queue new G
//	call runtime·mstart
//
// The new G calls runtime·main.
func schedinit() {
  // 前面是一些锁的初始化，可以忽略
  ......

  // 上来先做竞态检查，跟调度器初始化无关，可跳过
	gp := getg()
	if raceenabled {
		gp.racectx, raceprocctx0 = raceinit()
	}

  // 设置最多启动 10000 个操作系统线程，即 10000 个 M
	sched.maxmcount = 10000

	// The world starts stopped.
	worldStopped()

	moduledataverify()
	stackinit()
	mallocinit()
	godebug := getGodebugEarly()
	initPageTrace(godebug) // must run after mallocinit but before anything allocates
	cpuinit(godebug)       // must run before alginit
	alginit()              // maps, hash, fastrand must not be used before this call
	fastrandinit()         // must run before mcommoninit
	mcommoninit(gp.m, -1)
	modulesinit()   // provides activeModules
	typelinksinit() // uses maps, activeModules
	itabsinit()     // uses activeModules
	stkobjinit()    // must run before GC starts

	sigsave(&gp.m.sigmask)
	initSigmask = gp.m.sigmask

	goargs()
	goenvs()
	parsedebugvars()
	gcinit()

	// if disableMemoryProfiling is set, update MemProfileRate to 0 to turn off memprofile.
	// Note: parsedebugvars may update MemProfileRate, but when disableMemoryProfiling is
	// set to true by the linker, it means that nothing is consuming the profile, it is
	// safe to set MemProfileRate to 0.
	if disableMemoryProfiling {
		MemProfileRate = 0
	}

	lock(&sched.lock)
	sched.lastpoll.Store(nanotime())
	procs := ncpu   // 系统有多少核，就创建多少个P
  // 如果存在环境变量GOMAXPROCS，取环境变量的值，创建指定个数的 P
	if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
		procs = n
	}
  // procresize 函数具体创建 P
	if procresize(procs) != nil {
		throw("unknown runnable goroutine during bootstrap")
	}
	unlock(&sched.lock)

	// World is effectively started now, as P's can run.
	worldStarted()
  
  ......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// src/runtime/proc.go#L810
// Pre-allocated ID may be passed as 'id', or omitted by passing -1.
func mcommoninit(mp *m, id int64) {
	gp := getg()

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

	lock(&sched.lock)

  // 调度器初始化的时候，传进来的是 -1
  // mReserveID函数就是取 sched.mnext 的值，同时检查是否超过 10000 个工作线程的限制
	if id >= 0 {
		mp.id = id
	} else {
		mp.id = mReserveID()  // m0.id = 0
	}

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

	mpreinit(mp)
	if mp.gsignal != nil {
		mp.gsignal.stackguard1 = mp.gsignal.stack.lo + _StackGuard
	}

  // 把 m 挂到全局链表 allm 上
	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)
	}
}

1
2

m0.p = allp[0]
allp[0].m = &m0