epoll学习及实例

         epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，是IO多路复用的一种技术。它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。

         在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。

相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明：
#define __FD_SETSIZE    1024
表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内核来扩大这个数目，但这似乎并不治本。

epoll比select效率高的原因

epoll精巧的使用了3个方法来实现select方法要做的事：

新建epoll描述符==epoll_create()
epoll_ctrl(epoll描述符，添加或者删除所有待监控的连接)
返回的活跃连接 ==epoll_wait（epoll描述符）

而select只有一个接口做了这三件事：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

与select相比，epoll分清了频繁调用和不频繁调用的操作。

例如，epoll_ctl是不太频繁调用的，而epoll_wait是非常频繁调用的。
这时，epoll_wait却几乎没有入参，这比select的效率高出一大截，

而且，它也不会随着并发连接的增加使得入参越发多起来，导致内核执行效率下降。

1.数据结构

在select中采用轮询处理，其中的数据结构类似一个数组的数据结构，轮询时线性遍历。
而epoll是维护一个队列，直接看队列是不是空就可以了。

2.内核与用户空间的消息传递--内存拷贝

无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，就避免不了内存拷贝。
每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大;
而epoll只需要拷贝一次(epoll_ctl的add)，epoll是通过内核与用户空间mmap同一块内存实现的。

3.遍历效率上

select每调用一次，就需要轮询fd集合中的所有描述符，而且不管socket是否活跃，都会遍历一遍。
epoll只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。
那么，只有"活跃"的socket才会主动的去调用callback函数（把这个句柄加入队列），空闲状态的描述符则不会。

但是如果绝大部分的I/O都是 “活跃的”，每个I/O端口使用率很高的话，epoll效率不一定比select高（可能是要维护队列复杂）。

epoll的接口非常简单，一共就三个函数：
1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个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结构如下：

typedef union epoll_data {
    void *ptr;
    int fd;
    __uint32_t u32;
    __uint64_t u64;
} epoll_data_t;

struct epoll_event {
    __uint32_t events; /* Epoll events */
    epoll_data_t data; /* User data variable */
};

events可以是以下几个宏的集合：

EPOLLIN
              The associated file is available for read(2) operations.
EPOLLOUT
              The associated file is available for write(2) operations.
EPOLLRDHUP
              Stream  socket peer closed connection, or shut down writing half
              of connection.  (This flag is especially useful for writing sim-
              ple code to detect peer shutdown when using Edge Triggered moni-
              toring.)
EPOLLPRI
              There is urgent data available for read(2) operations.
EPOLLERR
              Error condition happened  on  the  associated  file  descriptor.
              epoll_wait(2)  will always wait for this event; it is not neces-
              sary to set it in events.
EPOLLHUP
              Hang  up   happened   on   the   associated   file   descriptor.
              epoll_wait(2)  will always wait for this event; it is not neces-
              sary to set it in events.
EPOLLET
              Sets  the  Edge  Triggered  behavior  for  the  associated  file
              descriptor.   The default behavior for epoll is Level Triggered.
              See epoll(7) for more detailed information about Edge and  Level
              Triggered event distribution architectures.
EPOLLONESHOT (since Linux 2.6.2)
              Sets  the  one-shot behavior for the associated file descriptor.
              This means that after an event is pulled out with  epoll_wait(2)
              the  associated  file  descriptor  is internally disabled and no
              other events will be reported by the epoll interface.  The  user
              must  call  epoll_ctl() with EPOLL_CTL_MOD to re-enable the file
              descriptor with a new event mask.

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将永久阻塞）。该函数返回需要处理的fd数，如返回-1表示发生错误。

4、ET、LT两种工作模式
epoll 的事件触发模式两种：默认的 level-trigger 模式，以及通过 EPOLLET 启用的 edge-trigger 模式两种。

从 epoll 发展历史来看，它刚诞生时只有 edge-trigger 模式，后来因不易被开发者理解，又增加了 level-trigger 模式并作为默认处理方式。

二者的差异在于level-trigger模式下只要某个socket处于readable/writable状态，无论什么时候进行epoll_wait都会返回该socket；

而edge-trigger模式下只有某个socket从unreadable变为readable或从unwritable变为writable时，epoll_wait才会返回该socket。

从 kernel 代码来看，ET/LT模式的处理逻辑几乎完全相同，差别仅在于LT模式在event 发生时不会将fd从 ready list 中移除，略微增大了 event 处理过程中 kernel space 中记录数据的大小。

edge-trigger 模式的真正优势在于减少了每次 epoll_wait 可能需要返回的 fd 数量，在并发 event 数量极多的情况下能加快 epoll_wait 的处理速度。

然而，edge-trigger 模式一定要配合 ready list 结构，以便收集已出现 event 的 fd，再通过轮询方式挨个处理，以此避免通信数据量很大时，出现忙于处理热点 fd 而导致非热点 fd 饿死的现象。

edge-trigger 虽然能加快epoll_wait 的处理速度，但别忘了这只是针对 epoll 体系自己而言的提升，与此同时开发者 需要增加复杂的逻辑、花费更多的 cpu/mem 与其配合工作，总体性能收益究竟如何？只有实际测量才知道，无法一概而论。所以，为了降低处理逻辑复杂度，常用的事件处理库大部分都选择了 level-trigger 模式（如 libevent、boost::asio等）。

结论：
1. epoll 的 edge-trigger 和 level-trigger 模式处理逻辑差异极小，性能测试结果表明常规应用场景中二者性能差异可以忽略。
2. 使用 edge-trigger 的用户态开发比使用 level-trigger 的逻辑复杂，出错概率更高。
3. edge-trigger 和 level-trigger 的性能差异主要在于 epoll_wait 系统调用的处理速度，是否是 user app 的性能瓶颈需要视应用场景而定，不可一概而论。

5. 实例应用
那么究竟如何来使用epoll呢？其实非常简单。
通过在包含一个头文件#include <sys/epoll.h> 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。

首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。

之后在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。

epoll_wait范围之后应该是一个循环，遍利所有的事件。

几乎所有的epoll程序都使用下面的框架：

for( ; ; )
    {
        nfds = epoll_wait(epfd,events,20,500);
        for(i=0;i<nfds;++i)
        {
            if(events[i].data.fd==listenfd) //有新的连接
            {
                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen); //accept这个连接
                ev.data.fd=connfd;
                ev.events=EPOLLIN|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); //将新的fd添加到epoll的监听队列中
            }
            else if( events[i].events&EPOLLIN ) //接收到数据，读socket
            {
                n = read(sockfd, line, MAXLINE)) < 0    //读
                ev.data.ptr = md;     //md为自定义类型，添加数据
                ev.events=EPOLLOUT|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);//修改标识符，等待下一个循环时发送数据，异步处理的精髓
            }
            else if(events[i].events&EPOLLOUT) //有数据待发送，写socket
            {
                struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;    //取数据
                sockfd = md->fd;
                send( sockfd, md->ptr, strlen((char*)md->ptr), 0 );        //发送数据
                ev.data.fd=sockfd;
                ev.events=EPOLLIN|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改标识符，等待下一个循环时接收数据
            }
            else
            {
                //其他的处理
            }
        }
    }

下面给出一个完整的服务器端例子，客户端直接连接到这个服务器就好了。

#include <iostream>
#include <cstdlib>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

using namespace std;

#define MAXLINE 80
#define LISTENQ 20
#define SERV_PORT 8000

int SetNonBlock(int iSock)
{
    int iFlags;

    iFlags = fcntl(iSock, F_GETFL, 0);
    iFlags |= O_NONBLOCK;
    iFlags |= O_NDELAY;
    int ret = fcntl(iSock, F_SETFL, iFlags);
    return ret;
}

int WriteNonBlock(int fd_, const char* send_buf, size_t send_len)
{
    int write_pos = 0;//发送位置
    int nLeft = send_len;//表示未发完的数据
    while(nLeft > 0)
    {
        int nWrite = write(fd_, send_buf + write_pos, nLeft);//已发完的数据长度
        if(nWrite == 0)//socket已关闭，发送失败
        {
            return -1;
        }
        if( nWrite < 0)
        {
            if(errno == EWOULDBLOCK || errno == EAGAIN)//没有空间可写数据
            {
                nWrite = 0;
            }else if(errno == EINTR){//连接正常，操作被中断，可继续发送
                continue;
            }
            else
            {
                return -1;
            }
        }
        else//发送成功
        {
            nLeft -= nWrite;
            write_pos += nWrite;
        }
    }
    return 0;
}

int ReadNonBlock(int fd_, char* recv_buf, size_t recv_len)
{
    while(1)
    {
        int ret = read(fd_, recv_buf, recv_len);
        if(ret > 0){//接收成功
            return 0;
        }
        if(ret == 0){//socket已关闭，发送失败
            return -1;
        }
        if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR){
            continue;
        }
    }
    return -1;
}

int main(int argc, char* argv[])
{
    int i, listenfd, connfd, epfd, nfds, portnumber=SERV_PORT;
    ssize_t n=-1;
    char line[MAXLINE];
    socklen_t clilen;
   
    struct sockaddr_in clientaddr;
    struct sockaddr_in serveraddr;
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if(listenfd <= 0){
        cout<<"create fd fail"<<endl;
        return -1;
    }
    SetNonBlock(listenfd);

    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
    struct epoll_event ev,events[20];
    //生成用于处理accept的epoll专用的文件描述符
    epfd=epoll_create(256);
    //设置与要处理的事件相关的文件描述符
    ev.data.fd=listenfd;
    //设置要处理的事件类型
    ev.events=EPOLLIN|EPOLLET;
    //ev.events=EPOLLIN;

    //注册epoll事件
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

    //listenfd绑定ip地址
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char local_addr[20]="127.0.0.1";
    inet_aton(local_addr,&(serveraddr.sin_addr));
    serveraddr.sin_port=htons(portnumber);
    
    //bind和listen不是阻塞函数
    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);

    cout << "server listening ..."  << endl;

    int ret = -1;

    for ( ; ; ) 
    {
        //等待epoll事件的发生
        nfds=epoll_wait(epfd,events,20,-1);

        //处理所发生的所有事件
        for(i=0;i<nfds;++i)
        {
            if(events[i].data.fd == listenfd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接
            {
                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);//以后读写都用这个返回的fd
                if(connfd < 0){
                    perror("connfd<0,accept fail");
                    exit(1);
                }
                SetNonBlock(connfd);//设置为非阻塞模式
                char *str = inet_ntoa(clientaddr.sin_addr);
                cout << "accapt a connection from " << str << endl;
                
                ev.data.fd=connfd;
                ev.events=EPOLLIN|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
            }
            else if(events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入
            {
                connfd = events[i].data.fd;

                ret = ReadNonBlock(connfd, line, MAXLINE);
                if(ret != 0){
                    cout<<"read line fail"<<endl;
                    close(connfd);
                    break;
                }
                cout << "receive:" << line << endl;

                ev.data.fd = connfd;
                ev.events = EPOLLOUT|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_MOD, connfd, &ev);//修改标识符，等待下一个循环时发送数据，异步处理的精髓
            }
            else if(events[i].events & EPOLLOUT) // 如果有数据发送
            {
                connfd = events[i].data.fd;

                //将从client接收到的字母转化为大写，回送给client
                for (int i = 0; i < n; i++)
               		line[i] = toupper(line[i]);

                ret = WriteNonBlock(connfd, line, MAXLINE);
                if(ret != 0){
                    cout<<"send line fail"<<endl;
                    close(connfd);
                    break;
                }
                cout << "send:" << line << endl;

                ev.data.fd = connfd;
                ev.events = EPOLLIN|EPOLLET;
                epoll_ctl(epfd,EPOLL_CTL_MOD, connfd, &ev);
            }
        }
    }
    return 0;
}

注意：epoll在非阻塞模式下，才能发挥最大性能，所以这里的读写操作，都是非阻塞的方式。