How to implement epoll in golang

In the Linux operating system, epoll is a very efficient I/O event notification mechanism. When using epoll, you can bind multiple file descriptors to one epoll instance. The epoll instance will notify the program of I/O events that occur on all file descriptors. Compared with other I/O event notification mechanisms such as select and poll, epoll has higher efficiency and lower overhead. In this article, we will introduce how to implement epoll in golang.

1. Basic principle of epoll

In Linux, each process has its own file descriptor table. When the process needs to perform I/O operations, it needs to pass File descriptor to access the corresponding file or socket. When the file or socket is ready, the kernel will notify the process. This notification is an I/O event. When an I/O event occurs, select and poll will traverse all the file descriptor sets, but epoll is different. It will only traverse the file descriptor set where the I/O event occurred.

epoll basically consists of three system calls: epoll_create, epoll_ctl and epoll_wait. epoll_create is used to create an epoll instance, epoll_ctl is used to add/delete/modify file descriptors to the epoll instance, and epoll_wait is used to wait for events to occur on the file descriptor.

2. epoll in golang

In golang, epoll is implemented by package net/netutil. It is encapsulated based on the epoll_create, epoll_ctl and epoll_wait system calls. golang encapsulates epoll into the internal/poll/epoll file of netutil.

When golang implements epoll, it defines epoll instance types epollServer and epollDesc respectively. Among them, epollServer contains an epoll instance, which is used to store file descriptors and I/O events; epollDesc is used to represent a file descriptor and related I/O events.

3. Implementation of epollServer

Let’s take a look at the implementation of epollServer first. epollServer contains the following fields:

type epollServer struct {
    // events 是一个数组，用于存储返回的 I/O 事件
    events []syscall.EpollEvent

    // epollFd 是 epoll 实例的文件描述符
    epollFd int

    // fds 用于存储文件描述符和对应的 epollDesc
    fds map[int]*epollDesc
}

First, in order to create an epollServer instance, you need to call the function newEpollServer provided by golang.

func newEpollServer() (ep *epollServer, err error) {
    // 创建 epoll 实例
    ep = &epollServer{
        events: make([]syscall.EpollEvent, epollServerBlock),
        fds:    make(map[int]*epollDesc),
    }
    ep.epollFd, err = syscall.EpollCreate1(0)
    if err != nil {
        return nil, err
    }

    // 将 epoll 实例添加到 epollServer 的文件描述符映射表中
    ep.fds[ep.epollFd] = &epollDesc{ep, syscall.EPOLLIN}
    return ep, nil
}

We can see that when creating an epollServer instance, an epoll instance will first be created through the syscall.EpollCreate1(0) call, and then added to the file descriptor mapping table of epollServer.

Then, we can add a file descriptor to the epollServer instance through the addFD method.

func (ep *epollServer) addFD(fd int, mode int) error {
    // 设置文件描述符的非阻塞模式
    if err := syscall.SetNonblock(fd, true); err != nil {
        return err
    }

    // 将文件描述符的 I/O 事件添加到 epoll 实例中
    ev := syscall.EpollEvent{Fd: int32(fd), Events: syscall.EPOLLIN | syscall.EPOLLOUT}
    if err := syscall.EpollCtl(ep.epollFd, syscall.EPOLL_CTL_ADD, fd, &ev); err != nil {
        return err
    }

    // 将文件描述符和 epollDesc 添加到文件描述符映射表中
    ep.fds[fd] = &epollDesc{ep, mode}
    return nil
}

In the addFD method, first set the file descriptor to non-blocking mode, and then add the I/O event of the file descriptor to the epoll instance. Finally, add the file descriptor and corresponding epollDesc to the file descriptor mapping table.

Finally, we can wait for I/O events that occur on the file descriptor through the wait method.

func (ep *epollServer) wait(ms int) ([]syscall.EpollEvent, error) {
    if ms < 0 {
        ms = -1
    }
    // 等待发生 I/O 事件
    nEvents, err := syscall.EpollWait(ep.epollFd, ep.events, ms)
    if err != nil {
        return nil, err
    }

    // 返回发生的 I/O 事件
    return ep.events[:nEvents], nil
}

Now, we have understood the implementation of epollServer in golang. Next we will introduce the implementation method of epollDesc.

4. Implementation of epollDesc

epollDesc is used to represent a file descriptor and its corresponding I/O event. Its implementation is very simple, requiring only a pointer to epollServer and an integer representing the I/O event.

type epollDesc struct {
    srv  *epollServer
    mode int
}

5. Summary

In this article, we introduced how to use epoll in golang to implement an efficient I/O event notification mechanism. We introduced in detail the basic principles of epoll and golang’s implementation of epollServer and epollDesc. I believe that by reading this article, you can better understand the implementation of epoll in golang and provide a reference for choosing the appropriate I/O event notification mechanism for your project.

The above is the detailed content of How to implement epoll in golang. For more information, please follow other related articles on the PHP Chinese website!