epoll函数

转自：
http://blog.youkuaiyun.com/penzo/article/details/5986574

epoll的几个函数的介绍。

1、epoll_create函数

/**  
 * @brief    该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。 
 *  
 * @param    size    size就是你在这个epoll fd上能关注的最大socket fd数 
 *  
 * @return   生成的文件描述符 
 */  
int epoll_create(int size);  

 

2、epoll_ctl函数

/**  
 * @brief    该函数用于控制某个epoll文件描述符上的事件，可以注册事件，修改事件，删除事件。 
 *  
 * @param    epfd    由 epoll_create 生成的epoll专用的文件描述符 
 * @param    op      要进行的操作例如注册事件，可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除 
 * @param    fd      关联的文件描述符 
 * @param    event   指向epoll_event的指针 
 *  
 * @return   0       succ 
 *           -1      fail 
 */  
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);  

其中用到的数据结构结构如下：
op值：
EPOLL_CTL_ADD：注册新的fd到epfd中；

EPOLL_CTL_MOD：修改已经注册的fd的监听事件；

EPOLL_CTL_DEL：从epfd中删除一个fd；

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 */
};

常用的事件类型:
EPOLLIN ：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 表示对应的文件描述符有事件发生；

例：

struct epoll_event ev;  
//设置与要处理的事件相关的文件描述符  
ev.data.fd=listenfd;  
//设置要处理的事件类型  
ev.events=EPOLLIN|EPOLLET;  
//注册epoll事件  
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); 

3、epoll_wait函数

 

/**  
 * @brief    该函数用于轮询I/O事件的发生 
 *  
 * @param    epfd        由epoll_create 生成的epoll专用的文件描述符 
 * @param    events      用于回传代处理事件的数组 
 * @param    maxevents   每次能处理的事件数 
 * @param    timeout     等待I/O事件发生的超时值；-1相当于阻塞，0相当于非阻塞。一般用-1即可 
 *  
 * @return   >=0         返回发生事件数 
 *           -1          错误 
 */  
int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout);  

好了，其实在epoll的使用中无非就用到了上面介绍的几个函数，下面贴一段用epoll实现的服务器代码：

 

#include <stdio.h>  
#include <stdlib.h>  
#include <errno.h>  
#include <string.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <sys/wait.h>  
#include <unistd.h>  
#include <arpa/inet.h>  
#include <openssl/ssl.h>  
#include <openssl/err.h>  
#include <fcntl.h>  
#include <sys/epoll.h>  
#include <sys/time.h>  
#include <sys/resource.h>  
#define MAXBUF 1024  
#define MAXEPOLLSIZE 10000  
/* 
   setnonblocking - 设置句柄为非阻塞方式 
   */  
int setnonblocking(int sockfd)  
{  
    if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  
    {  
        return -1;  
    }  
    return 0;  
}  
/* 
   handle_message - 处理每个 socket 上的消息收发 
   */  
int handle_message(int new_fd)  
{  
    char buf[MAXBUF + 1];  
    int len;  
    /* 开始处理每个新连接上的数据收发 */  
    bzero(buf, MAXBUF + 1);  
    /* 接收客户端的消息 */  
    len = recv(new_fd, buf, MAXBUF, 0);  
    if (len > 0)  
    {  
        printf("%d接收消息成功:'%s'，共%d个字节的数据/n",  
             new_fd, buf, len);  
    }  
    else  
    {  
        if (len < 0)  
            printf  
                ("消息接收失败！错误代码是%d，错误信息是'%s'/n",  
                 errno, strerror(errno));  
        close(new_fd);  
        return -1;  
    }  
    /* 处理每个新连接上的数据收发结束 */  
    return len;  
}  
int main(int argc, char **argv)  
{  
    int listener, new_fd, kdpfd, nfds, n, ret, curfds;  
    socklen_t len;  
    struct sockaddr_in my_addr, their_addr;  
    unsigned int myport, lisnum;  
    struct epoll_event ev;  
    struct epoll_event events[MAXEPOLLSIZE];  
    struct rlimit rt;  
    myport = 5000;  
    lisnum = 2;   
    /* 设置每个进程允许打开的最大文件数 */  
    rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;  
    if (setrlimit(RLIMIT_NOFILE, &rt) == -1)   
    {  
        perror("setrlimit");  
        exit(1);  
    }  
    else   
    {  
        printf("设置系统资源参数成功！/n");  
    }  
    /* 开启 socket 监听 */  
    if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)  
    {  
        perror("socket");  
        exit(1);  
    }  
    else  
    {  
        printf("socket 创建成功！/n");  
    }  
    setnonblocking(listener);  
    bzero(&my_addr, sizeof(my_addr));  
    my_addr.sin_family = PF_INET;  
    my_addr.sin_port = htons(myport);  
    my_addr.sin_addr.s_addr = INADDR_ANY;  
    if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)   
    {  
        perror("bind");  
        exit(1);  
    }   
    else  
    {  
        printf("IP 地址和端口绑定成功/n");  
    }  
    if (listen(listener, lisnum) == -1)   
    {  
        perror("listen");  
        exit(1);  
    }  
    else  
    {  
        printf("开启服务成功！/n");  
    }  
    /* 创建 epoll 句柄，把监听 socket 加入到 epoll 集合里 */  
    kdpfd = epoll_create(MAXEPOLLSIZE);  
    len = sizeof(struct sockaddr_in);  
    ev.events = EPOLLIN | EPOLLET;  
    ev.data.fd = listener;  
    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)   
    {  
        fprintf(stderr, "epoll set insertion error: fd=%d/n", listener);  
        return -1;  
    }  
    else  
    {  
        printf("监听 socket 加入 epoll 成功！/n");  
    }  
    curfds = 1;  
    while (1)   
    {  
        /* 等待有事件发生 */  
        nfds = epoll_wait(kdpfd, events, curfds, -1);  
        if (nfds == -1)  
        {  
            perror("epoll_wait");  
            break;  
        }  
        /* 处理所有事件 */  
        for (n = 0; n < nfds; ++n)  
        {  
            if (events[n].data.fd == listener)   
            {  
                new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);  
                if (new_fd < 0)   
                {  
                    perror("accept");  
                    continue;  
                }   
                else  
                {  
                    printf("有连接来自于： %d:%d， 分配的 socket 为:%d/n",  
                            inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);  
                }  
                setnonblocking(new_fd);  
                ev.events = EPOLLIN | EPOLLET;  
                ev.data.fd = new_fd;  
                if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)  
                {  
                    fprintf(stderr, "把 socket '%d' 加入 epoll 失败！%s/n",  
                            new_fd, strerror(errno));  
                    return -1;  
                }  
                curfds++;  
            }   
            else  
            {  
                ret = handle_message(events[n].data.fd);  
                if (ret < 1 && errno != 11)  
                {  
                    epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);  
                    curfds--;  
                }  
            }  
        }  
    }  
    close(listener);  
    return 0;  
}  

转载：http://www.vimer.cn/2009/11/epoll%E4%BD%BF%E7%94%A8%E5%AE%9E%E4%BE%8B%E8%AF%B4%E6%98%8E.html

 

epoll与select/poll的区别

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

select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显 然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的 Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完 美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左 右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

2.IO效率不随FD数目增加而线性下降

传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，但 是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操 作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相 反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。

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

这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很 重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注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网 卡驱动架构LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表． 

epoll工作模式

LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

ET(edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认（这句话不理解）。 

epoll工作在LT模式下和传统的poll/select一模一样的，epoll，select和poll的fd集里面的fd是可以阻塞或者非阻塞的方式来访问fd。但是epoll工作在ET模式的时候就只能工作在非阻塞模式下面了。

 

转载：http://blog.chinaunix.net/u2/76430/showart_1275186.html