请问epoll应该怎么用才能体现出高性能?

草肃威

我在网上抄了一段使用epoll的代码,大概的流程就是
主线程 --> 阻塞在accept()上,一旦有连接过来就放到epoll监听事件队列中去
其他线程 --> 各自从epoll的队列里面取出连接进行处理.

现在问题是,我在一台 双至强 E5220,共16核,4G 内存的机器上跑,在另一台一样的机器上用http_load压,最多只能跑到 1w fetchs/s

1. 
   
2. ./http_load -p 1000 -f 1000000 ./url 2>/dev/null               
   
3. 1000000 fetches, 1000 max parallel, 4.01402e+09 bytes, in 96.1637 seconds
   
4. 4014.02 mean bytes/connection
   
5. 10398.9 fetches/sec, 4.17415e+07 bytes/sec
   

复制代码

请问这个在代码层面上应该怎么改进? 或者说,这种多路事件处理的模型根本就是不合理的?

1. #include <iostream>
   
2. #include <cstring>
   
3. #include <string>
   
4. #include <sys/types.h>
   
5. #include <sys/socket.h>
   
6. #include <netinet/in.h>
   
7. #include <errno.h>
   
8. #include <pthread.h>
   
9. #include <sys/epoll.h>
   
10. #include <unistd.h>
    
11. #include <fcntl.h>
    
12. #include <signal.h>
    
13. 
    
14. #include "http_response.h"
    
15. 
    
16. using namespace std;
    
17. 
    
18. inline void log_error(char *c);
    
19. int read_write(int *sock_fd);
    
20. void do_accept(int *epoll_fd);
    
21. 
    
22. const int THREAD_NUMBER = 8;
    
23. const int MAX_FDS = 4096;
    
24. const int EPOLL_TIMEOUT = 1000;
    
25. 
    
26. 
    
27. int sock_fd;
    
28. 
    
29. pthread_mutex_t fd_mutex;
    
30. 
    
31. int main(void){
    
32.         int rc = 0;
    
33.         sock_fd = socket(PF_INET, SOCK_STREAM, 0);
    
34.         if(-1 == sock_fd) log_error("socket error");
    
35. 
    
36.         /*
    
37.         rc = fcntl(sock_fd, F_SETFL, O_NONBLOCK);
    
38.         if(rc == -1) log_error("fcntl set nonblock error");
    
39.         */
    
40. 
    
41.         int val = 1;
    
42.         rc = setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
    
43.         if(rc != 0) log_error("setsockopt error");
    
44. 
    
45.         struct sockaddr_in addr;
    
46.         memset(&addr, 0, sizeof(addr));
    
47. 
    
48.         addr.sin_port = htons(1819);
    
49.         addr.sin_family = AF_INET;
    
50.         addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
51. 
    
52.         rc = bind(sock_fd, (struct sockaddr*)&addr, sizeof(addr));
    
53.         if(rc != 0) log_error("bind error");
    
54. 
    
55.         rc = listen(sock_fd, 1024);
    
56.         if(rc != 0) log_error("listen error");
    
57. 
    
58.         // 创建epoll描述符
    
59.         int epoll_fd = epoll_create(MAX_FDS);
    
60.         if(epoll_fd == -1) log_error("epoll_create error");
    
61. 
    
62.         pthread_t th[THREAD_NUMBER];
    
63.         pthread_attr_t attr;
    
64. 
    
65.         pthread_attr_init(&attr);
    
66. 
    
67.         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    
68. 
    
69.         pthread_mutex_init(&fd_mutex, NULL);
    
70. 
    
71.         for(int i = 0; i < THREAD_NUMBER; ++i)
    
72.                 pthread_create(&th[i], &attr, (void*(*)(void*))read_write, &epoll_fd);
    
73. 
    
74.         do_accept(&epoll_fd);
    
75. 
    
76.         return 0;
    
77. }
    
78. 
    
79. inline void log_error(char *c){
    
80.         cout<<c<<": "<<strerror(errno)<<endl;
    
81.         _exit(-1);
    
82. }
    
83. 
    
84. void do_accept(int *epoll_fd){
    
85.         int rc = 0;
    
86.         int connect_fd = 0;
    
87.         struct epoll_event ev;
    
88. 
    
89.         while(1){
    
90.         //        pthread_mutex_lock(&fd_mutex);
    
91.                 connect_fd = accept(sock_fd, NULL, NULL);
    
92.         //        pthread_mutex_unlock(&fd_mutex);
    
93. 
    
94.                 if(connect_fd > 0){
    
95.                         rc = fcntl(connect_fd, F_SETFL, O_NONBLOCK);
    
96.                         if(rc == -1){log_error("fcntl set nonblock error");}
    
97. 
    
98.                         ev.data.fd = connect_fd;
    
99.                         ev.events = EPOLLIN | EPOLLOUT | EPOLLET | EPOLLERR | EPOLLHUP | EPOLLPRI;
    
100. 
     
101.                         rc = epoll_ctl(*epoll_fd, EPOLL_CTL_ADD, connect_fd, &ev);
     
102.                         if(rc == -1) { log_error("epoll_ctl add socket fd error");}
     
103.                 }
     
104.         }
     
105. }
     
106. 
     
107. int read_write(int *epoll_fd){
     
108.         int count = 0;
     
109. 
     
110.         struct epoll_event ev, events[MAX_FDS];
     
111. 
     
112.         char r_buffer[4096];
     
113.         char w_buffer[4096] = "HTTP/1.1 200 OK\r\nContent-Length: 5\r\nConnection: close\r\nContent-Type: text/html\r\n\r\nHello";
     
114. 
     
115.         #define data_fd (events[i].data.fd)
     
116. 
     
117.         while(1){
     
118.                 count = epoll_wait(*epoll_fd, events, MAX_FDS, 1000);
     
119. 
     
120.                 for(int i = 0; i < count; ++i){
     
121.                         if(events[i].events&EPOLLIN){
     
122.                                 read(data_fd, r_buffer, sizeof(r_buffer));
     
123. 
     
124.                                 ev.data.fd = data_fd;
     
125.                                 ev.events = EPOLLET | EPOLLOUT;
     
126.                                 epoll_ctl(*epoll_fd, EPOLL_CTL_MOD, data_fd, &ev);
     
127.                         }
     
128.                         else if(events[i].events&EPOLLOUT){
     
129.                                 write(data_fd, w_buffer, sizeof(w_buffer));
     
130. 
     
131.                                 ev.data.fd = data_fd;
     
132.                                 epoll_ctl(*epoll_fd, EPOLL_CTL_DEL, data_fd, &ev);
     
133.                                 close(data_fd);
     
134.                         }
     
135.                         else{
     
136.                                 ev.data.fd = data_fd;
     
137.                                 epoll_ctl(*epoll_fd, EPOLL_CTL_DEL, data_fd, &ev);
     
138. 
     
139.                                 close(data_fd);
     
140.                         }
     
141.                 }
     
142.         }
     
143. 
     
144.         return 0;
     
145. }
     
146. 
     

复制代码

drangon

先看看瓶颈在什么地方，再针对性进行优化，在很多环境下，其实epoll和select、poll差不多，其他地方的处理的优化空间大多了

草肃威

CPU的使用率一直都很高,长时间维持在100%左右
另外,拿strace -c -p PID看的时候, 70%的时间被用在了epoll_ctl上了,30%多的是在accept上面

我拿lighttpd也试过这样的测试,如果只是跑这样hello world的代码
lighttpd,8个worker跑的时候cpu只会在40%左右,而http_load的测试结果能达到
1.5w fetches/sec

samlumengjun

epoll对与select的区别在于大量长连接时不需要去轮讯每个文件描述符,所以只有在存在大量长连接时,epoll才有它的优势.

草肃威

那你的意思是我这个在代码的层面上没有调优的空间了?

lenky0401

要调优首先需要找到短板 用oprofile或gprof分析一下