「Tech初见」对epoll的理解

一、Motivation

通常，操作系统会为每个进程划分一个时间片的，在这个时间片内进程可以合法占有 cpu 进行一些计算任务。并当时间片结束后自动退回至就绪状态待命，等待下一次的调度

但是，有一种情况会使进程提前（时间片还未用完）进入等待状态，即是进程发生了阻塞（多半是因为 I/O 请求）。进程一旦发生了阻塞，它就要让出 cpu 给其他进程，这个让位的动作就是进程之间切换的操作，这种操作非常蠢（在开发者眼里是无用功），也很耗时。可以说是时间和 cpu 资源没用在正儿八经的计算任务上

select 和 epoll 的提出就是来解决这个愚蠢的问题，有一种设想：在分配给该进程时间片还未结束之前，如果进程的某个 socket 连接发生阻塞，先不急着逼该进程退位，而是通过某种手段去查询一下进程的其他 socket 连接是否有已就绪的。如果其他 socket 连接有活动可以处理，不如充分利用 cpu 先进行计算，在处理完成 OR 时间片到期后再让位也不迟。这样不就可以提高计算机资源的利用率了嘛

但是，在 Linux 老的版本中，有关事件触发的问题，一直是采用 select 轮询手段来解决的，所谓的轮询就是 cpu 不停地去查询任务队列是否有已经就绪的任务。这种方法在任务较少的情况下还能勉强应付，当任务数量增加至千级数量级之后，效率就会出现断崖式地降低。因为每次需要轮询上千个任务，自然非常耗时

为此，Linux 提出了新的解决方法 epoll，不再采用轮询的方法来感知新事件的发生，而是通过 epoll 结构体内部的红黑树来自动将等待的任务和就绪的任务分开，从而使 kernel 能够快速感知新事件的发生

再说直白一点，只要活儿足够多，epoll_wait 根本就不会让用户进程阻塞，用户进程会一直干活，直到属于该进程的时间片结束。这样就大大减少了进程切换次数，提高了效率

epoll 相比于 select 和 poll 厉害的地方，即是它可以快速感知已连接的 socket 动静，而 select 和 poll 需要用户层将描述符集合 sockets 传入 kernel，接着进行一次遍历之后才能知道 socket 的变动情况

其实，socket 有什么动静我们是能够快速感知的（通过中断），但是我们要准确识别到底是哪个 socket 发生了变化，这件事确实有很多种不同的做法，不同的做法也带来了不同的效率

epoll 是在用户层第一次注册 socket 的时候就将其传入 kernel 了，具体表现为在 epoll 对象的红黑树 rbr 中创建该 socket 的 epitem，这种行为就是用户层数据拷贝进 kernel 的动作。与 select 和 poll 每次都要将集合 sockets 传入 kernel 的事实相比，无疑是 epoll 在初始化时就将 socket 传入 kernel 的做法效率要高很快

epoll 效率高的背后其实是牺牲 kernel 空间（创建红黑树）来换取时间的妥协，select 和 poll 因为只是临时（遍历完会释放）占用 kernel 空间，所以它们的效率比较低。归根结底，就是空间换时间

二、Solutions

S1 - epoll_create

创建一个 epoll 句柄，size 用来告诉 kernel 共能监听多少个事件，

int epoll_create(int size)

这个参数在现在的版本中没有意义，kernel 会根据实际情况自行决定的，意思就是说这个 size 只是我们规定的事件的大致数量，而不是能够处理的最大事件数

epoll 结构体中定义的等待队列 wq 存放阻塞在 epoll 对象上的用户进程，当软中断数据就绪时会前来寻找进程；epoll 对象用红黑树 rbr 来管理用户进程 accept 添加进来的所有 socket 连接，选用红黑树的原因是因为红黑树能够更好地支持海量连接的查找、插入和删除；就绪链表 rdllist 存放着一些已就绪的任务，这样一来，应用进程只需要查询 rdllist 就能判断是否有就绪任务可供处理，而不必去遍历整棵红黑树

S2 - epoll_ctl

该方法向 epoll 对象中添加、修改和删除特定的事件，返回 0 表示成功，-1 表示失败，

int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event)

添加意味着对这件事感兴趣，应用进程想收来处理；删除则表示对这件事没了兴趣。其中，epfd 是 epoll 对象的 id，epoll_create() 的返回值；op 有三种操作类型，EPOLL_CTL_ADD、EPOLL_CTL_MOD 和 EPOLL_CTL_DEL；fd 是需要监听的文件描述符，通常是连接至服务端的 socket；最后一个参数 event 可以是以下几种宏的集合，

• EPOLLIN：文件描述符可读
• EPOLLOUT：文件描述符可写
• EPOLLPRI：文件描述符有紧急数据可读
• EPOLLERR：文件描述符发生错误
• EPOLLHUP：文件描述符被挂断
• EPOLLET：边缘触发（后面会讲到）
• EPOLLONESHOT：只监听一次，意味着触发来事件之后就被踢出 epoll 对象中了

它是一个传入的指针，这就要求我们需要在进入函数之前分配好空间并初始化，以便 epoll_create() 可以在方法内获取内容，但 epoll_create() 并不会替我们释放 events 空间

再进一步解释，当有新的 socket 连接加入 epoll 对象时，epoll 对象会创建一个 epitem 用来关联该 socket 连接，然后将 epitem 挂到红黑树 rbr 中。之后，会设置该 epitem 的回调函数（如果该连接有数据写入，请将其存入 epoll 对象的就绪链表 rdllist 中），以及其他的回调函数

在这我只列举了 “增” 的一个例子，其他关于 “删” 和 “改” 的操作，它们的本质是一样的，都是 socket 连接有什么动作就会去调用对应的回调函数。关于能够快速实现 “增删改查” 最主要的原因是因为选用了红黑树

补充一个 demo，假设处于阻塞状态的 socket 有数据写入了，第一步会去通知红黑树 rbr 找到（很快）该 socket 的 epitem；然后，调用 epitem 的回调函数将 epitem 加入就绪链表 rdllist 中。这一步主要是为了 epoll_wait 能够快速获取已经就绪的 socket 信息

S3 - epoll_wait

等待处于监听范围的事件发生，

int epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout)

epoll 对象会将已经发生的事件复制到数组 events 中，maxevents 是数组的长度；timeout 如果为 0，则意味着就绪链表 rdllist 若为空则立刻返回，不会等待；-1 表示阻塞，会一直陷入 epoll_wait 状态中

关于 ET 和 LT 模式，我想用简短的语言去描述，不要深究细节。ET（边缘触发）模式仅当状态发生变化时才会感知事件的发生，即使这个事件对应的缓冲区内还有未读取的数据；而 LT（水平触发）模式是只要有数据没处理就会一直通知下去

三、Result

我想透过一个简单的 demo 来介绍 epoll 的经典用法。说到用法，最常用的就是连接 socket，监听 socket 的动静并读/写数据进行处理，之后返回给 client 结果。我写了一个小写转大写的程式来说明 epoll 的用法，请看代码，

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define EPOLL_MAXSIZE 16
#define SRV_PORT_ID 1980  /* 端口号 */
#define SOCKET_QUEUE_LEN 20
#define BUFSIZE 256

struct myepoll_data {
  int fd;
  char data[BUFSIZE];
};

int main()
{
  int i,j;
  int epfd, sockfd, nfds, clntfd;
  struct sockaddr_in srvaddr, clntaddr;
  struct epoll_event ev, evs[EPOLL_MAXSIZE];
  socklen_t clntlen = sizeof(clntaddr);
  char buf[BUFSIZE];

  /* 创建epoll结构体（就绪链表、等待队列和红黑树） */
  epfd = epoll_create(EPOLL_MAXSIZE);
  if(epfd == -1) {
    printf("epoll_create err\n");
    goto over;
  }
  printf("epoll_create ok\n");

  /* 创建socket结构体 */
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if(sockfd == -1) {
    printf("socket_create err\n");
    goto over;
  }
  printf("socket_create ok\n");
  /* 初始化socket绑定监听 */
  bzero(&srvaddr, sizeof(srvaddr));
  srvaddr.sin_family = AF_INET;
  srvaddr.sin_port = htons(SRV_PORT_ID);
  srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);

  if(bind(sockfd, (struct sockaddr*)&srvaddr, sizeof(struct sockaddr)) == -1) {
    printf("socket_bind err\n");
    goto over;
  }
  printf("socket_bind ok\n");

  if(listen(sockfd, SOCKET_QUEUE_LEN) == -1) {
    printf("socket_listen err\n");
    goto over;
  }
  printf("socket_listen ok\n");

  /* 向epoll结构体中注册socket，实现监听功能 */
  ev.data.fd = sockfd;
  ev.events = EPOLLIN | EPOLLET;
  if(epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {
    printf("epoll_ctl_add err\n");
    goto over;
  }
  printf("epoll_ctl_add ok\n");

  /* 不停地处理外来事件 */
  while(1) {
    /* 阻塞地等待事件发生，其中0为没有就绪事件就立刻返回，-1为阻塞 */
    nfds = epoll_wait(epfd, evs, EPOLL_MAXSIZE, -1);
    /* 处理每个收上来的事件 */
    for(i=0; i<nfds; i++) {
      if(evs[i].data.fd == sockfd) {  /* 有人敲sockfd的门了（收到新的连接）*/
        clntfd = accept(sockfd, (struct sockaddr*)&clntaddr, &clntlen);
        ev.events = EPOLLIN | EPOLLET;
        ev.data.fd = clntfd;

        if(epoll_ctl(epfd, EPOLL_CTL_ADD, clntfd, &ev) == -1)
          printf("epoll_ctl_add %d err\n", clntfd);
        else
          printf("epoll_ctL_add %d clnt ok\n", clntfd);
      } else if(evs[i].events & EPOLLIN) {  /* 读取数据但先不处理 */
        clntfd = evs[i].data.fd;
        memset(buf, 0, BUFSIZE);

        if(read(clntfd, buf, BUFSIZE) == 0) { /* 客户端关闭连接 */
          if(epoll_ctl(epfd, EPOLL_CTL_DEL, clntfd, NULL) == -1) {
            printf("epoll_ctl_del %d err\n", clntfd);
          } else {
            printf("epoll_ctl_del %d ok\n", clntfd);
            close(clntfd);
          }
          continue;
        }

        /* 先接收client的请求 */
        struct myepoll_data fddata;
        fddata.fd = clntfd;
        strcpy(fddata.data, buf);
        ev.data.ptr = &fddata;
        memset(buf, 0, BUFSIZE);
        strcpy(buf, "i'm keep u's data, deal with it later, please check u can be written...\n");
        send(clntfd, buf, strlen(buf), 0);

        ev.events = EPOLLOUT | EPOLLET;
        /* 下一次epoll时再处理client的请求 */
        if(epoll_ctl(epfd, EPOLL_CTL_MOD, clntfd, &ev) == -1) 
          printf("epoll_ctl_mod clnt %d EPOLLIN -> EPOLLOUT err\n", clntfd);
        else 
          printf("epoll_ctl_mod clnt %d EPOLLIN -> EPOLLOUT ok\n", clntfd);
      } else if(evs[i].events & EPOLLOUT) { /* 对之前读取的数据予以处理并将处理结果返回给client */
        struct myepoll_data* fddata = (struct myepoll_data*)evs[i].data.ptr;
        clntfd = fddata->fd;
        char* data = fddata->data;

        memset(buf, 0, BUFSIZE);
        strcpy(buf, "i'm processing u's data, please waiting...\n");
        send(clntfd, buf, strlen(buf), 0);

        /* 将小写转为大写的业务逻辑 */
        for(j=0; j<strlen(data); j++)
          data[j] = toupper(data[j]);
        send(clntfd, data, strlen(data), 0);

        ev.events = EPOLLIN | EPOLLET;
        /* 准备接收client的下一次计算请求 */
        if(epoll_ctl(epfd, EPOLL_CTL_MOD, clntfd, &ev) == -1)
          printf("epoll_ctl_mod clnt %d EPOLLOUT -> EPOLLIN err\n", clntfd);
        else 
          printf("epoll_ctl_mod clnt %d EPOLLOUT -> EPOLLIN ok\n", clntfd);
      } else {
        printf("unknown event\n");
      }
    }
  }

over:
  return 0;
}

整个流程，我认为较为清晰，首先创建 socket，然后将 socket 添加进 epoll 对象中，这就意味着让 epoll 对象监听 socket 的一举一动。如果有数据写入 socket 中，那么就读出来，等待下一轮再进行处理（为什么下一轮再进行处理？而不是接收了请求就处理，其中的道理我想可能是 server 想用最快的速度把所有请求都收下来，这样的话，client 就不会陷入阻塞状态

client 什么时候会陷入阻塞？当 client 缓冲区满的状态时它就会陷入阻塞状态。那么缓冲区为什么会满？归根到底还是 server 没把数据给读走，所以导致缓冲区满了

按照流程走下去，在下一轮中进行处理（小写转大写），然后将结果返回给 client。这就是 epoll demo。在另一个终端中透过 nc 命令尝试连接 server 进程，

nc 127.0.0.1 1980

作为 client，输入小写的字符串，server 就会返回大写的结果，