golang 实现 epoll 代码解析

systemstack(func() {
     newm(sysmon, nil)
})

atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
gp := netpoll(false)
if gp != nil {
       injectglist(gp)
}

for {
		if idle == 0 { //20us后开始睡眠
			delay = 20
		} else if idle > 50 { //睡眠1毫秒后翻倍
			delay *= 2
		}
		if delay > 10*1000 { //10ms
			delay = 10 * 1000
		}
                //以上是调整时间间隔
		usleep(delay)
                //睡眠若干毫秒后,判断是否进行调度追踪，
                //并且 是否进行垃圾回收或所有的P都处在空闲状态
		if debug.schedtrace <= 0 && (sched.gcwaiting != 0 || atomic.Load(&sched.npidle) == uint32(gomaxprocs)) {
			lock(&sched.lock)
			if atomic.Load(&sched.gcwaiting) != 0 || atomic.Load(&sched.npidle) == uint32(gomaxprocs) {
				atomic.Store(&sched.sysmonwait, 1)
				unlock(&sched.lock)
				//唤醒任务
				maxsleep := forcegcperiod / 2
				if scavengelimit < forcegcperiod {
					maxsleep = scavengelimit / 2
				}
				notetsleep(&sched.sysmonnote, maxsleep)
				lock(&sched.lock)

				atomic.Store(&sched.sysmonwait, 0)
				noteclear(&sched.sysmonnote)
                                //重置时间间隔
				idle = 0
				delay = 20
			}
			unlock(&sched.lock)
		}
		//距离上次拉去是否超过10ms
		lastpoll := int64(atomic.Load64(&sched.lastpoll))
		now := nanotime()
		unixnow := unixnanotime()
                //判断获取最后一次从网络I/O轮循查找G的时间
		if lastpoll != 0 && lastpoll+10*1000*1000 < now {
                        //更新最后一次查询G时间，为了下一次做判断。
			atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
                        //这行代码是今天的主角，从网络I/O(我喜欢叫网络轮询器)
                        //查找已经就绪的G，注意不是阻塞的
			gp := netpoll(false)

			if gp != nil {
				incidlelocked(-1)
                                //找到后注入到调度器下面的可获取的G队列
				injectglist(gp)
				incidlelocked(1)
			}
		}
		// 再次夺取P、 阻塞的系统调用
		// 再次夺取长时间运行的G
		...
                ...
                ...
	}

func epollcreate(size int32) int32
func epollcreate1(flags int32) int32

TEXT runtime·epollcreate1(SB),NOSPLIT,$0
	MOVL    $329, AX
	MOVL	flags+0(FP), BX
	INVOKE_SYSCALL
	MOVL	AX, ret+4(FP)
	RET

func epollctl(epfd, op, fd int32, ev *epollevent) int32

// sys_linux_386.s
TEXT runtime·epollctl(SB),NOSPLIT,$0
	MOVL	$255, AX
	MOVL	epfd+0(FP), BX
	MOVL	op+4(FP), CX
	MOVL	fd+8(FP), DX
	MOVL	ev+12(FP), SI
	INVOKE_SYSCALL
	MOVL	AX, ret+16(FP)
	RET

_EPOLL_CTL_ADD = 0x1 //在epfd中注册指定的fd文件描述符并能把event和fd关联起来。
_EPOLL_CTL_MOD = 0x3 //改变 fd和evetn之间的联系。
_EPOLL_CTL_DEL = 0x2 //从指定的epfd中删除fd文件描述符。在这种模式中event是被忽略的，并且为可以等于nil。

type epollevent struct {
	events uint32
	data   [8]byte // to match amd64
}

func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32

TEXT runtime·epollwait(SB),NOSPLIT,$0
	MOVL	$256, AX
	MOVL	epfd+0(FP), BX
	MOVL	ev+4(FP), CX
	MOVL	nev+8(FP), DX
	MOVL	timeout+12(FP), SI
	INVOKE_SYSCALL
	MOVL	AX, ret+16(FP)
	RET

func netpoll(block bool) *g {
	if epfd == -1 {
		return nil
	}
	waitms := int32(-1)
	if !block {
		waitms = 0
	}
	var events [128]epollevent
retry:
	n := epollwait(epfd, &events[0], int32(len(events)), waitms)
	if n < 0 {
		if n != -_EINTR {
			println("runtime: epollwait on fd", epfd, "failed with", -n)
			throw("epollwait failed")
		}
		goto retry
	}
	var gp guintptr
	for i := int32(0); i < n; i++ {
		ev := &events[i]
		if ev.events == 0 {
			continue
		}
		var mode int32
		if ev.events&(_EPOLLIN|_EPOLLRDHUP|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'r'
		}
		if ev.events&(_EPOLLOUT|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'w'
		}
		if mode != 0 {
			pd := *(**pollDesc)(unsafe.Pointer(&ev.data))

			netpollready(&gp, pd, mode)
		}
	}
	if block && gp == 0 {
		goto retry
	}
	return gp.ptr()
}