linux的epoll使用ET模式应当如何正确处理EPOLLOUT和EPOLLIN事件？

future0906

hi,all
     最近在开发一个网络游戏服务器，使用epoll的ET模式。看了网上很多的资料，一些基本的概念，
例如accept和recive要到返回EAGAIN或EWOULDBLOCK才停止。
问题：
     如EPOLL的作者Davide Libenzi所说，如果你对一fd同时注册EPOLLIN | EPOLLOUT事件，
即使发送缓冲区并非由满变空，也会触发EPOLLOUT事件（参考链接：http://www.0x61.com/forum/post3712824.html）。

     他指出使用epoll的最好是用ATM模式，当真正需要用到EPOLLOUT时才注册。我理解的ATM模式就是读、写、读、写这样的循环。
像converse兄在一篇epoll笔记中的代码（经过修改）：

1. #include <iostream>
   
2. #include <sys/socket.h>
   
3. #include <sys/epoll.h>
   
4. #include <netinet/in.h>
   
5. #include <arpa/inet.h>
   
6. #include <fcntl.h>
   
7. #include <unistd.h>
   
8. #include <stdio.h>
   
9. #include <errno.h>
   
10. 
    
11. using namespace std;
    
12. 
    
13. #define MAXLINE 5
    
14. #define OPEN_MAX 100
    
15. #define LISTENQ 20
    
16. #define SERV_PORT 9980
    
17. #define INFTIM 1000
    
18. 
    
19. void setnonblocking(int sock)
    
20. {
    
21.     int opts;
    
22.     opts=fcntl(sock,F_GETFL);
    
23.     if(opts<0)
    
24.     {
    
25.         perror("fcntl(sock,GETFL)");
    
26.         exit(1);
    
27.     }
    
28.     opts = opts|O_NONBLOCK;
    
29.     if(fcntl(sock,F_SETFL,opts)<0)
    
30.     {
    
31.         perror("fcntl(sock,SETFL,opts)");
    
32.         exit(1);
    
33.     }
    
34. }
    
35. 
    
36. int main()
    
37. {
    
38.     int i, maxi, listenfd, connfd, sockfd,epfd,nfds;
    
39.     ssize_t n;
    
40.     char line[MAXLINE];
    
41.     socklen_t clilen;
    
42.     //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
    
43.     struct epoll_event ev,events[20];
    
44.     //生成用于处理accept的epoll专用的文件描述符
    
45.     epfd=epoll_create(256);
    
46.     struct sockaddr_in clientaddr;
    
47.     struct sockaddr_in serveraddr;
    
48. 
    
49.     listenfd = socket(AF_INET, SOCK_STREAM, 0);
    
50.     //把socket设置为非阻塞方式
    
51.     setnonblocking(listenfd);
    
52.     //设置与要处理的事件相关的文件描述符
    
53.     ev.data.fd=listenfd;
    
54.     //设置要处理的事件类型
    
55.     ev.events=EPOLLIN|EPOLLET;
    
56.     //ev.events=EPOLLIN;
    
57.     //注册epoll事件
    
58.     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
    
59.     bzero(&serveraddr, sizeof(serveraddr));
    
60.     serveraddr.sin_family = AF_INET;
    
61.     char *local_addr="0.0.0.0";
    
62.     inet_aton(local_addr,&(serveraddr.sin_addr));//htons(SERV_PORT);
    
63.     serveraddr.sin_port=htons(SERV_PORT);
    
64.     bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
    
65.     listen(listenfd, LISTENQ);
    
66.     maxi = 0;
    
67.     for ( ; ; ) {
    
68.         static int last_fd = 0;
    
69.         char empty[10240];
    
70.         send(last_fd, empty, sizeof(empty), MSG_DONTWAIT);
    
71.         //等待epoll事件的发生
    
72.         nfds=epoll_wait(epfd,events,20,500);
    
73.         //处理所发生的所有事件
    
74.         for(i=0;i<nfds;++i)
    
75.         {
    
76.             if(events[i].data.fd==listenfd)
    
77.             {
    
78.                 connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
    
79.                 if(connfd<0){
    
80.                     perror("connfd<0");
    
81.                     exit(1);
    
82.                 }
    
83.                 //setnonblocking(connfd);
    
84.                 char *str = inet_ntoa(clientaddr.sin_addr);
    
85.                 cout << "accapt a connection from " << str << endl;
    
86.                 //设置用于读操作的文件描述符
    
87.                 ev.data.fd=connfd;
    
88.                 //设置用于注测的读操作事件
    
89.                 ev.events=EPOLLIN|EPOLLET;
    
90.                 //ev.events=EPOLLIN;
    
91.                 //注册ev
    
92.                 epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
    
93.             }
    
94.             else if(events[i].events&EPOLLIN)
    
95.             {
    
96. 
    
97.                 cout << "EPOLLIN" << endl;
    
98.                 if ( (sockfd = events[i].data.fd) < 0)
    
99.                     continue;
    
100.                 if ( (n = read(sockfd, line, MAXLINE)) < 0) {
     
101.                     if (errno == ECONNRESET) {
     
102.                         close(sockfd);
     
103.                         events[i].data.fd = -1;
     
104.                     } else
     
105.                         std::cout<<"readline error"<<std::endl;
     
106.                 } else if (n == 0) {
     
107.                     close(sockfd);
     
108.                     events[i].data.fd = -1;
     
109.                 }
     
110.                 line[n] = '\0';
     
111.                 cout << "read " << line << endl;
     
112.                 //设置用于写操作的文件描述符
     
113.                 ev.data.fd=sockfd;
     
114.                 //设置用于注测的写操作事件
     
115.                 ev.events=EPOLLOUT|EPOLLET;
     
116.                 //修改sockfd上要处理的事件为EPOLLOUT
     
117.                 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
     
118.                 last_fd = sockfd;
     
119.             }
     
120.             else if(events[i].events&EPOLLOUT)
     
121.             {
     
122.                 sockfd = events[i].data.fd;
     
123.                 write(sockfd, line, n);
     
124.                 //设置用于读操作的文件描述符
     
125.                 ev.data.fd=sockfd;
     
126.                 //设置用于注测的读操作事件
     
127.                 ev.events=EPOLLIN|EPOLLET;
     
128.                 //修改sockfd上要处理的事件为EPOLIN
     
129.                 epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
     
130.             }
     
131.         }
     
132.     }
     
133.     return 0;
     
134. }

复制代码

不过，假如发送缓冲区一直满，那就不会触发EPOLLOUT事件，那就不会切换到读取模式，那读出的数据就会变慢了。

请问正确处理这两个事件的框架是怎样的呢？

Jim_WangGang

我对此表示十分关注

xtlx2000

你知道的也就你说的这么用了。。囧。。。。

hellioncu

如果你来逻辑是 接收-》处理-》发送，发送来不及了，接收了数据处理也没用，还得等着发送

future0906

如果你来逻辑是 接收-》处理-》发送，发送来不及了，接收了数据处理也没用，还得等着发送
hellioncu 发表于 2011-01-26 08:45

    发送时除了内核的缓冲区以外  我自己也有一个缓冲区，动态增长的，所以暂时发不出去也没问题
    但如果我接收慢了的话，数据会不会丢失呢？

    我看了一下ngix的epoll模块，对于EPOLLOUT和EPOLLIN，他们都是在需要的时候才注册的。两个可能两个同时注册，同时注册时其实就多几次系统调用。

hellioncu

发送时除了内核的缓冲区以外  我自己也有一个缓冲区，动态增长的，所以暂时发不出去也没问题
   ...
future0906 发表于 2011-01-26 10:28

    又不是UDP，不会丢

future0906

回复 6# hellioncu


    那你的意思就是说上面的EPOLLOUT->EPOLLIN->EPOLLOUT的模式是没问题的 是吗？

hellioncu

回复  hellioncu


    那你的意思就是说上面的EPOLLOUT->EPOLLIN->EPOLLOUT的模式是没问题的 是吗？
future0906 发表于 2011-01-26 10:49

    ET模式accept、read等要循环直到失败。

实际上我觉得还是LT模式好用，没觉得性能有啥不好

chenzhanyiczy

为什么要EPOLLOUT->EPOLLIN->EPOLLOUT？业务逻辑需要？

deanshuai

具体什么逻辑是开发决定的。

                //设置用于写操作的文件描述符

                ev.data.fd=sockfd;

                      //设置用于注测的写操作事件。这里是开发者决定的，如果没有不关注写操作，只关注读，这里可以接着修改为监听读服务。
              /*
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并未清空，只是事件类型清空。这一步非常重要。
              */

                ev.events=EPOLLOUT|EPOLLET;

                 //修改sockfd上要处理的事件为EPOLLOUT

                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);

楼主给的代码是比较简单的。
ET方式，读必须判断是不是都读完了。
写必须要关注返回值，当返回值小于实际要发送的数量，说明该id已经不能写了，所以就要设置监听这个端口可写。当触发可写的时候把没发送完的数据发送完。