Unlocking High‑Performance IO: How epoll Powers Linux’s Event‑Driven Architecture

IO Multiplexing

In Linux, the epoll pool is the core weapon for building high‑throughput, high‑concurrency IO systems. Go’s goroutine model makes asynchronous network code look synchronous, but under the hood it relies on epoll to manage many file descriptors.

Simple (but flawed) implementation

A naïve approach uses a for loop that repeatedly tries read / write on each descriptor and sleeps when nothing is ready. Because the descriptors are created in blocking mode, the loop can get stuck on the first descriptor that is not ready, starving the rest.

while True:
    for each fd in fd_array:
        read/write(fd, /* args */)
    sleep(1s)

Fixing the problem requires setting all descriptors to non‑blocking mode so that read / write return EAGAIN instead of blocking, allowing the loop to continue processing other ready descriptors.

Kernel‑provided multiplexing tools

Linux offers three system calls for multiplexing: select, poll, and epoll. Epoll is the most efficient because it avoids the O(n) scanning performed by select and poll.

epoll system calls

Only three syscalls are needed:

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

Internal data structures

epoll manages registered file descriptors with a red‑black tree for fast add/remove/modify operations and a simple doubly‑linked ready list that holds epitem structures for descriptors that have become ready.

Which file descriptors can be managed by epoll?

Only descriptors whose underlying file operations implement the poll callback can be added to an epoll set. Typical examples are:

Network sockets (implemented by socket_file_ops) eventfd – event notification objects timerfd – timer objects that become readable when the timer expires

Regular file systems such as ext2, ext4, or XFS do not implement poll, so their file descriptors cannot be managed directly by epoll.

Key takeaways

IO multiplexing enables a single thread to handle many descriptors efficiently.

Non‑blocking mode and kernel‑level poll callbacks are essential for high performance.

epoll’s red‑black tree and ready list give it superior scalability over select/poll.

Only sockets, eventfd, and timerfd (and similar objects) can be registered with epoll.

For regular files, libraries like libaio can provide indirect epoll‑style notifications.