epoll机制 linux
2018-10-31 01:29:07 mingC0758 阅读数 74

阻塞和非阻塞轮询
当缓冲区为空的时候我们需要阻塞起来(线程切换消耗资源),或者不断地进行轮询(消耗CPU)。

缺点

  • 阻塞的缺点是:只能处理一个线程的IO流。
  • 非阻塞轮训可以同时处理多个流,我们只要不停的把所有流从头到尾问一遍,又从头开始。这样就可以处理多个流了,但这样的做法显然不好,因为如果所有的流都没有数据,那么只会白白浪费CPU。

SELECT O(n)

  • 可以避免轮询带来的CPU空转。
  • 引入一个SELECT代理,这个代理可以同时观察多个IO流,当所有IO空闲的时候把线程阻塞起来,否则就对所有IO流进行无差别轮询,就可以知道是哪个IO流需要CPU了。

epoll O(k)
epoll可以理解为event poll,不同于忙轮询和无差别轮询,epoll之会把哪个流发生了怎样的I/O事件通知我们。此时我们对这些流的操作都是有意义的。(复杂度降低到了O(k),k为产生I/O事件的流的个数,也有认为O(1)的)
在讨论epoll的实现细节之前,先把epoll的相关操作列出:
epoll_create 创建一个epoll对象,一般epollfd = epoll_create()
epoll_ctl (epoll_add/epoll_del的合体),往epoll对象中增加/删除某一个流的某一个事件
比如
epoll_ctl(epollfd, EPOLL_CTL_ADD, socket, EPOLLIN);//有缓冲区内有数据时epoll_wait返回
epoll_ctl(epollfd, EPOLL_CTL_DEL, socket, EPOLLOUT);//缓冲区可写入时epoll_wait返回
epoll_wait(epollfd,…)等待直到注册的事件发生
(注:当对一个非阻塞流的读写发生缓冲区满或缓冲区空,write/read会返回-1,并设置errno=EAGAIN。而epoll只关心缓冲区非满和缓冲区非空事件)。
一个epoll模式的代码大概的样子是:

while true {
	active_stream[] = epoll_wait(epollfd)
	for i in active_stream[] {
		read or write till unavailable	
	}
}
2015-03-09 11:10:32 u010657219 阅读数 2815

在linux 没有实现epoll事件驱动机制之前,我们一般选择用select或者poll等IO多路复用的方法来实现并发服务程序。在linux新的内核中,有了一种替换它的机制,就是epoll。

select()和poll() IO多路复用模型

select的缺点:
1.单个进程能够监视的文件描述符的数量存在最大限制,通常是1024,当然可以更改数量,但由于select采用轮询的方式扫描文件描述符,文件描述符数量越多,性能越差;(在linux内核头文件中,有这样的定义:#define __FD_SETSIZE 1024)
2.内核 / 用户空间内存拷贝问题,select需要复制大量的句柄数据结构,产生巨大的开销;
3.select返回的是含有整个句柄的数组,应用程序需要遍历整个数组才能发现哪些句柄发生了事件;
4.select的触发方式是水平触发,应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作,那么之后每次select调用还是会将这些文件描述符通知进程。
相比select模型,poll使用链表保存文件描述符,因此没有了监视文件数量的限制,但其他三个缺点依然存在。

假设我们的服务器需要支持100万的并发连接,则在__FD_SETSIZE 为1024的情况下,则我们至少需要开辟1k个进程才能实现100万的并发连接。除了进程间上下文切换的时间消耗外,从内核/用户空间大量的无脑内存拷贝、数组轮询等,是系统难以承受的。因此,基于select模型的服务器程序,要达到10万级别的并发访问,是一个很难完成的任务。

epoll IO多路复用模型实现机制

由于epoll的实现机制与select/poll机制完全不同,上面所说的 select的缺点在epoll上不复存在。

设想一下如下场景:有100万个客户端同时与一个服务器进程保持着TCP连接。而每一时刻,通常只有几百上千个TCP连接是活跃的(事实上大部分场景都是这种情况)。如何实现这样的高并发?

在select/poll时代,服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态),让操作系统内核去查询这些套接字上是否有事件发生,轮询完后,再将句柄数据复制到用户态,让服务器应用程序轮询处理已发生的网络事件,这一过程资源消耗较大,因此,select/poll一般只能处理几千的并发连接。

epoll的设计和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统(文件系统一般用什么数据结构实现?B+树)。把原先的select/poll调用分成了3个部分:

1)调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)

2)调用epoll_ctl向epoll对象中添加这100万个连接的套接字

3)调用epoll_wait收集发生的事件的连接

如此一来,要实现上面说是的场景,只需要在进程启动时建立一个epoll对象,然后在需要的时候向这个epoll对象中添加或者删除连接。同时,epoll_wait的效率也非常高,因为调用epoll_wait时,并没有一股脑的向操作系统复制这100万个连接的句柄数据,内核也不需要去遍历全部的连接。

epoll实现机制

当某一进程调用epoll_create方法时,Linux内核会创建一个eventpoll结构体,这个结构体中有两个成员与epoll的使用方式密切相关。eventpoll结构体如下所示:

struct eventpoll{
    ....
    /*红黑树的根节点,这颗树中存储着所有添加到epoll中的需要监控的事件*/
    struct rb_root  rbr;
    /*双链表中则存放着将要通过epoll_wait返回给用户的满足条件的事件*/
    struct list_head rdlist;
    ....
};

每一个epoll对象都有一个独立的eventpoll结构体,用于存放通过epoll_ctl方法向epoll对象中添加进来的事件。这些事件都会挂载在红黑树中,如此,重复添加的事件就可以通过红黑树而高效的识别出来(红黑树的插入时间效率是lgn,其中n为树的高度)。

而所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系,也就是说,当相应的事件发生时会调用这个回调方法。这个回调方法在内核中叫ep_poll_callback,它会将发生的事件添加到rdlist双链表中。

在epoll中,对于每一个事件,都会建立一个epitem结构体,如下所示:

struct epitem{
    struct rb_node  rbn;//红黑树节点
    struct list_head    rdllink;//双向链表节点
    struct epoll_filefd  ffd;  //事件句柄信息
    struct eventpoll *ep;    //指向其所属的eventpoll对象
    struct epoll_event event; //期待发生的事件类型
}

当调用epoll_wait检查是否有事件发生时,只需要检查eventpoll对象中的rdlist双链表中是否有epitem元素即可。如果rdlist不为空,则把发生的事件复制到用户态,同时将事件数量返回给用户。
epoll结构示意图
通过红黑树和双链表数据结构,并结合回调机制,造就了epoll的高效。

epoll的接口

  1. epoll_create
    创建epoll句柄
    函数声明:int epoll_create(int size)
    参数:size用来告诉内核这个监听的数目一共有多大。
    返回值:返回创建了的epoll句柄。
    当创建好epoll句柄后,它就是会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。
  2. epoll_ctl
    将被监听的描述符添加到epoll句柄或从epool句柄中删除或者对监听事件进行修改。
    函数申明:int epoll_ctl(int epfd, int op, int fd, struct epoll_event*event);
    参数:
    epfd: epoll_create()的返回值
    op:表示要进行的操作,其值分别为:
    EPOLL_CTL_ADD: 注册新的fd到epfd中;
    EPOLL_CTL_MOD: 修改已经注册的fd的监听事件;
    EPOLL_CTL_DEL: 从epfd中删除一个fd;
    fd:需要操作/监听的文件句柄
    event:是告诉内核需要监听什么事件,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:触发该事件,表示对应的文件描述符上有可读数据。(包括对端SOCKET正常关闭);
EPOLLOUT:触发该事件,表示对应的文件描述符上可以写数据;
EPOLLPRI:表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来);
EPOLLERR:表示对应的文件描述符发生错误;
EPOLLHUP: 表示对应的文件描述符被挂断;
EPOLLET:将EPOLL设为边缘触发(EdgeTriggered)模式,这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT: 只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里。
示例:

struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
  1. epoll_wait
    等侍注册在epfd上的socket fd的事件的发生,如果发生则将发生的sokct fd和事件类型放入到events数组中。
    函数原型:int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
    参数:
    epfd:由epoll_create 生成的epoll文件描述符
    events:用于回传代处理事件的数组
    maxevents:每次能处理的最大事件数
    timeout:等待I/O事件发生的超时毫秒数,-1相当于阻塞,0相当于非阻塞。一般用-1即可

epoll的工作模式

ET(EdgeTriggered):高速工作模式,只支持no_block(非阻塞模式)。在此模式下,当描述符从未就绪变为就绪时,内核通过epoll告知。然后它会假设用户知道文件描述符已经就绪,并且不会再为那个文件描述符发送更多的就绪通知,直到某些操作导致那个文件描述符不再为就绪状态了。(触发模式只在数据就绪时通知一次,若数据没有读完,下一次不会通知,直到有新的就绪数据)
LT(LevelTriggered):缺省工作方式,支持blocksocket和no_blocksocket。在LT模式下内核会告知一个文件描述符是否就绪了,然后可以对这个就绪的fd进行IO操作。如果不作任何操作,内核还是会继续通知!若数据没有读完,内核也会继续通知,直至设备数据为空为止!

示例说明:

1.我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符
2. 这个时候从管道的另一端被写入了2KB的数据
3. 调用epoll_wait(2),并且它会返回RFD,说明它已经准备好读取操作
4. 然后我们读取了1KB的数据
5. 调用epoll_wait(2)……
ET工作模式:
如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志,在第2步执行了一个写操作,第三步epoll_wait会返回同时通知的事件会销毁。因为第4步的读取操作没有读空文件输入缓冲区内的数据,因此我们在第5步调用epoll_wait(2)完成后,是否挂起是不确定的。epoll工作在ET模式的时候,必须使用非阻塞套接口,以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
只有当read(2)或者write(2)返回EAGAIN时(认为读完)才需要挂起,等待。但这并不是说每次read()时都需要循环读,直到读到产生一个EAGAIN才认为此次事件处理完成,当read()返回的读到的数据长度小于请求的数据长度时(即小于sizeof(buf)),就可以确定此时缓冲中已没有数据了,也就可以认为此事读事件已处理完成。
LT工作模式:
LT方式调用epoll接口的时候,它就相当于一个速度比较快的poll(2),并且无论后面的数据是否被使用,因此他们具有同样的职能。

示例

/*
*   file epollTest.c
*/
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <errno.h>  
#include <sys/socket.h>  
#include <netdb.h>  
#include <fcntl.h>  
#include <sys/epoll.h>  
#include <string.h>  

#define MAXEVENTS 64  

//函数:  
//功能:创建和绑定一个TCP socket  
//参数:端口  
//返回值:创建的socket  
static int  
create_and_bind (char *port)  
{  
  struct addrinfo hints;  
  struct addrinfo *result, *rp;  
  int s, sfd;  

  memset (&hints, 0, sizeof (struct addrinfo));  
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */  
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */  
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */  

  s = getaddrinfo (NULL, port, &hints, &result);  
  if (s != 0)  
    {  
      fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));  
      return -1;  
    }  

  for (rp = result; rp != NULL; rp = rp->ai_next)  
    {  
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);  
      if (sfd == -1)  
        continue;  

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);  
      if (s == 0)  
        {  
          /* We managed to bind successfully! */  
          break;  
        }  

      close (sfd);  
    }  

  if (rp == NULL)  
    {  
      fprintf (stderr, "Could not bind\n");  
      return -1;  
    }  

  freeaddrinfo (result);  

  return sfd;  
}  


//函数  
//功能:设置socket为非阻塞的  
static int  
make_socket_non_blocking (int sfd)  
{  
  int flags, s;  

  //得到文件状态标志  
  flags = fcntl (sfd, F_GETFL, 0);  
  if (flags == -1)  
    {  
      perror ("fcntl");  
      return -1;  
    }  

  //设置文件状态标志  
  flags |= O_NONBLOCK;  
  s = fcntl (sfd, F_SETFL, flags);  
  if (s == -1)  
    {  
      perror ("fcntl");  
      return -1;  
    }  

  return 0;  
}  

//端口由参数argv[1]指定  
int  
main (int argc, char *argv[])  
{  
  int sfd, s;  
  int efd;  
  struct epoll_event event;  
  struct epoll_event *events;  

  if (argc != 2)  
    {  
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);  
      exit (EXIT_FAILURE);  
    }  

  sfd = create_and_bind (argv[1]);  
  if (sfd == -1)  
    abort ();  

  s = make_socket_non_blocking (sfd);  
  if (s == -1)  
    abort ();  

  s = listen (sfd, SOMAXCONN);  
  if (s == -1)  
    {  
      perror ("listen");  
      abort ();  
    }  

  //除了参数size被忽略外,此函数和epoll_create完全相同  
  efd = epoll_create1 (0);  
  if (efd == -1)  
    {  
      perror ("epoll_create");  
      abort ();  
    }  

  event.data.fd = sfd;  
  event.events = EPOLLIN | EPOLLET;//读入,边缘触发方式  
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);  
  if (s == -1)  
    {  
      perror ("epoll_ctl");  
      abort ();  
    }  

  /* Buffer where events are returned */  
  events = calloc (MAXEVENTS, sizeof event);  

  /* The event loop */  
  while (1)  
    {  
      int n, i;  

      n = epoll_wait (efd, events, MAXEVENTS, -1);  
      for (i = 0; i < n; i++)  
        {  
          if ((events[i].events & EPOLLERR) ||  
              (events[i].events & EPOLLHUP) ||  
              (!(events[i].events & EPOLLIN)))  
            {  
              /* An error has occured on this fd, or the socket is not 
                 ready for reading (why were we notified then?) */  
              fprintf (stderr, "epoll error\n");  
              close (events[i].data.fd);  
              continue;  
            }  

          else if (sfd == events[i].data.fd)  
            {  
              /* We have a notification on the listening socket, which 
                 means one or more incoming connections. */  
              while (1)  
                {  
                  struct sockaddr in_addr;  
                  socklen_t in_len;  
                  int infd;  
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];  

                  in_len = sizeof in_addr;  
                  infd = accept (sfd, &in_addr, &in_len);  
                  if (infd == -1)  
                    {  
                      if ((errno == EAGAIN) ||  
                          (errno == EWOULDBLOCK))  
                        {  
                          /* We have processed all incoming 
                             connections. */  
                          break;  
                        }  
                      else  
                        {  
                          perror ("accept");  
                          break;  
                        }  
                    }  

                                  //将地址转化为主机名或者服务名  
                  s = getnameinfo (&in_addr, in_len,  
                                   hbuf, sizeof hbuf,  
                                   sbuf, sizeof sbuf,  
                                   NI_NUMERICHOST | NI_NUMERICSERV);//flag参数:以数字名返回  
                                  //主机地址和服务地址  

                  if (s == 0)  
                    {  
                      printf("Accepted connection on descriptor %d "  
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);  
                    }  

                  /* Make the incoming socket non-blocking and add it to the 
                     list of fds to monitor. */  
                  s = make_socket_non_blocking (infd);  
                  if (s == -1)  
                    abort ();  

                  event.data.fd = infd;  
                  event.events = EPOLLIN | EPOLLET;  
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);  
                  if (s == -1)  
                    {  
                      perror ("epoll_ctl");  
                      abort ();  
                    }  
                }  
              continue;  
            }  
          else  
            {  
              /* We have data on the fd waiting to be read. Read and 
                 display it. We must read whatever data is available 
                 completely, as we are running in edge-triggered mode 
                 and won't get a notification again for the same 
                 data. */  
              int done = 0;  

              while (1)  
                {  
                  ssize_t count;  
                  char buf[512];  

                  count = read (events[i].data.fd, buf, sizeof(buf));  
                  if (count == -1)  
                    {  
                      /* If errno == EAGAIN, that means we have read all 
                         data. So go back to the main loop. */  
                      if (errno != EAGAIN)  
                        {  
                          perror ("read");  
                          done = 1;  
                        }  
                      break;  
                    }  
                  else if (count == 0)  
                    {  
                      /* End of file. The remote has closed the 
                         connection. */  
                      done = 1;  
                      break;  
                    }  

                  /* Write the buffer to standard output */  
                  s = write (1, buf, count);  
                  if (s == -1)  
                    {  
                      perror ("write");  
                      abort ();  
                    }  
                }  

              if (done)  
                {  
                  printf ("Closed connection on descriptor %d\n",  
                          events[i].data.fd);  

                  /* Closing the descriptor will make epoll remove it 
                     from the set of descriptors which are monitored. */  
                  close (events[i].data.fd);  
                }  
            }  
        }  
    }  

  free (events);  

  close (sfd);  

  return EXIT_SUCCESS;  
}
代码编译后,./epollTest 8888 ,在另外一个终端中执行 
telnet 192.168.1.161 8888192.168.1.161为执行测试程序的ip。在telnet终端敲入任何字符敲入Enter后,会在测试终端显示敲入的字符。

参考文档:
高并发网络编程之epoll详解
epoll机制:epoll_create、epoll_ctl、epoll_wait、close
Linux Epoll介绍和程序实例
如何使用 epoll? 一个 C 语言实例

2018-09-14 11:35:00 weixin_34380948 阅读数 2

epoll_create、epoll_ctl、epoll_wait、close

 

在linux的网络编程中,很长的时间都在使用select来做事件触发。在linux新的内核中,有了一种替换它的机制,就是epoll。相比于select,epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中,它是采用轮询来处理的,轮询的fd数目越多,自然耗时越多。并且,linux/posix_types.h头文件有这样的声明:
#define__FD_SETSIZE   1024
         表示select最多同时监听1024个fd,当然,可以通过修改头文件再重编译内核来扩大这个数目,但这似乎并不治本

 

epoll的接口非常简单,一共就三个函数: 1.创建epoll句柄    int epfd = epoll_create(intsize);                                                                   

       创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大这个参数不同于select()中的第一个参数,给出最大监听的fd+1的值。需要注意的是,当创建好epoll句柄后,它就是会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。 函数声明:int epoll_create(int size) 该 函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间,用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。随你定好了。只要你有空间。可参见上面与select之不同 2.将被监听的描述符添加到epoll句柄或从epool句柄中删除或者对监听事件进行修改

 

函数声明:int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) 该函数用于控制某个epoll文件描述符上的事件,可以注册事件,修改事件,删除事件。 参数: epfd:由 epoll_create 生成的epoll专用的文件描述符; op:要进行的操作例如注册事件,可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除
fd:关联的文件描述符; event:指向epoll_event的指针; 如果调用成功返回0,不成功返回-1

 

 

 int epoll_ctl(int epfd, intop, 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

 

          第四个参数是告诉内核需要监听什么事件,structepoll_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:            触发该事件,表示对应的文件描述符上有可读数据。(包括对端SOCKET正常关闭);
         EPOLLOUT:         触发该事件,表示对应的文件描述符上可以写数据;
        EPOLLPRI:           表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来);
        EPOLLERR:        表示对应的文件描述符发生错误;
         EPOLLHUP:        表示对应的文件描述符被挂断;
        EPOLLET:           将EPOLL设为边缘触发(Edge Triggered)模式,这是相对于水平触发(Level Triggered)来说的。
        EPOLLONESHOT:  只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里。

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

 

3.等待事件触发,当超过timeout还没有事件触发时,就超时。

   int epoll_wait(int epfd, struct epoll_event * events, intmaxevents, int timeout);     等待事件的产生,类似于select()调用。参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大(数组成员的个数),这个maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说是永久阻塞)。

 

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

 

    返回的事件集合在events数组中,数组中实际存放的成员个数是函数的返回值。返回0表示已经超时
函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
该函数用于轮询I/O事件的发生;
参数:
epfd:由epoll_create 生成的epoll专用的文件描述符;
epoll_event:用于回传代处理事件的数组;
maxevents:每次能处理的事件数;
timeout:等待I/O事件发生的超时值(单位我也不太清楚);-1相当于阻塞,0相当于非阻塞。一般用-1即可
返回发生事件数。
epoll_wait运行的原理是
等侍注册在epfd上的socket fd的事件的发生,如果发生则将发生的sokct fd和事件类型放入到events数组中。
并 且将注册在epfd上的socket fd的事件类型给清空,所以如果下一个循环你还要关注这个socket fd的话,则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。这时不用EPOLL_CTL_ADD,因为socket fd并未清空,只是事件类型清空。这一步非常重要。
 
epoll_wait范围之后应该是一个循环,遍历所有的事件:
 
nfds = epoll_wait(epfd,events,20,500);  
{
for(n=0;n<nfds;++n)
{
if(events[n].data.fd==listener)
{
//如果是主socket的事件的话,则表示
//有新连接进入了,进行新连接的处理。
client=accept(listener,(structsockaddr*)&local,&addrlen);
if(client<0)
{
perror("accept");
continue;
}
setnonblocking(client);//将新连接置于非阻塞模式
ev.events=EPOLLIN|EPOLLET;//并且将新连接也加入EPOLL的监听队列。
//注意,这里的参数EPOLLIN|EPOLLET并没有设置对写socket的监听,
//如果有写操作的话,这个时候epoll是不会返回事件的,如果要对写操作
//也监听的话,应该是EPOLLIN|EPOLLOUT|EPOLLET
ev.data.fd=client;
if(epoll_ctl(kdpfd,EPOLL_CTL_ADD,client,&ev)<0)
{
//设置好event之后,将这个新的event通过epoll_ctl加入到epoll的监听队列里面,
//这里用EPOLL_CTL_ADD来加一个新的epoll事件,通过EPOLL_CTL_DEL来减少一个
//epoll事件,通过EPOLL_CTL_MOD来改变一个事件的监听方式。
fprintf(stderr,"epollsetinsertionerror:fd=%d0,client);
return-1;d
}
}
elseif(event[n].events&EPOLLIN)
{
//如果是已经连接的用户,并且收到数据,
//那么进行读入
intsockfd_r;
if((sockfd_r=event[n].data.fd)<0)continue;
read(sockfd_r,buffer,MAXSIZE);
//修改sockfd_r上要处理的事件为EPOLLOUT
ev.data.fd=sockfd_r;
ev.events=EPOLLOUT|EPOLLET;
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd_r,&ev)
}
elseif(event[n].events&EPOLLOUT)
{
//如果有数据发送
intsockfd_w=events[n].data.fd;
write(sockfd_w,buffer,sizeof(buffer));
//修改sockfd_w上要处理的事件为EPOLLIN
ev.data.fd=sockfd_w;
ev.events=EPOLLIN|EPOLLET;
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd_w,&ev)
}
do_use_fd(events[n].data.fd);
}
}

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

从man手册中,得到ET和LT的具体描述如下
EPOLL事件有两种模型:
Edge Triggered(ET)       //高速工作方式,错误率比较大,只支持no_block socket (非阻塞socket)
LevelTriggered(LT)       //缺省工作方式,即默认的工作方式,支持blocksocket和no_blocksocket,错误率比较小。

假如有这样一个例子:(LT方式,即默认方式下,内核会继续通知,可以读数据,ET方式,内核不会再通知,可以读数据)
1.我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符
2. 这个时候从管道的另一端被写入了2KB的数据
3. 调用epoll_wait(2),并且它会返回RFD,说明它已经准备好读取操作
4. 然后我们读取了1KB的数据
5. 调用epoll_wait(2)......

转载于:https://www.cnblogs.com/henryliublog/p/9645562.html

2015-10-19 11:02:41 wangjin2891 阅读数 273

背景:

在linux的网络编程中,很长的时间都在使用select来做事件触发。

在linux新的内核中,有了一种替换它的机制,就是epoll。相比于select,epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。

因为在内核中的select实现中,它是采用轮询来处理的,轮询的fd数目越多,自然耗时越多。并且,linux/posix_types.h头文件有这样的声明:

#define__FD_SETSIZE   1024   表示select最多同时监听1024个fd,当然,可以通过修改头文件再重编译内核来扩大这个数目,但这似乎并不治本。
 
 
epoll的接口非常简单,一共就三个函数:
1.创建epoll句柄
       int epfd = epoll_create(intsize);                                                                   
       创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大。
       这个参数不同于select()中的第一个参数,给出最大监听的fd+1的值。需要注意的是,当创建好epoll句柄后,它就是会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。
函数声明:int epoll_create(int size)
该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间,用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。

2.将被监听的描述符添加到epoll句柄或从epool句柄中删除或者对监听事件进行修改。
函数声明:int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
该函数用于控制某个epoll文件描述符上的事件,可以注册事件,修改事件,删除事件。
参数:
epfd:由 epoll_create 生成的epoll专用的文件描述符;
op:要进行的操作例如注册事件,可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除
fd:关联的文件描述符;
event:指向epoll_event的指针;
如果调用成功返回0,不成功返回-1
   
int epoll_ctl(int epfd, intop, 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,
          第四个参数是告诉内核需要监听什么事件;
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:            触发该事件,表示对应的文件描述符上有可读数据。(包括对端SOCKET正常关闭);
         EPOLLOUT:         触发该事件,表示对应的文件描述符上可以写数据;
        EPOLLPRI:           表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来);
        EPOLLERR:         表示对应的文件描述符发生错误;
         EPOLLHUP:         表示对应的文件描述符被挂断;
        EPOLLET:           将EPOLL设为边缘触发(Edge Triggered)模式,这是相对于水平触发(Level Triggered)来说的。
        EPOLLONESHOT:  只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里。
例如:
struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型,文件描述符上有可读数据或者将EPOLL设为边缘触发(Edge Triggered)模式;
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

3.等待事件触发,当超过timeout还没有事件触发时,就超时。
    int epoll_wait(int epfd, struct epoll_event * events, intmaxevents, int timeout);
    等待事件的产生,类似于select()调用。
参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大(数组成员的个数),这个maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说是永久阻塞)。
    该函数返回需要处理的事件数目,如返回0表示已超时。
    返回的事件集合在events数组中,数组中实际存放的成员个数是函数的返回值。返回0表示已经超时。
函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
该函数用于轮询I/O事件的发生;
参数:
epfd:由epoll_create 生成的epoll专用的文件描述符;
epoll_event:用于回传代处理事件的数组;
maxevents:每次能处理的事件数;
timeout:等待I/O事件发生的超时值(单位我也不太清楚);-1相当于阻塞,0相当于非阻塞。一般用-1即可
返回值: 返回发生事件数。

epoll_wait运行的原理:
等侍注册在epfd上的socket fd的事件的发生,如果发生则将发生的sokct fd和事件类型放入到events数组中。
并且将注册在epfd上的socket fd的事件类型给清空,所以如果下一个循环你还要关注这个socket fd的话,则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。

这时不用EPOLL_CTL_ADD,因为socket fd并未清空,只是事件类型清空。这一步非常重要。


疑问:
EPOLLET:边缘触发(Edge Triggered)模式是什么意思?





2014-07-15 22:41:19 nkguohao 阅读数 944

先给一个源码例子:

服务器端:
#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <string.h>  
#include <sys/types.h>  
#include <errno.h>  
#include <sys/socket.h>  
#include <netinet/in.h>           /* socket类定义需要*/  
#include <sys/epoll.h>            /* epoll头文件 */  
#include <fcntl.h>                    /* nonblocking需要 */  
#include <sys/resource.h>     /* 设置最大的连接数需要setrlimit */  
  
#define MAXEPOLL    10000   /* 对于服务器来说,这个值可以很大的! */  
#define MAXLINE     1024  
#define     PORT            6000  
#define MAXBACK 1000  
  
//!> 设置非阻塞  
//!>   
int setnonblocking( int fd )  
{  
    if( fcntl( fd, F_SETFL, fcntl( fd, F_GETFD, 0 )|O_NONBLOCK ) == -1 )  
    {  
        printf("Set blocking error : %d\n", errno);  
        return -1;  
    }  
    return 0;  
}  
  
int main( int argc, char ** argv )  
{  
    int         listen_fd;  
    int         conn_fd;  
    int         epoll_fd;  
    int         nread;  
    int         cur_fds;                //!> 当前已经存在的数量  
    int         wait_fds;               //!> epoll_wait 的返回值  
    int     i;  
    struct sockaddr_in servaddr;  
    struct sockaddr_in cliaddr;  
    struct  epoll_event ev;  
    struct  epoll_event evs[MAXEPOLL];  
    struct  rlimit  rlt;        //!> 设置连接数所需  
    char    buf[MAXLINE];  
    socklen_t   len = sizeof( struct sockaddr_in );  
  
    //!> 设置每个进程允许打开的最大文件数  
    //!> 每个主机是不一样的哦,一般服务器应该很大吧!  
    //!>   
    rlt.rlim_max = rlt.rlim_cur = MAXEPOLL;  
    if( setrlimit( RLIMIT_NOFILE, &rlt ) == -1 )      
    {  
        printf("Setrlimit Error : %d\n", errno);  
        exit( EXIT_FAILURE );  
    }  
      
    //!> server 套接口  
    //!>   
    bzero( &servaddr, sizeof( servaddr ) );  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_addr.s_addr = htonl( INADDR_ANY );  
    servaddr.sin_port = htons( PORT );  
      
    //!> 建立套接字  
    if( ( listen_fd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )  
    {  
        printf("Socket Error...\n" , errno );  
        exit( EXIT_FAILURE );  
    }  
      
    //!> 设置非阻塞模式  
    //!>   
    if( setnonblocking( listen_fd ) == -1 )  
    {  
        printf("Setnonblocking Error : %d\n", errno);  
        exit( EXIT_FAILURE );  
    }  
      
    //!> 绑定  
    //!>  
    if( bind( listen_fd, ( struct sockaddr *)&servaddr, sizeof( struct sockaddr ) ) == -1 )  
    {  
        printf("Bind Error : %d\n", errno);  
        exit( EXIT_FAILURE );  
    }  
  
    //!> 监听  
    //!>   
    if( listen( listen_fd, MAXBACK ) == -1 )  
    {  
        printf("Listen Error : %d\n", errno);  
        exit( EXIT_FAILURE );  
    }  
      
    //!> 创建epoll  
    //!>   
    epoll_fd = epoll_create( MAXEPOLL );    //!> create  
    ev.events = EPOLLIN | EPOLLET;      //!> accept Read!  
    ev.data.fd = listen_fd;                 //!> 将listen_fd 加入  
    if( epoll_ctl( epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev ) < 0 )  
    {  
        printf("Epoll Error : %d\n", errno);  
        exit( EXIT_FAILURE );  
    }
	else
	{
		printf("listen_fd:%d been added in epoll_fd\n", listen_fd);
	}
    cur_fds = 1;  
      
    while( 1 )  
    {  
		printf("\n\n");
        if( ( wait_fds = epoll_wait( epoll_fd, evs, cur_fds, -1 ) ) == -1 )  
        {  
            printf( "Epoll Wait Error : %d\n", errno );  
            exit( EXIT_FAILURE );  
        }
		else
		{
			printf("epoll_wait success! the return value wait_fds = %d\n", wait_fds);
		}
  
        for( i = 0; i < wait_fds; i++ )  
        {  
			printf("evs[i].data.fd = %d, listen_fd = %d \n", evs[i].data.fd, listen_fd);
            if( evs[i].data.fd == listen_fd && cur_fds < MAXEPOLL )           //!> if是监听端口有事                             
            {
                if( ( conn_fd = accept( listen_fd, (struct sockaddr *)&cliaddr, &len ) ) == -1 )  
                {  
                    printf("Accept Error : %d\n", errno);  
                    exit( EXIT_FAILURE );  
                }  
                
                printf( " Server get from client: %s  %d\n",  inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port); 
				   
                ev.events = EPOLLIN | EPOLLET;      //!> accept Read!  
                ev.data.fd = conn_fd;                   //!> 将conn_fd 加入  
                if( epoll_ctl( epoll_fd, EPOLL_CTL_ADD, conn_fd, &ev ) < 0 )  
                {  
                    printf("Epoll Error : %d\n", errno);  
                    exit( EXIT_FAILURE );  
                } 
				printf("conn_fd = %d, been added in epoll_fd\n", conn_fd);
                ++cur_fds;   
                continue;         
            }  
              
            //!> 下面处理数据  
            //!>   
            nread = read( evs[i].data.fd, buf, sizeof( buf ) );  
            if( nread <= 0 )                     //!> 结束后者出错  
            {  
                close( evs[i].data.fd );  
                epoll_ctl( epoll_fd, EPOLL_CTL_DEL, evs[i].data.fd, &ev );  //!> 删除计入的fd  
                --cur_fds;                  //!> 减少一个呗!  
                continue;  
            }
		else
		<span style="white-space:pre">	</span>printf("read from client, data: %s\n", buf);
              
            write( evs[i].data.fd, buf, nread );            //!> 回写  
        }  
    }  
    close( listen_fd );  
    return 0;  
} 

客户端例子(使用select)
#include <stdio.h>  
#include <unistd.h>  
#include <stdlib.h>  
#include <string.h>  
#include <errno.h>  
#include <netinet/in.h>  
#include <sys/types.h>  
#include <sys/socket.h>  
#include  <arpa/inet.h>  
#include <sys/select.h>  
  
#define MAXLINE 1024  
#define SERV_PORT 6000  
  
//!> 注意输入是由stdin,接受是由server发送过来  
//!> 所以在client端也是需要select进行处理的  
void send_and_recv( int connfd )  
{  
    FILE * fp = stdin;  
    int   lens;  
    char send[MAXLINE];  
    char recv[MAXLINE];  
    fd_set rset;  
    FD_ZERO( &rset );  
    int maxfd = ( fileno( fp ) > connfd ? fileno( fp ) : connfd  + 1 );    
                                    //!> 输入和输出的最大值  
    int n;  
      
    while( 1 )  
    {  
		printf("\n\n");
        FD_SET( fileno( fp ), &rset );  
        FD_SET( connfd, &rset );            //!> 注意不要把rset看作是简单的一个变量  
                                //!> 注意它其实是可以包含一组套接字的哦,  
                                //!> 相当于是封装的数组!每次都要是新的哦!  
          
        if( select( maxfd, &rset, NULL, NULL, NULL ) == -1 )  
        {  
            printf("Client Select Error..\n");  
            exit(EXIT_FAILURE  );  
        }  
          
        //!> if 连接口有信息  
        if( FD_ISSET( connfd, &rset ) ) //!> if 连接端口有信息  
        {  
            printf( "client get from server ...\n" );  
            memset( recv, 0, sizeof( recv ) );  
            n = read( connfd, recv, MAXLINE ); 
			 
            if( n == 0 )  
            {  
                printf("Recv ok...\n");  
                break;  
            }  
            else if( n == -1 )  
            {  
                printf("Recv error...\n");  
                break;  
            }  
            else  
            {  
                lens = strlen( recv );  
                recv[lens] = '\0';  
                //!> 写到stdout 
				printf( "client read from server: ", recv); 
                write( STDOUT_FILENO, recv, MAXLINE );  
                printf("\n");  
            }  
  
        }  
          
        //!> if 有stdin输入  
        if( FD_ISSET( fileno( fp ), &rset ) )   //!> if 有输入  
        {  
            printf("client stdin ...\n");  
              
            memset( send, 0, sizeof( send ) );  
            if( fgets( send, MAXLINE, fp ) == NULL )  
            {  
                printf("End...\n");  
                exit( EXIT_FAILURE );  
            }  
            else  
            {  
                //!>if( str )  
                lens = strlen( send );  
                send[lens-1] = '\0';        //!> 减一的原因是不要回车字符  
                                //!> 经验值:这一步非常重要的哦!!!!!!!!  
                if( strcmp( send, "q" ) == 0 )  
                {  
                    printf( "Bye..\n" );  
                    return;  
                }  
                  
                printf("Client send : %s\n", send);  
                write( connfd, send, strlen( send ) );  
            }  
        }  
          
    }  
      
}  
  
int main( int argc, char ** argv )  
{  
    //!> char * SERV_IP = "10.30.97.188";  
    char    buf[MAXLINE];  
    int     connfd;  
    struct sockaddr_in servaddr;  
      
    if( argc != 2 )  
    {  
        printf("Input server ip !\n");  
        exit( EXIT_FAILURE );  
    }  
      
    //!> 建立套接字  
    if( ( connfd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )  
    {  
        printf("Socket Error...\n" , errno );  
        exit( EXIT_FAILURE );  
    }  
  
    //!> 套接字信息  
    bzero(&servaddr, sizeof(servaddr));  
    servaddr.sin_family = AF_INET;  
    servaddr.sin_port = htons(SERV_PORT);  
    inet_pton(AF_INET, argv[1], &servaddr.sin_addr);  
      
    //!> 链接server  
    if( connect( connfd, ( struct sockaddr *  )&servaddr, sizeof( servaddr ) ) < 0 )  
    {  
        printf("Connect error..\n");  
        exit(EXIT_FAILURE);  
    }     
    /*else 
    { 
        printf("Connet ok..\n"); 
    }*/  
  
    //!>  
    //!> send and recv  
    send_and_recv( connfd );  
      
    //!>   
  
    close( connfd );  
    printf("Exit\n");  
      
    return 0;  

} 




转自http://blog.chinaunix.net/uid-24517549-id-4051156.html


什么是epoll

epoll是什么?按照man手册的说法:是为处理大批量句柄而作了改进的poll。当然,这不是2.6内核才有的,它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44),它几乎具备了之前所说的一切优点,被公认为Linux2.6下性能最好的多路I/O就绪通知方法。

 

epoll的相关系统调用

epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。

 

1. int epoll_create(int size);

创建一个epoll的句柄。自从linux2.6.8之后,size参数是被忽略的。需要注意的是,当创建好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:注册新的fdepfd中;

EPOLL_CTL_MOD:修改已经注册的fd的监听事件;

EPOLL_CTL_DEL:从epfd中删除一个fd

 

第三个参数是需要监听的fd

第四个参数是告诉内核需要监听什么事,struct epoll_event结构如下:

  1. //保存触发事件的某个文件描述符相关的数据(与具体使用方式有关)  
  2.   
  3. typedef union epoll_data {  
  4.     void *ptr;  
  5.     int fd;  
  6.     __uint32_t u32;  
  7.     __uint64_t u64;  
  8. } epoll_data_t;  
  9.  //感兴趣的事件和被触发的事件  
  10. struct epoll_event {  
  11.     __uint32_t events; /* Epoll events */  
  12.     epoll_data_t data; /* User data variable */  
  13. };  


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);

收集在epoll监控的事件中已经发送的事件。参数events是分配好的epoll_event结构体数组,epoll将会把发生的事件赋值到events数组中(events不可以是空指针,内核只负责把数据复制到这个events数组中,不会去帮助我们在用户态中分配内存)maxevents告之内核这个events有多大,这个 maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1将不确定,也有说法说是永久阻塞)。如果函数调用成功,返回对应I/O上已准备好的文件描述符数目,如返回0表示已超时。

 

epoll工作原理

epoll同样只告知那些就绪的文件描述符,而且当我们调用epoll_wait()获得就绪文件描述符时,返回的不是实际的描述符,而是一个代表就绪描述符数量的值,你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可,这里也使用了内存映射(mmap)技术,这样便彻底省掉了这些文件描述符在系统调用时复制的开销。

 

另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个文件描述符,当进程调用epoll_wait()时便得到通知。

 

Epoll2种工作方式-水平触发(LT)和边缘触发(ET

假如有这样一个例子:

1. 我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符

2. 这个时候从管道的另一端被写入了2KB的数据

3. 调用epoll_wait(2),并且它会返回RFD,说明它已经准备好读取操作

4. 然后我们读取了1KB的数据

5. 调用epoll_wait(2)......


Edge Triggered 工作模式:

如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志,那么在第5步调用epoll_wait(2)之后将有可能会挂起,因为剩余的数据还存在于文件的输入缓冲区内,而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候,调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。在上面的例子中,会有一个事件产生在RFD句柄上,因为在第2步执行了一个写操作,然后,事件将会在第3步被销毁。因为第4步的读取操作没有读空文件输入缓冲区内的数据,因此我们在第5步调用 epoll_wait(2)完成后,是否挂起是不确定的。epoll工作在ET模式的时候,必须使用非阻塞套接口,以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。最好以下面的方式调用ET模式的epoll接口,在后面会介绍避免可能的缺陷。

   i    基于非阻塞文件句柄

   ii   只有当read(2)或者write(2)返回EAGAIN时才需要挂起,等待。但这并不是说每次read()时都需要循环读,直到读到产生一个EAGAIN才认为此次事件处理完成,当read()返回的读到的数据长度小于请求的数据长度时,就可以确定此时缓冲中已没有数据了,也就可以认为此事读事件已处理完成。


Level Triggered 工作模式

相反的,以LT方式调用epoll接口的时候,它就相当于一个速度比较快的poll(2),并且无论后面的数据是否被使用,因此他们具有同样的职能。因为即使使用ET模式的epoll,在收到多个chunk的数据的时候仍然会产生多个事件。调用者可以设定EPOLLONESHOT标志,在 epoll_wait(2)收到事件后epoll会与事件关联的文件句柄从epoll描述符中禁止掉。因此当EPOLLONESHOT设定后,使用带有 EPOLL_CTL_MOD标志的epoll_ctl(2)处理文件句柄就成为调用者必须作的事情。



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

 

ET (edge-triggered)是高速工作方式,只支持no-block socket,它效率要比LT更高。ET与LT的区别在于,当一个新的事件到来时,ET模式下当然可以从epoll_wait调用中获取到这个事件,可是如果这次没有把这个事件对应的套接字缓冲区处理完,在这个套接字中没有新的事件再次到来时,在ET模式下是无法再次从epoll_wait调用中获取这个事件的。而LT模式正好相反,只要一个事件对应的套接字缓冲区还有数据,就总能从epoll_wait中获取这个事件。

因此,LT模式下开发基于epoll的应用要简单些,不太容易出错。而在ET模式下事件发生时,如果没有彻底地将缓冲区数据处理完,则会导致缓冲区中的用户请求得不到响应。


Nginx默认采用ET模式来使用epoll。

 

epoll的优点:

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网卡驱动架构。

 

linuxepoll如何实现高效处理百万句柄的

开发高性能网络程序时,windows开发者们言必称iocplinux开发者们则言必称epoll。大家都明白epoll是一种IO多路复用技术,可以非常高效的处理数以百万计的socket句柄,比起以前的selectpoll效率高大发了。我们用起epoll来都感觉挺爽,确实快,那么,它到底为什么可以高速处理这么多并发连接呢?

 

使用起来很清晰,首先要调用epoll_create建立一个epoll对象。参数size是内核保证能够正确处理的最大句柄数,多于这个最大数时内核可不保证效果。

 

epoll_ctl可以操作上面建立的epoll,例如,将刚建立的socket加入到epoll中让其监控,或者把 epoll正在监控的某个socket句柄移出epoll,不再监控它等等。

 

epoll_wait在调用时,在给定的timeout时间内,当在监控的所有句柄中有事件发生时,就返回用户态的进程。

 

从上面的调用方式就可以看到epollselect/poll的优越之处:因为后者每次调用时都要传递你所要监控的所有socketselect/poll系统调用,这意味着需要将用户态的socket列表copy到内核态,如果以万计的句柄会导致每次都要copy几十几百KB的内存到内核态,非常低效。而我们调用epoll_wait时就相当于以往调用select/poll,但是这时却不用传递socket句柄给内核,因为内核已经在epoll_ctl中拿到了要监控的句柄列表。

 

所以,实际上在你调用epoll_create后,内核就已经在内核态开始准备帮你存储要监控的句柄了,每次调用epoll_ctl只是在往内核的数据结构里塞入新的socket句柄。

 当一个进程调用epoll_creaqte方法时,Linux内核会创建一个eventpoll结构体,这个结构体中有两个成员与epoll的使用方式密切相关:

  1. /* 
  2.  
  3.  171 * This structure is stored inside the "private_data" member of the file 
  4.  
  5.  172 * structure and represents the main data structure for the eventpoll 
  6.  
  7.  173 * interface. 
  8.  
  9.  174 */  
  10.   
  11.  175struct eventpoll {  
  12.   
  13.  176        /* Protect the access to this structure */  
  14.   
  15.  177        spinlock_t lock;  
  16.   
  17.  178  
  18.   
  19.  179        /* 
  20.  
  21.  180         * This mutex is used to ensure that files are not removed 
  22.  
  23.  181         * while epoll is using them. This is held during the event 
  24.  
  25.  182         * collection loop, the file cleanup path, the epoll file exit 
  26.  
  27.  183         * code and the ctl operations. 
  28.  
  29.  184         */  
  30.   
  31.  185        struct mutex mtx;  
  32.   
  33.  186  
  34.   
  35.  187        /* Wait queue used by sys_epoll_wait() */  
  36.   
  37.  188        wait_queue_head_t wq;  
  38.   
  39.  189  
  40.   
  41.  190        /* Wait queue used by file->poll() */  
  42.   
  43.  191        wait_queue_head_t poll_wait;  
  44.   
  45.  192  
  46.   
  47.  193        /* List of ready file descriptors */  
  48.   
  49.  194        struct list_head rdllist;  
  50.   
  51.  195  
  52.   
  53.  196        /* RB tree root used to store monitored fd structs */  
  54.   
  55.  197        struct rb_root rbr;//红黑树根节点,这棵树存储着所有添加到epoll中的事件,也就是这个epoll监控的事件  
  56.  198  
  57.  199        /* 
  58.  200         * This is a single linked list that chains all the "struct epitem" that 
  59.  201         * happened while transferring ready events to userspace w/out 
  60.  202         * holding ->lock. 
  61.  203         */  
  62.  204        struct epitem *ovflist;  
  63.  205  
  64.  206        /* wakeup_source used when ep_scan_ready_list is running */  
  65.  207        struct wakeup_source *ws;  
  66.  208  
  67.  209        /* The user that created the eventpoll descriptor */  
  68.  210        struct user_struct *user;  
  69.  211  
  70.  212        struct file *file;  
  71.  213  
  72.  214        /* used to optimize loop detection check */  
  73.  215        int visited;  
  74.  216        struct list_head visited_list_link;//双向链表中保存着将要通过epoll_wait返回给用户的、满足条件的事件  
  75.  217};  

每一个epoll对象都有一个独立的eventpoll结构体,这个结构体会在内核空间中创造独立的内存,用于存储使用epoll_ctl方法向epoll对象中添加进来的事件。这样,重复的事件就可以通过红黑树而高效的识别出来。


在epoll中,对于每一个事件都会建立一个epitem结构体:

  1. /* 
  2.  130 * Each file descriptor added to the eventpoll interface will 
  3.  131 * have an entry of this type linked to the "rbr" RB tree. 
  4.  132 * Avoid increasing the size of this struct, there can be many thousands 
  5.  133 * of these on a server and we do not want this to take another cache line. 
  6.  134 */  
  7.  135struct epitem {  
  8.  136        /* RB tree node used to link this structure to the eventpoll RB tree */  
  9.  137        struct rb_node rbn;  
  10.  138  
  11.  139        /* List header used to link this structure to the eventpoll ready list */  
  12.  140        struct list_head rdllink;  
  13.  141  
  14.  142        /* 
  15.  143         * Works together "struct eventpoll"->ovflist in keeping the 
  16.  144         * single linked chain of items. 
  17.  145         */  
  18.  146        struct epitem *next;  
  19.  147  
  20.  148        /* The file descriptor information this item refers to */  
  21.  149        struct epoll_filefd ffd;  
  22.  150  
  23.  151        /* Number of active wait queue attached to poll operations */  
  24.  152        int nwait;  
  25.  153  
  26.  154        /* List containing poll wait queues */  
  27.  155        struct list_head pwqlist;  
  28.  156  
  29.  157        /* The "container" of this item */  
  30.  158        struct eventpoll *ep;  
  31.  159  
  32.  160        /* List header used to link this item to the "struct file" items list */  
  33.  161        struct list_head fllink;  
  34.  162  
  35.  163        /* wakeup_source used when EPOLLWAKEUP is set */  
  36.  164        struct wakeup_source __rcu *ws;  
  37.  165  
  38.  166        /* The structure that describe the interested events and the source fd */  
  39.  167        struct epoll_event event;  
  40.  168};  

此外,epoll还维护了一个双链表,用户存储发生的事件。epoll_wait调用时,仅仅观察这个list链表里有没有数据即eptime项即可。有数据就返回,没有数据就sleep,等到timeout时间到后即使链表没数据也返回。所以,epoll_wait非常高效。

 

而且,通常情况下即使我们要监控百万计的句柄,大多一次也只返回很少量的准备就绪句柄而已,所以,epoll_wait仅需要从内核态copy少量的句柄到用户态而已,如何能不高效?!

 

那么,这个准备就绪list链表是怎么维护的呢?当我们执行epoll_ctl时,除了把socket放到epoll文件系统里file对象对应的红黑树上之外,还会给内核中断处理程序注册一个回调函数,告诉内核,如果这个句柄的中断到了,就把它放到准备就绪list链表里。所以,当一个socket上有数据到了,内核在把网卡上的数据copy到内核中后就来把socket插入到准备就绪链表里了。

 

如此,一颗红黑树,一张准备就绪句柄链表,少量的内核cache,就帮我们解决了大并发下的socket处理问题。执行epoll_create时,创建了红黑树和就绪链表,执行epoll_ctl时,如果增加socket句柄,则检查在红黑树中是否存在,存在立即返回,不存在则添加到树干上,然后向内核注册回调函数,用于当中断事件来临时向准备就绪链表中插入数据。执行epoll_wait时立刻返回准备就绪链表里的数据即可。

 

epoll的使用方法

那么究竟如何来使用epoll呢?其实非常简单。

 

通过在包含一个头文件#include <sys/epoll.h> 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。

 

首先通过create_epoll(int 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程序都使用下面的框架:

  1. for( ; ; )  
  2.    {  
  3.        nfds = epoll_wait(epfd,events,20,500);  
  4.        for(i=0;i<nfds;++i)  
  5.        {  
  6.            if(events[i].data.fd==listenfd) //有新的连接  
  7.            {  
  8.                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen); //accept这个连接  
  9.                ev.data.fd=connfd;  
  10.                ev.events=EPOLLIN|EPOLLET;  
  11.                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); //将新的fd添加到epoll的监听队列中  
  12.            }  
  13.   
  14.            else if( events[i].events&EPOLLIN ) //接收到数据,读socket  
  15.            {  
  16.                n = read(sockfd, line, MAXLINE)) < 0    //读  
  17.                ev.data.ptr = md;     //md为自定义类型,添加数据  
  18.                ev.events=EPOLLOUT|EPOLLET;  
  19.                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);//修改标识符,等待下一个循环时发送数据,异步处理的精髓  
  20.            }  
  21.            else if(events[i].events&EPOLLOUT) //有数据待发送,写socket  
  22.            {  
  23.                struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;    //取数据  
  24.                sockfd = md->fd;  
  25.                send( sockfd, md->ptr, strlen((char*)md->ptr), 0 );        //发送数据  
  26.                ev.data.fd=sockfd;  
  27.                ev.events=EPOLLIN|EPOLLET;  
  28.                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改标识符,等待下一个循环时接收数据  
  29.            }  
  30.            else  
  31.            {  
  32.                //其他的处理  
  33.            }  
  34.        }  
  35.    }  

epoll的程序实例

  1.  #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <errno.h>  
  5. #include <sys/socket.h>  
  6. #include <netdb.h>  
  7. #include <fcntl.h>  
  8. #include <sys/epoll.h>  
  9. #include <string.h>  
  10.   
  11. #define MAXEVENTS 64  
  12.   
  13. //函数:  
  14. //功能:创建和绑定一个TCP socket  
  15. //参数:端口  
  16. //返回值:创建的socket  
  17. static int  
  18. create_and_bind (char *port)  
  19. {  
  20.   struct addrinfo hints;  
  21.   struct addrinfo *result, *rp;  
  22.   int s, sfd;  
  23.   
  24.   memset (&hints, 0, sizeof (struct addrinfo));  
  25.   hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */  
  26.   hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */  
  27.   hints.ai_flags = AI_PASSIVE;     /* All interfaces */  
  28.   
  29.   s = getaddrinfo (NULL, port, &hints, &result);  
  30.   if (s != 0)  
  31.     {  
  32.       fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));  
  33.       return -1;  
  34.     }  
  35.   
  36.   for (rp = result; rp != NULL; rp = rp->ai_next)  
  37.     {  
  38.       sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);  
  39.       if (sfd == -1)  
  40.         continue;  
  41.   
  42.       s = bind (sfd, rp->ai_addr, rp->ai_addrlen);  
  43.       if (s == 0)  
  44.         {  
  45.           /* We managed to bind successfully! */  
  46.           break;  
  47.         }  
  48.   
  49.       close (sfd);  
  50.     }  
  51.   
  52.   if (rp == NULL)  
  53.     {  
  54.       fprintf (stderr, "Could not bind\n");  
  55.       return -1;  
  56.     }  
  57.   
  58.   freeaddrinfo (result);  
  59.   
  60.   return sfd;  
  61. }  
  62.   
  63.   
  64. //函数  
  65. //功能:设置socket为非阻塞的  
  66. static int  
  67. make_socket_non_blocking (int sfd)  
  68. {  
  69.   int flags, s;  
  70.   
  71.   //得到文件状态标志  
  72.   flags = fcntl (sfd, F_GETFL, 0);  
  73.   if (flags == -1)  
  74.     {  
  75.       perror ("fcntl");  
  76.       return -1;  
  77.     }  
  78.   
  79.   //设置文件状态标志  
  80.   flags |= O_NONBLOCK;  
  81.   s = fcntl (sfd, F_SETFL, flags);  
  82.   if (s == -1)  
  83.     {  
  84.       perror ("fcntl");  
  85.       return -1;  
  86.     }  
  87.   
  88.   return 0;  
  89. }  
  90.   
  91. //端口由参数argv[1]指定  
  92. int  
  93. main (int argc, char *argv[])  
  94. {  
  95.   int sfd, s;  
  96.   int efd;  
  97.   struct epoll_event event;  
  98.   struct epoll_event *events;  
  99.   
  100.   if (argc != 2)  
  101.     {  
  102.       fprintf (stderr, "Usage: %s [port]\n", argv[0]);  
  103.       exit (EXIT_FAILURE);  
  104.     }  
  105.   
  106.   sfd = create_and_bind (argv[1]);  
  107.   if (sfd == -1)  
  108.     abort ();  
  109.   
  110.   s = make_socket_non_blocking (sfd);  
  111.   if (s == -1)  
  112.     abort ();  
  113.   
  114.   s = listen (sfd, SOMAXCONN);  
  115.   if (s == -1)  
  116.     {  
  117.       perror ("listen");  
  118.       abort ();  
  119.     }  
  120.   
  121.   //除了参数size被忽略外,此函数和epoll_create完全相同  
  122.   efd = epoll_create1 (0);  
  123.   if (efd == -1)  
  124.     {  
  125.       perror ("epoll_create");  
  126.       abort ();  
  127.     }  
  128.   
  129.   event.data.fd = sfd;  
  130.   event.events = EPOLLIN | EPOLLET;//读入,边缘触发方式  
  131.   s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);  
  132.   if (s == -1)  
  133.     {  
  134.       perror ("epoll_ctl");  
  135.       abort ();  
  136.     }  
  137.   
  138.   /* Buffer where events are returned */  
  139.   events = calloc (MAXEVENTS, sizeof event);  
  140.   
  141.   /* The event loop */  
  142.   while (1)  
  143.     {  
  144.       int n, i;  
  145.   
  146.       n = epoll_wait (efd, events, MAXEVENTS, -1);  
  147.       for (i = 0; i < n; i++)  
  148.         {  
  149.           if ((events[i].events & EPOLLERR) ||  
  150.               (events[i].events & EPOLLHUP) ||  
  151.               (!(events[i].events & EPOLLIN)))  
  152.             {  
  153.               /* An error has occured on this fd, or the socket is not 
  154.                  ready for reading (why were we notified then?) */  
  155.               fprintf (stderr, "epoll error\n");  
  156.               close (events[i].data.fd);  
  157.               continue;  
  158.             }  
  159.   
  160.           else if (sfd == events[i].data.fd)  
  161.             {  
  162.               /* We have a notification on the listening socket, which 
  163.                  means one or more incoming connections. */  
  164.               while (1)  
  165.                 {  
  166.                   struct sockaddr in_addr;  
  167.                   socklen_t in_len;  
  168.                   int infd;  
  169.                   char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];  
  170.   
  171.                   in_len = sizeof in_addr;  
  172.                   infd = accept (sfd, &in_addr, &in_len);  
  173.                   if (infd == -1)  
  174.                     {  
  175.                       if ((errno == EAGAIN) ||  
  176.                           (errno == EWOULDBLOCK))  
  177.                         {  
  178.                           /* We have processed all incoming 
  179.                              connections. */  
  180.                           break;  
  181.                         }  
  182.                       else  
  183.                         {  
  184.                           perror ("accept");  
  185.                           break;  
  186.                         }  
  187.                     }  
  188.   
  189.                                   //将地址转化为主机名或者服务名  
  190.                   s = getnameinfo (&in_addr, in_len,  
  191.                                    hbuf, sizeof hbuf,  
  192.                                    sbuf, sizeof sbuf,  
  193.                                    NI_NUMERICHOST | NI_NUMERICSERV);//flag参数:以数字名返回  
  194.                                   //主机地址和服务地址  
  195.   
  196.                   if (s == 0)  
  197.                     {  
  198.                       printf("Accepted connection on descriptor %d "  
  199.                              "(host=%s, port=%s)\n", infd, hbuf, sbuf);  
  200.                     }  
  201.   
  202.                   /* Make the incoming socket non-blocking and add it to the 
  203.                      list of fds to monitor. */  
  204.                   s = make_socket_non_blocking (infd);  
  205.                   if (s == -1)  
  206.                     abort ();  
  207.   
  208.                   event.data.fd = infd;  
  209.                   event.events = EPOLLIN | EPOLLET;  
  210.                   s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);  
  211.                   if (s == -1)  
  212.                     {  
  213.                       perror ("epoll_ctl");  
  214.                       abort ();  
  215.                     }  
  216.                 }  
  217.               continue;  
  218.             }  
  219.           else  
  220.             {  
  221.               /* We have data on the fd waiting to be read. Read and 
  222.                  display it. We must read whatever data is available 
  223.                  completely, as we are running in edge-triggered mode 
  224.                  and won't get a notification again for the same 
  225.                  data. */  
  226.               int done = 0;  
  227.   
  228.               while (1)  
  229.                 {  
  230.                   ssize_t count;  
  231.                   char buf[512];  
  232.   
  233.                   count = read (events[i].data.fd, buf, sizeof(buf));  
  234.                   if (count == -1)  
  235.                     {  
  236.                       /* If errno == EAGAIN, that means we have read all 
  237.                          data. So go back to the main loop. */  
  238.                       if (errno != EAGAIN)  
  239.                         {  
  240.                           perror ("read");  
  241.                           done = 1;  
  242.                         }  
  243.                       break;  
  244.                     }  
  245.                   else if (count == 0)  
  246.                     {  
  247.                       /* End of file. The remote has closed the 
  248.                          connection. */  
  249.                       done = 1;  
  250.                       break;  
  251.                     }  
  252.   
  253.                   /* Write the buffer to standard output */  
  254.                   s = write (1, buf, count);  
  255.                   if (s == -1)  
  256.                     {  
  257.                       perror ("write");  
  258.                       abort ();  
  259.                     }  
  260.                 }  
  261.   
  262.               if (done)  
  263.                 {  
  264.                   printf ("Closed connection on descriptor %d\n",  
  265.                           events[i].data.fd);  
  266.   
  267.                   /* Closing the descriptor will make epoll remove it 
  268.                      from the set of descriptors which are monitored. */  
  269.                   close (events[i].data.fd);  
  270.                 }  
  271.             }  
  272.         }  
  273.     }  
  274.   
  275.   free (events);  
  276.   
  277.   close (sfd);  
  278.   
  279.   return EXIT_SUCCESS;  
  280. }  

linux中的epoll机制

阅读数 8342

linux中的epoll机制

阅读数 604

没有更多推荐了,返回首页