协程调度时机一:系统调用

func Read(fd int, p []byte) (n int, err error) {
 n, err = read(fd, p)
 if raceenabled {
 if n > 0 {
 ......
 }
 ......
 }
 return
}
// 最终封装了Syscall 
func read(fd int, p []byte) (n int, err error) {
 var _p0 unsafe.Pointer
 if len(p) > 0 {
 _p0 = unsafe.Pointer(&p[0])
 } else {
 _p0 = unsafe.Pointer(&_zero)
 }
 r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 n = int(r0)
 if e1 != 0 {
 err = e1
 }
 return
}
// 我们只关心进入系统调用时调用的runtime·entersyscall
// 和退出时调用的runtime·exitsyscall
TEXT ·Syscall(SB),NOSPLIT,0ドル-56 
 CALL runtime·entersyscall(SB)
 MOVQ 16(SP), DI 
 MOVQ 24(SP), SI 
 MOVQ 32(SP), DX 
 MOVQ 0,ドル R10 
 MOVQ 0,ドル R8 
 MOVQ 0,ドル R9 
 MOVQ 8(SP), AX // syscall entry
 SYSCALL 
 CMPQ AX, 0ドルxfffffffffffff001
 JLS ok
 
 MOVQ $-1, 40(SP) // r1 
 MOVQ 0,ドル 48(SP) // r2 
 NEGQ AX 
 MOVQ AX, 56(SP) // errno
 
 CALL runtime·exitsyscall(SB)
 RET 

void
·entersyscall(int32 dummy)
{
 runtime·reentersyscall((uintptr)runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
}
void
runtime·reentersyscall(uintptr pc, uintptr sp)
{
 void (*fn)(void);
 // 为什么g->m->locks++? 
 g->m->locks++;
 g->stackguard0 = StackPreempt;
 g->throwsplit = 1;
 // Leave SP around for GC and traceback. 
 // save()到底在save什么? 
 save(pc, sp);
 g->syscallsp = sp;
 g->syscallpc = pc;
 runtime·casgstatus(g, Grunning, Gsyscall);
 // 这些堆栈之间到底是什么关系? 
 if(g->syscallsp < g->stack.lo || g->stack.hi < g->syscallsp) 
 {
 fn = entersyscall_bad;
 runtime·onM(&fn);
 }
 // 这个还不知道是啥意思 
 if(runtime·atomicload(&runtime·sched.sysmonwait)) { 
 fn = entersyscall_sysmon;
 runtime·onM(&fn);
 save(pc, sp);
 }
 // 这里很关键:P的M已经陷入系统调用,于是P忍痛放弃该M 
 // 但是请注意:此时M还指向P,在M从系统调用返回后还能找到P 
 g->m->mcache = nil;
 g->m->p->m = nil;
 // P的状态变为Psyscall 
 runtime·atomicstore(&g->m->p->status, Psyscall);
 if(runtime·sched.gcwaiting) {
 fn = entersyscall_gcwait;
 runtime·onM(&fn);
 save(pc, sp);
 }
 g->stackguard0 = StackPreempt;
 g->m->locks--;
}

void
·exitsyscall(int32 dummy)
{
 void (*fn)(G*);
 // 这个g到底是什么? 
 g->m->locks++; // see comment in entersyscall 
 if(runtime·getcallersp(&dummy) > g->syscallsp)
 runtime·throw("exitsyscall: syscall frame is no longer valid");
 g->waitsince = 0;
 // 判断能否快速找到归属 
 if(exitsyscallfast()) {
 g->m->p->syscalltick++;
 // g的状态从syscall变成running,继续欢快地跑着 
 runtime·casgstatus(g, Gsyscall, Grunning);
 g->syscallsp = (uintptr)nil;
 g->m->locks--;
 if(g->preempt) {
 g->stackguard0 = StackPreempt;
 } else {
 g->stackguard0 = g->stack.lo + StackGuard;
 }
 g->throwsplit = 0;
 return;
 }
 g->m->locks--;
 // Call the scheduler. 
 // 如果M回来发现P已经有别人服务了,那只能将自己挂起 
 // 等着服务别人。 
 fn = exitsyscall0;
 runtime·mcall(&fn);
 ......
}
static bool
exitsyscallfast(void)
{
 void (*fn)(void);
 if(runtime·sched.stopwait) {
 g->m->p = nil;
 return false;
 }
 // 如果之前附属的P尚未被其他M,尝试绑定该P 
 if(g->m->p && g->m->p->status == Psyscall && runtime·cas(&g->m->p->status, Psyscall, Prunning)) {
 g->m->mcache = g->m->p->mcache;
 g->m->p->m = g->m;
 return true;
 }
 // Try to get any other idle P. 
 // 否则从空闲P列表中随便捞一个出来 
 g->m->p = nil;
 if(runtime·sched.pidle) {
 fn = exitsyscallfast_pidle;
 runtime·onM(&fn);
 if(g->m->scalararg[0]) {
 g->m->scalararg[0] = 0;
 return true;
 }
 }
 return false;
}

static void
exitsyscall0(G *gp)
{
 P *p; 
 runtime·casgstatus(gp, Gsyscall, Grunnable); 
 dropg(); 
 runtime·lock(&runtime·sched.lock); 
 // 这里M再次尝试为自己找个归宿P
 p = pidleget(); 
 // 如果没找到P,M讲自己放入全局的运行队列中
 // 同时将它的g放置到全局的P queue中进去,自己不管了
 if(p == nil)
 globrunqput(gp); 
 else if(runtime·atomicload(&runtime·sched.sysmonwait)) {
 runtime·atomicstore(&runtime·sched.sysmonwait, 0); 
 runtime·notewakeup(&runtime·sched.sysmonnote); 
 }
 runtime·unlock(&runtime·sched.lock); 
 // 如果找到了P,占有P并且开始执行P内的g,永不回头
 if(p) {
 acquirep(p); 
 execute(gp); // Never returns. 
 }
 if(g->m->lockedg) {
 // Wait until another thread schedules gp and so m again.
 stoplockedm(); 
 execute(gp); // Never returns. 
 }
 // 找了一圈还是没找到,释放掉M当前执行环境,M不再做事
 // stopm会暂停当前M直到其找到了可运行的P为止
 // 找到以后进入schedule,执行P内的g
 stopm(); 
 
 // m从stopm()中返回以后,说明该m被绑定至某个P,可以开始
 // 继续欢快地跑了,此时就需要调度找到一个g去执行
 // 这就是调用schedule的目的所在
 schedule(); // Never returns. 
}

// Stops execution of the current m until new work is available. 
// Returns with acquired P. 
static void stopm(void)
{
 if(g->m->locks)
 runtime·throw("stopm holding locks");
 if(g->m->p)
 runtime·throw("stopm holding p");
 if(g->m->spinning) {
 g->m->spinning = false;
 runtime·xadd(&runtime·sched.nmspinning, -1);
 }
retry:
 runtime·lock(&runtime·sched.lock);
 // 将m插入到空闲m队列中,统一管理 
 mput(g->m);
 runtime·unlock(&runtime·sched.lock);
 // 在这里被挂起,阻塞在m->park上,位于lock_futex.go 
 runtime·notesleep(&g->m->park);
 // 从挂起被唤醒后开始执行 
 runtime·noteclear(&g->m->park);
 if(g->m->helpgc) {
 runtime·gchelper();
 g->m->helpgc = 0;
 g->m->mcache = nil;
 goto retry;
 }
 // m->nextp是什么? 
 acquirep(g->m->nextp);
 g->m->nextp = nil;
}

func sysmon() {
 ......
 retake(now);
 ......
}
// 我们只摘取了sysmon中与P处理相关的代码分析:
static uint32
retake(int64 now)
{
 uint32 i, s, n;
 int64 t;
 P *p;
 Pdesc *pd;
 n = 0;
 // 遍历所有的P,根据其状态作相应处理,我们只关注Psyscall 
 for(i = 0; i < runtime·gomaxprocs; i++) {
 p = runtime·allp[i];
 if(p==nil)
 continue;
 pd = &pdesc[i];
 s = p->status;
 if(s == Psyscall) {
 t = p->syscalltick;
 if(pd->syscalltick != t) {
 pd->syscalltick = t;
 pd->syscallwhen = now;
 continue;
 }
 if(p->runqhead == p->runqtail && runtime·atomicload(&runtime·sched.nmspinning) + runtime·atomicload(&runtime·sched.npidle) > 0 &&
 pd->syscallwhen + 10*1000*1000 > now)
 continue;
 incidlelocked(-1);
 // 因为需要将P重新安排m,所以状态转化为Pidle 
 if(runtime·cas(&p->status, s, Pidle)) {
 n++;
 handoffp(p);
 }
 incidlelocked(1);
 ......
}

stopm() 
{
 ......
 // 从挂起被唤醒后开始执行 
 runtime·noteclear(&g->m->park);
 if(g->m->helpgc) {
 runtime·gchelper();
 g->m->helpgc = 0;
 g->m->mcache = nil;
 goto retry;
 }
 // 将M和P绑定 
 acquirep(g->m->nextp);
 g->m->nextp = nil;
}
// 由于m在sleep前的调用路径是exitsyscall0() –> stopm(),从stopm()中返回至exitsyscall0后,执行接下来的语句
func exitsyscall0(gp *g) {
 _g_ := getg()
 ......
 stopm()
 // m继续run起来后,执行一次schedule 
 // 找到m->p里面可运行的g并执行 
 schedule() // Never returns. 
}
// One round of scheduler: find a runnable goroutine and execute it. 
// Never returns. 
func schedule() {
 _g_ := getg()
 ......
 if gp == nil {
 gp, inheritTime = runqget(_g_.m.p.ptr())
 if gp != nil && _g_.m.spinning {
 throw("schedule: spinning with local work")
 }
 }
 if gp == nil {
 gp, inheritTime = findrunnable()
 resetspinning()
 }
 if gp.lockedm != nil {
 // Hands off own p to the locked m, 
 // then blocks waiting for a new p. 
 startlockedm(gp)
 goto top
 }
 // 执行该gp 
 execute(gp, inheritTime)
}

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传