您当前的位置： 首页 >  linux

phymat.nico

暂无认证

  • 2浏览

    0关注

    1967博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

Linux下select, poll和epoll IO模型的详解

phymat.nico 发布时间：2018-01-15 20:28:03 ，浏览量：2

一）.Epoll 介绍

Epoll 可是当前在 Linux 下开发大规模并发网络程序的热门人选， Epoll 在 Linux2.6 内核中正式引入，和 select 相似，其实都 I/O 多路复用技术而已 ，并没有什么神秘的。其实在 Linux 下设计并发网络程序，向来不缺少方法，比如典型的 Apache 模型（ Process Per Connection ，简称 PPC ）， TPC （ Thread Per Connection ）模型，以及 select 模型和 poll 模型，那为何还要再引入 Epoll 这个东东呢？那还是有得说说的 …

二）. 常用模型的缺点

如果不摆出来其他模型的缺点，怎么能对比出 Epoll 的优点呢。

① PPC/TPC 模型

这两种模型思想类似，就是让每一个到来的连接一边自己做事去，别再来烦我 。只是 PPC 是为它开了一个进程，而 TPC 开了一个线程。可是别烦我是有代价的，它要时间和空间啊，连接多了之后，那么多的进程 / 线程切换，这开销就上来了；因此这类模型能接受的最大连接数都不会高，一般在几百个左右。

② select 模型

1. 最大并发数限制，因为一个进程所打开的 FD （文件描述符）是有限制的，由 FD_SETSIZE 设置，默认值是 1024/2048 ，因此 Select 模型的最大并发数就被相应限制了。自己改改这个 FD_SETSIZE ？想法虽好，可是先看看下面吧 …

2. 效率问题， select 每次调用都会线性扫描全部的 FD 集合，这样效率就会呈现线性下降，把 FD_SETSIZE 改大的后果就是，大家都慢慢来，什么？都超时了。

3. 内核 / 用户空间 内存拷贝问题，如何让内核把 FD 消息通知给用户空间呢？在这个问题上 select 采取了内存拷贝方法。

总结为：1.连接数受限  2.查找配对速度慢 3.数据由内核拷贝到用户态

③ poll 模型

基本上效率和 select 是相同的， select 缺点的 2 和 3 它都没有改掉。

三）. Epoll 的提升

把其他模型逐个批判了一下，再来看看 Epoll 的改进之处吧，其实把 select 的缺点反过来那就是 Epoll 的优点了。

①. Epoll 没有最大并发连接的限制，上限是最大可以打开文件的数目，这个数字一般远大于 2048, 一般来说这个数目和系统内存关系很大 ，具体数目可以 cat /proc/sys/fs/file-max 察看。

②. 效率提升， Epoll 最大的优点就在于它只管你“活跃”的连接 ，而跟连接总数无关，因此在实际的网络环境中， Epoll 的效率就会远远高于 select 和 poll 。

③. 内存拷贝， Epoll 在这点上使用了“共享内存 ”，这个内存拷贝也省略了。

 四）. Epoll 为什么高效

Epoll 的高效和其数据结构的设计是密不可分的，这个下面就会提到。

首先回忆一下 select 模型，当有 I/O 事件到来时， select 通知应用程序有事件到了快去处理，而应用程序必须轮询所有的 FD 集合，测试每个 FD 是否有事件发生，并处理事件；代码像下面这样：

[cpp] view plain copy
  1. int res = select(maxfd+1, &readfds, NULL, NULL, 120);  
  2. if (res > 0)  
  3. {  
  4.     for (int i = 0; i events = 0;  
  5.     ev->arg = arg;  
  6.     ev->status = 0;  
  7.     ev->last_active = time(NULL);  
  8. }  
  9. // add/mod an event to epoll  
  10. void EventAdd(int epollFd, int events, myevent_s *ev)  
  11. {  
  12.     struct epoll_event epv = {0, {0}};  
  13.     int op;  
  14.     epv.data.ptr = ev;  
  15.     epv.events = ev->events = events;  
  16.     if(ev->status == 1){  
  17.         op = EPOLL_CTL_MOD;  
  18.     }  
  19.     else{  
  20.         op = EPOLL_CTL_ADD;  
  21.         ev->status = 1;  
  22.     }  
  23.     if(epoll_ctl(epollFd, op, ev->fd, &epv) fd);  
  24.     else  
  25.         printf("Event Add OK[fd=%d]/n", ev->fd);  
  26. }  
  27. // delete an event from epoll  
  28. void EventDel(int epollFd, myevent_s *ev)  
  29. {  
  30.     struct epoll_event epv = {0, {0}};  
  31.     if(ev->status != 1) return;  
  32.     epv.data.ptr = ev;  
  33.     ev->status = 0;  
  34.     epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);  
  35. }  
  36. int g_epollFd;  
  37. myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd  
  38. void RecvData(int fd, int events, void *arg);  
  39. void SendData(int fd, int events, void *arg);  
  40. // accept new connections from clients  
  41. void AcceptConn(int fd, int events, void *arg)  
  42. {  
  43.     struct sockaddr_in sin;  
  44.     socklen_t len = sizeof(struct sockaddr_in);  
  45.     int nfd, i;  
  46.     // accept  
  47.     if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)  
  48.     {  
  49.         if(errno != EAGAIN && errno != EINTR)  
  50.         {  
  51.             printf("%s: bad accept", __func__);  
  52.         }  
  53.         return;  
  54.     }  
  55.     do  
  56.     {  
  57.         for(i = 0; i buff)-1, 0);    
  58.     EventDel(g_epollFd, ev);  
  59.     if(len > 0)  
  60.     {  
  61.         ev->len = len;  
  62.         ev->buff[len] = '/0';  
  63.         printf("C[%d]:%s/n", fd, ev->buff);  
  64.         // change to send event  
  65.         EventSet(ev, fd, SendData, ev);  
  66.         EventAdd(g_epollFd, EPOLLOUT|EPOLLET, ev);  
  67.     }  
  68.     else if(len == 0)  
  69.     {  
  70.         close(ev->fd);  
  71.         printf("[fd=%d] closed gracefully./n", fd);  
  72.     }  
  73.     else  
  74.     {  
  75.         close(ev->fd);  
  76.         printf("recv[fd=%d] error[%d]:%s/n", fd, errno, strerror(errno));  
  77.     }  
  78. }  
  79. // send data  
  80. void SendData(int fd, int events, void *arg)  
  81. {  
  82.     struct myevent_s *ev = (struct myevent_s*)arg;  
  83.     int len;  
  84.     // send data  
  85.     len = send(fd, ev->buff, ev->len, 0);  
  86.     ev->len = 0;  
  87.     EventDel(g_epollFd, ev);  
  88.     if(len > 0)  
  89.     {  
  90.         // change to receive event  
  91.         EventSet(ev, fd, RecvData, ev);  
  92.         EventAdd(g_epollFd, EPOLLIN|EPOLLET, ev);  
  93.     }  
  94.     else  
  95.     {  
  96.         close(ev->fd);  
  97.         printf("recv[fd=%d] error[%d]/n", fd, errno);  
  98.     }  
  99. }  
  100. void InitListenSocket(int epollFd, short port)  
  101. {  
  102.     int listenFd = socket(AF_INET, SOCK_STREAM, 0);  
  103.     fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking  
  104.     printf("server listen fd=%d/n", listenFd);  
  105.     EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);  
  106.     // add listen socket  
  107.     EventAdd(epollFd, EPOLLIN|EPOLLET, &g_Events[MAX_EVENTS]);  
  108.     // bind & listen  
  109.     sockaddr_in sin;  
  110.     bzero(&sin, sizeof(sin));  
  111.     sin.sin_family = AF_INET;  
  112.     sin.sin_addr.s_addr = INADDR_ANY;  
  113.     sin.sin_port = htons(port);  
  114.     bind(listenFd, (const sockaddr*)&sin, sizeof(sin));  
  115.     listen(listenFd, 5);  
  116. }  
  117. int main(int argc, char **argv)  
  118. {  
  119.     short port = 12345; // default port  
  120.     if(argc == 2){  
  121.         port = atoi(argv[1]);  
  122.     }  
  123.     // create epoll  
  124.     g_epollFd = epoll_create(MAX_EVENTS);  
  125.     if(g_epollFd fd, events[i].events, ev->arg);  
  126.             }  
  127.             if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event  
  128.             {  
  129.                 ev->call_back(ev->fd, events[i].events, ev->arg);  
  130.             }  
  131.         }  
  132.     }  
  133.     // free resource  
  134.     return 0;  
  135. }   

3、epoll 3.1、poll(select)的限制       Poll函数起源于SVR3，最初局限于流设备，SVR4取消了这种限制。总是来说，poll比select要高效一些，但是，它有可移植性问题，例如，windows就只支持select。 一个poll的简单例子：

代码
复制代码
#include  #include  #include  #define  TIMEOUT 5       /* poll timeout, in seconds */ int  main ( void ) {          struct  pollfd fds[ 2 ];          int  ret;          /*  watch stdin for input  */         fds[ 0 ].fd  =  STDIN_FILENO;         fds[ 0 ].events  =  POLLIN;          /*  watch stdout for ability to write (almost always true)  */         fds[ 1 ].fd  =  STDOUT_FILENO;         fds[ 1 ].events  =  POLLOUT;          /*  All set, block!  */         ret  =  poll (fds,  2 , TIMEOUT  *   1000 );          if  (ret  ==   - 1 ) {                 perror ( " poll " );                  return   1 ;         }          if  ( ! ret) {                 printf ( " %d seconds elapsed.\n " , TIMEOUT);                  return   0 ;         }          if  (fds[ 0 ].revents  &  POLLIN)                 printf ( " stdin is readable\n " );          if  (fds[ 1 ].revents  &  POLLOUT)                 printf ( " stdout is writable\n " );          return   0 ; }
复制代码

 

     select模型与此类例。内核必须遍历所有监视的描述符，而应用程序也必须遍历所有描述符，检查哪些描述符已经准备好。当描述符成百上千时，会变得非常低效——这是select(poll)模型低效的根源所在。考虑这些情况，2.6以后的内核都引进了epoll模型。

3.2、核心数据结构与接口 Epoll模型由3个函数构成，epoll_create、epoll_ctl和epoll_wait。 3.2.1创建epoll实例(Creating a New Epoll Instance)      epoll环境通过epoll_create函数创建：      #include       int epoll_create (int size)       调用成功则返回与实例关联的文件描述符，该文件描述符与真实的文件没有任何关系，仅作为接下来调用的函数的句柄。size是给内核的一个提示，告诉内核将要监视的文件描述符的数量，它不是最大值；但是，传递合适的值能够提高系统性能。发生错误时，返回-1。 例子：

int  epfd; epfd  =  epoll_create ( 100 );   /*  plan to watch ~100 fds  */ if  (epfd 
关注
打赏
1659628745
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

ClashX教程 绘画宝宝 配音宝宝
立即登录/注册

微信扫码登录

0.1843s