golang抢占实现(一)----------抢占的时机

golang抢占时机

golang 1.14版本以后开始支持抢占协程.

这里有个有趣的问题是:用户态调度的goroutine在什么时机触发抢占判断?

熟悉linux的朋友可能知道,

linux可能的抢占时机有:

• 时钟中断处理里
• 系统调用返回

golang目前的实现

golang编译器在每个函数调用之前都会插入以下代码:

  mov    %fs:0xfffffffffffffff8,%rcx  //获取tls
  cmp    0x10(%rcx),%rsp // 判断当前协程的stack是否足够
  jbe    jmp  // jmp代指要跳转的位置
  ...
jmp:
  callq  462720 <runtime.morestack_noctxt> //调用morestack_noctxt

通过代码我们可以知道,协程的栈是动态扩展的,每次函数调用时都会判断是否需要扩栈,如果需要则调用morestack_noctxt

morestack_noctxt

runtime.asm_amd64.s

TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
	MOVL	$0, DX
	JMP	runtime·morestack(SB)

TEXT runtime·morestack(SB),NOSPLIT,$0-0
	// Cannot grow scheduler stack (m->g0).
	get_tls(CX)
	MOVQ	g(CX), BX // bx:g
	MOVQ	g_m(BX), BX // bx:g->m
	MOVQ	m_g0(BX), SI // si:m->g0
	CMPQ	g(CX), SI // assert g != g0
	JNE	3(PC)
	CALL	runtime·badmorestackg0(SB)
	CALL	runtime·abort(SB)

	// Cannot grow signal stack (m->gsignal).
	MOVQ	m_gsignal(BX), SI // si: m->signal
	CMPQ	g(CX), SI // assert g != m->signal
	JNE	3(PC)
	CALL	runtime·badmorestackgsignal(SB)
	CALL	runtime·abort(SB)

	// Called from f.
	// Set m->morebuf to f's caller.
	NOP	SP	// tell vet SP changed - stop checking offsets
	MOVQ	8(SP), AX	// f's caller's PC
	MOVQ	AX, (m_morebuf+gobuf_pc)(BX) // m->morebuf->pc = pc
	LEAQ	16(SP), AX	// f's caller's SP // ax: sp
	MOVQ	AX, (m_morebuf+gobuf_sp)(BX) // m->morebuf->sp = sp
	get_tls(CX)
	MOVQ	g(CX), SI
	MOVQ	SI, (m_morebuf+gobuf_g)(BX) // m->morebuf->g = current_g

	// Set g->sched to context in f.
	MOVQ	0(SP), AX // f's PC
	MOVQ	AX, (g_sched+gobuf_pc)(SI)
	MOVQ	SI, (g_sched+gobuf_g)(SI)
	LEAQ	8(SP), AX // f's SP
	MOVQ	AX, (g_sched+gobuf_sp)(SI)
	MOVQ	BP, (g_sched+gobuf_bp)(SI)
	MOVQ	DX, (g_sched+gobuf_ctxt)(SI)

	// Call newstack on m->g0's stack.
	MOVQ	m_g0(BX), BX // bx: g0
	MOVQ	BX, g(CX) // tls: g0
	MOVQ	(g_sched+gobuf_sp)(BX), SP // sp
	CALL	runtime·newstack(SB)
	CALL	runtime·abort(SB)	// crash if newstack returns
	RET

morestack代码注解

• 首先判断当前goroutine是否为g0,g0使用系统栈,不能扩展.
• 然后判断当前goroutine也不能是信号处理goroutine
• 保存当前函数的调用函数信息到当前运行的m->morebuf中
• 判断当前函数信息到g->sched中
• 将栈切换到g0的系统栈,在系统栈上调用newstack扩栈(当前栈已经不足,因此使用g0的系统栈)

有很多操作都是在g0的系统栈上进行的,这个栈是每个m一份,大小足够,经常用作一些关键操作.

通过上面的汇编代码执行到了golang语言的newsatck

stack.go:newstack

newstack除了执行扩栈操作外还会判断是否可以抢占,如果可以则抢占当前goroutine.

func newstack() {
	thisg := getg()
    ...
    	if preempt {
		if !canPreemptM(thisg.m) {
			// Let the goroutine keep running for now.
			// gp->preempt is set, so it will be preempted next time.
			gp.stackguard0 = gp.stack.lo + _StackGuard
			gogo(&gp.sched) // never return
		}
	}
    ...