libevent库源码学习-poll/select（ linux） .devpoll（/dev/poll）（ linux） ，epoll(linux)

http://blog.csdn.net/hcwzq/article/details/7526088

libevent库源码学习-poll/select（ linux）

这两种实际上差不多，都是把一组fd传送给kernal，然后返回一个就绪fd的数量，然后开始遍历所有的fd，找到那些可读或者可写的。

区别在于，poll相比select来说，传送给kernal的数组要小，这可能是它唯一的优势，其他方面区别不大....

api

1 int select(int fdsp1, fd_set *readfds, fd_set *writefds, fd_set *errorfds, const struct timeval *timeout);
各个参数含义如下：

• int fdsp1:最大描述符值 + 1
• fd_set *readfds:对可读感兴趣的描述符集
• fd_set *writefds:对可写感兴趣的描述符集
• fd_set *errorfds:对出错感兴趣的描述符集
• struct timeval *timeout:超时时间（注意：对于linux系统，此参数没有const限制，每次select调用完毕timeout的值都被修改为剩余时间，而unix系统则不会改变timeout值）

select函数会在发生以下情况时返回：

1. readfds集合中有描述符可读
2. writefds集合中有描述符可写
3. errorfds集合中有描述符遇到错误条件
4. 指定的超时时间timeout到了

当select返回时，描述符集合将被修改以指示哪些个描述符正处于可读、可写或有错误状态。可以用FD_ISSET宏对描述符进行测试以找到状态变化的描述符。如果select因为超时而返回的话，所有的描述符集合都将被清空。
select函数返回状态发生变化的描述符总数。返回0意味着超时。失败则返回-1并设置errno。可能出现的错误有：EBADF（无效描述符）、EINTR（因终端而返回）、EINVAL（nfds或timeout取值错误）。
设置描述符集合通常用如下几个宏定义：

1  FD_ZERO(fd_set  * fdset);                 /*  clear all bits in fdset            */
2  FD_SET( int  fd, fd_set  * fdset);          /*  turn on the bit for fd in fd_set   */
3  FD_CLR( int  fd, fd_set  * fdset);          /*  turn off the bit for fd in fd_set  */
4  int  FD_ISSET( int  fd, fd_set  * fdset);    /*  is the bit for fd on in fdset?     */

如:

1  fd_set rset;
2  FD_ZERO( & rset);                         /*  initialize the set: all bits off   */
3  FD_SET( 1 ,  & rset);                       /*  turn on bit for fd 1               */
4  FD_SET( 4 ,  & rset);                       /*  turn on bit for fd 4               */
5  FD_SET( 5 ,  & rset);                       /*  turn on bit for fd 5               */

当select返回的时候，rset位都将被置0，除了那些有变化的fd位。
当发生如下情况时认为是可读的：

1. socket的receive buffer中的字节数大于socket的receive buffer的low-water mark属性值。（low-water mark值类似于分水岭，当receive buffer中的字节数小于low-water mark值的时候，认为socket还不可读，只有当receive buffer中的字节数达到一定量的时候才认为socket可读）
2. 连接半关闭（读关闭，即收到对端发来的FIN包）
3. 发生变化的描述符是被动套接字，而连接的三路握手完成的数量大于0，即有新的TCP连接建立
4. 描述符发生错误，如果调用read系统调用读套接字的话会返回-1。

当发生如下情况时认为是可写的：

1. socket的send buffer中的字节数大于socket的send buffer的low-water mark属性值以及socket已经连接或者不需要连接（如UDP）。
2. 写半连接关闭，调用write函数将产生SIGPIPE
3. 描述符发生错误，如果调用write系统调用写套接字的话会返回-1。

注意：
select默认能处理的描述符数量是有上限的，为FD_SETSIZE的大小。
对于timeout参数，如果置为NULL，则表示wait forever；若timeout->tv_sec = timeout->tv_usec = 0，则表示do not wait at all；否则指定等待时间。
如果使用select处理多个套接字，那么需要使用一个数组（也可以是其他结构）来记录各个描述符的状态。而使用poll则不需要，下面看poll函数。

2 int poll(struct pollfd *fdarray, unsigned long nfds, int timeout);
各参数含义如下：

• struct pollfd *fdarray:一个结构体，用来保存各个描述符的相关状态。
• unsigned long nfds:fdarray数组的大小，即里面包含有效成员的数量。
• int timeout:设定的超时时间。（以毫秒为单位）

poll函数返回值及含义如下：

• -1：有错误产生
• 0：超时时间到，而且没有描述符有状态变化
• >0：有状态变化的描述符个数

着重讲fdarray数组，因为这是它和select()函数主要的不同的地方：
pollfd的结构如下：

1  struct  pollfd {
2      int  fd;                   /*  descriptor to check  */
3      short  events;       /*  events of interest on fd  */
4      short  revents;      /*  events that occured on fd  */
5  };

其实poll()和select()函数要处理的问题是相同的，只不过是不同组织在几乎相同时刻同时推出的，因此才同时保留了下来。select()函数把可读描述符、可写描述符、错误描述符分在了三个集合里，这三个集合都是用bit位来标记一个描述符，一旦有若干个描述符状态发生变化，那么它将被置位，而其他没有发生变化的描述符的bit位将被clear，也就是说select()的readset、writeset、errorset是一个value-result类型，通过它们传值，而也通过它们返回结果。这样的一个坏处是每次重新select 的时候对集合必须重新赋值。而poll()函数则与select()采用的方式不同，它通过一个结构数组保存各个描述符的状态，每个结构体第一项fd代表描述符，第二项代表要监听的事件，也就是感兴趣的事件，而第三项代表poll()返回时描述符的返回状态。合法状态如下：

• POLLIN:                有普通数据或者优先数据可读
• POLLRDNORM:    有普通数据可读
• POLLRDBAND:    有优先数据可读
• POLLPRI:              有紧急数据可读
• POLLOUT:            有普通数据可写
• POLLWRNORM:   有普通数据可写
• POLLWRBAND:    有紧急数据可写
• POLLERR:            有错误发生
• POLLHUP:            有描述符挂起事件发生
• POLLNVAL:          描述符非法

对于POLLIN | POLLPRI等价与select()的可读事件；POLLOUT | POLLWRBAND等价与select()的可写事件；POLLIN 等价与POLLRDNORM | POLLRDBAND，而POLLOUT等价于POLLWRBAND。如果你对一个描述符的可读事件和可写事件以及错误等事件均感兴趣那么你应该都进行相应的设置。
对于timeout的设置如下：

• INFTIM:   wait forever
• 0:            return immediately, do not block
• >0:         wait specified number of milliseconds

使用的方式也都差不多，返回后，都要遍历一遍数组，从而确定那个fd是就绪的

 

libevent库源码学习-devpoll（/dev/poll）（ linux）

1.初始化
使用
fd = open(“/dev/poll”, flags, (mode_t)mode);获得文件描述符

2.增加事件
struct pollfd *events;
pwrite(fd, events,sizeof(struct pollfd) * eventsnum, 0) 直接往里边写

3.删除事件
使用 POLLREMOVE 事件，然后把这个时间用增加时间的方法写入/dev/poll，系统会自动将我们要删除的描述符时间删除


4.监听事件

struct dvpoll {
        struct pollfd *dp_fds;
        int dp_nfds;
        int dp_timeout;
    }

struct dvpoll dvp;
res = ioctl(devpollop->dpfd, DP_POLL, &dvp);返回事件发生的个数

用个for遍历一遍即可
for (i = 0; i < res; i++) {
int which = 0;
int what = dvp.dp_fds[i].revents;

if (what & POLLHUP)
what |= POLLIN | POLLOUT;
else if (what & POLLERR)
what |= POLLIN | POLLOUT;

if (what & POLLIN)
which |= EV_READ;
if (what & POLLOUT)
which |= EV_WRITE;


if (!which)
continue;
。。。
}

libevent库源码学习-epoll（ linux）

转自：
http://blog.csdn.net/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);

/**  
 * @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);

/**  
 * @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： 表示对应的文件描述符有事件发生；

例：

"BACKGROUND-COLOR: rgb(240,240,240); MARGIN: 4px 0px" class=cpp name="code">struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

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

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

#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#include   
#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