您当前的位置： 首页 >  linux

phymat.nico

暂无认证

  • 1浏览

    0关注

    1967博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

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

phymat.nico 发布时间：2018-01-18 02:59:02 ，浏览量：1

http://blog.csdn.net/tianmohust/article/details/6677985

 

 

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

 

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.1657s