Thoroughly learn to use epoll (VI): Some Problems ET summary

Editor: wind over the summer ChinaUnix blog

Why 6.1 ET mode to be set to work in non-blocking mode

    Because reading and writing in ET mode until the need has been read or write error (for reading, when the actual number of bytes read is smaller than the requested number of bytes that can be stopped), and if you file descriptor, if not non-blocking, that this has been read or write is bound to be a blockage in the final. This can not be blocked on epoll_wait, resulting in other file descriptor task starve.

The difference between ET and LT 6.2

LT: trigger level, the efficiency will be lower than ET trigger, especially in large concurrent case of large flow. But the relatively low coding requirements for LT, the problem is not likely to occur. Performance on the LT-mode service is written: as long as the data has not been acquired, the kernel will continue to inform you, so do not worry about missing the event.

ET: edge trigger, the efficiency is very high, in the case of concurrent, large flow, a lot less epoll system calls than LT, and therefore high efficiency. But the high programming requirements, requires careful handling each request, or prone to loss situations events.

 

Here is an Liezi to illustrate the difference between LT and ET (both non-blocking mode, blocking is not to say, the efficiency is too low):

Using LT mode, if you accept the return call there can be established immediately in the current connection, and then wait for the next epoll_wait notification, and select the same.

But for ET, if accpet return call there, in addition to establishing the current outer join, can not immediately epoll_wait also it needs to continue circulation accpet, until the return -1 with errno == EAGAIN,

In essence: Compared with LT, ET model by reducing system calls to improve the parallel efficiency.

6.3 a backstage interview questions developed by Tencent

    Use Linux epoll model level (LT) trigger mode, when the socket can be written, it will stop triggering event socket can write, how to deal with?

The first most common way:
the time required to write data to the socket socket and only then join epoll, waiting can write event. After receiving the write event, write or send calls to send data. When all the data are finished, the socket is removed epoll.

The disadvantage of this approach is that, even if the transmission data is small, we should also join socket epoll, epoll removed after writing in, the cost of a certain operation.

An improved way:
at the beginning not to join socket epoll, need to write data to the socket, and direct calls to write or send send data. If the return EAGAIN, the socket epoll added, driven epoll write data, the entire data transmission is completed, and then removed epoll.

The advantage of this approach is: not much data can be avoided when epoll event processing, and improve efficiency.

6.4 Under what circumstances ET

Very simple, when you want to improve program efficiency.

Attaching a last epoll instance:

Click ( here) folded or unfolded

1. #include <sys/socket.h>
2. #include <sys/wait.h>
3. #include <netinet/in.h>
4. #include <netinet/tcp.h>
5. #include <sys/epoll.h>
6. #include <sys/sendfile.h>
7. #include <sys/stat.h>
8. #include <unistd.h>
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <string.h>
12. #include <strings.h>
13. #include <fcntl.h>
14. #include <errno.h>
16. #define MAX_EVENTS 10
17. #define PORT 8080
19. // set socket connection is non-blocking mode
20. void setnonblocking(int sockfd) {
21.     int opts;
22.     opts = fcntl(sockfd, F_GETFL);
23.     if(opts < 0) {
24.         perror("fcntl(F_GETFL)\n");
25.         exit(1);
26.     }
27.     opts = (opts | O_NONBLOCK);
28.     if(fcntl(sockfd, F_SETFL, opts) < 0) {
29.         perror("fcntl(F_SETFL)\n");
30.         exit(1);
31.     }
32. }
34. int main () {
35.     struct epoll_event ev, events [MAX_EVENTS]; // ev responsible for adding events, events receive a return event
36.     int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;
37.     struct sockaddr_in local, remote;
38.     char buf[BUFSIZ];
40.     // Create listen socket
41.     if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
42.         perror("sockfd\n");
43.         exit(1);
44.     }
45.     setnonblocking (listenfd); // listenfd nonblocking set [1]
46.     bzero(&local, sizeof(local));
47.     local.sin_family = AF_INET;
48.     local.sin_addr.s_addr = htonl(INADDR_ANY);;
49.     local.sin_port = htons(PORT);
50.     if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {
51.         perror("bind\n");
52.         exit(1);
53.     }
54.     listen(listenfd, 20);
56.     epfd = epoll_create(MAX_EVENTS);
57.     if (epfd == -1) {
58.         perror("epoll_create");
59.         exit(EXIT_FAILURE);
60.     }
62.     ev.events = EPOLLIN;
63.     ev.data.fd = listenfd;
64.     if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {//监听listenfd
65.         perror("epoll_ctl: listen_sock");
66.         exit(EXIT_FAILURE);
67.     }
69.     for (;;) {
70.         nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
71.         if (nfds == -1) {
72.             perror("epoll_pwait");
73.             exit(EXIT_FAILURE);
74.         }
76.         for (i = 0; i < nfds; ++i) {
77.             fd = events[i].data.fd;
78.             if (fd == listenfd) {
79.                 while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,
80.                                 (size_t *)&addrlen)) > 0) {
81.                     setnonblocking (conn_sock); // Set the following ET mode, to set the non-blocking
82.                     ev.events = EPOLLIN | EPOLLET;
83.                     ev.data.fd = conn_sock;
84.                     if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {//读监听
85.                         perror ( "epoll_ctl: add"); // connecting socket
86.                         exit(EXIT_FAILURE);
87.                     }
88.                 }
89.                 if (conn_sock == -1) {
90.                     if (errno != EAGAIN && errno != ECONNABORTED
91.                             && errno != EPROTO && errno != EINTR)
92.                         perror("accept");
93.                 }
94.                 continue;
95.             }
96.             if (events[i].events & EPOLLIN) {
97.                 n = 0;
98.                 while ((nread = read (fd, buf + n, BUFSIZ-1))> 0) {// read next has been read ET
99.                     n += nread;
100.                 }
101.                 if (nread == -1 && errno != EAGAIN) {
102.                     perror("read error");
103.                 }
104.                 ev.data.fd = fd;
105.                 ev.events = events[i].events | EPOLLOUT; //MOD OUT
106.                 if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
107.                     perror("epoll_ctl: mod");
108.                 }
109.             }
110.             if (events[i].events & EPOLLOUT) {
111.               sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World", 11);
112.                 int nwrite, data_size = strlen(buf);
113.                 n = data_size;
114.                 while (n > 0) {
115.                     nwrite = write (fd, buf + data_size - n, n); // ET the data to be written has been written
116.                     if (nwrite < n) {
117.                         if (nwrite == -1 && errno != EAGAIN) {
118.                             perror("write error");
119.                         }
120.                         break;
121.                     }
122.                     n - = nwrite;
123.                 }
124.                 close(fd);
125.             }
126.         }
127.     }
128.     return 0;
129. }