I/O多路复用（二）：epoll模型详解

epoll的优点
1.支持一个进程打开大数目的socket描述符(FD)

select 中一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是1024。

在usr/include/linux/posix_types.h头文件有这样的声明：

#define __FD_SETSIZE    1024

对于那些需要支持的上万连接数目的服务器来说显然太少了。这时候可以选择修改这个宏，但似乎治标不治本，

二是可以选择多进程的解决方案，虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，

加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。

epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于1024，

具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

 

2.IO效率不随FD数目增加而线性下降
传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，

但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，

它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。

那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会。

 

 

3.使用mmap加速内核与用户空间的消息传递

　　这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。

 

4.内核微调

　　这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool（skb_head_pool）的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数（TCP完成3次握手的数据包队列长度），也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。

 

epoll简介

epoll的接口非常简单，一共就三个函数：
1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。

这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。

注意：当创建好epoll句柄后，它就是会占用一个fd值，所以在使用完epoll后，

必须调用close()关闭，否则可能导致fd被耗尽。

 

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。

第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：

EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；

第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，

struct epoll_event结构如下：
struct epoll_event {
　　__uint32_t events;  /* Epoll events */
　　epoll_data_t data;  /* User data variable */
};

epoll_data_t联合如下：

typedef union epoll_data {
　　void *ptr;
　　int fd;
　　uint32_t u32;
　　uint64_t u64;
} epoll_data_t;

events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里


3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，

这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。

该函数返回需要处理的事件数目，如返回0表示已超时。

 

以下是epoll的例子：

用epoll实现的多客户聊天的服务器，客户端成功连接服务器之后，可以和其他客户进行群聊。

与http://www.cnblogs.com/chris12/archive/2012/08/23/2653249.html中的例子的功能一模一样。

以下只列出服务端部分的代码，客户端代码可使用上面的链接中代码。

 

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <strings.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/epoll.h>

#define MAX_CLI 2048 //最大客户数

void main(void)
{
　　struct sockaddr_in ser;
　　struct sockaddr_in peer;
　　int epfd; 　　　　　　　　 //创建epoll描述符
　　int ser_fd;
　　int cli_fd;
　　int cli[MAX_CLI]; 　　　　 //存放客户端fd的数组
　　int i,j;

　　int max_cli_i = 0; 　　　　 //存放客户端fd的数组的最大下标
　　int nfds; 　　　　　　　　 //epoll_wait返回值，返回需要处理的事件数目
　　char buf[1024]; 　　　　　　 //接收缓冲区
　　int cli_num = 0; 　　　　　　 //成功连接的客户数

　　int peer_len = sizeof(peer);

　　bzero(&ser, sizeof(ser));
　　bzero(&peer, sizeof(peer));

　　ser.sin_family = AF_INET;
　　ser.sin_port = htons(9678);
　　ser.sin_addr.s_addr = htonl(INADDR_ANY);

　　ser_fd = socket(AF_INET, SOCK_STREAM, 0);


　　bind(ser_fd, (struct sockaddr*)&ser, sizeof(ser));

　　listen(ser_fd, 5);

　　for(i = 0; i < MAX_CLI; i++)
　　　　cli[i] = -1;

　　struct epoll_event ev； 　　　　　　　　 //用于注册事件
　　struct epoll_event event[MAX_CLI]; 　　//用于回传要处理的事件

　　ev.data.fd = ser_fd;
　　ev.events = EPOLLIN;

　　epfd = epoll_create(MAX_CLI); 　　　　 //创建epoll
　　epoll_ctl(epfd, EPOLL_CTL_ADD, ser_fd, &ev);

　　for(;;){
　　　　nfds = epoll_wait(epfd, event, MAX_CLI, 0);
　　　　if(nfds < 0)
　　　　　　perror("epoll_wait failed");
　　　　else if(0 == nfds)
　　　　　　; //perror("epoll time out");
　　　　else{
　　　　　　for(i = 0; i < nfds; i++){
　　　　　　　　if(event[i].data.fd == ser_fd){
　　　　　　　　　　cli_fd = accept(ser_fd, (struct sockaddr*)&peer, &peer_len);
　　　　　　　　　　if(cli_fd < 0){
　　　　　　　　　　　　perror("accept failed\n");
　　　　　　　　　　　　continue;
　　　　　　　　　　}

　　　　　　　　　　ev.data.fd = cli_fd;
　　　　　　　　　　ev.events = EPOLLIN;
　　　　　　　　　　cli_num++; 　　　　 　　 //成功连接后，客户连接数自增
　　　　　　　　　　for(j = 0; j < MAX_CLI; j++){ //记录最大cli数组下标
　　　　　　　　　　　　if(j > max_cli_i)
　　　　　　　　　　　　　　max_cli_i = j;
　　　　　　　　　　　　if(cli[j] < 0){
　　　　　　　　　　　　　　cli[j] = cli_fd;
　　　　　　　　　　　　　　break;
　　　　　　　　　　　　}
　　　　　　　　　　}

　　　　　　　　　　printf("the num of clients is %d\n", cli_num);
　　　　　　　　　　epoll_ctl(epfd, EPOLL_CTL_ADD, cli_fd, &ev);
　　　　　　　　}else if(event[i].events & EPOLLIN){
　　　　　　　　　　if(event[i].data.fd < 0)
　　　　　　　　　　　　continue;
　　　　　　　　　　if(read(event[i].data.fd, buf, sizeof(buf)) <= 0){
　　　　　　　　　　　　perror("read failed\n");
　　　　　　　　　　　　close(event[i].data.fd);
　　　　　　　　　　　　--cli_num;
　　　　　　　　　　　　printf("cli %d is out of connect\n", event[i].data.fd);

　　　　　　　　　　　　ev.data.fd = event[i].data.fd;
　　　　　　　　　　　　epoll_ctl(epfd, EPOLL_CTL_DEL, ev.data.fd, &ev);
　　　　　　　　　　　　for(j = 0; j <= max_cli_i; j++){
　　　　　　　　　　　　　　if(event[i].data.fd == cli[j])
　　　　　　　　　　　　　　　　cli[j] = -1;
　　　　　　　　　　　　}
　　　　　　　　　　　　event[i].data.fd = -1;
　　　　　　　　　　　　continue;
　　　　　　　　　　}else{
　　　　　　　　　　　　　for(j = 0; j <= max_cli_i; j++){
　　　　　　　　　　　　　　　　if(cli[j] < 0 || cli[j] == event[i].data.fd)
　　　　　　　　　　　　　　　　　　　　continue;
　　　　　　　　　　　　　　　　if(send(cli[j], buf, sizeof(buf), 0) <= 0){ //群发
　　　　　　　　　　　　　　　　　　　　perror("send failed");
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　printf("recv from %d : %s\n", event[i].data.fd, buf);
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}
　　}
}