The difference between horizontal departure and edge departure

There are horizontal triggers in the IO multiplexing of Linux, and the edge triggers two modes, the difference between the two modes is as follows:

Horizontal trigger: A notification is triggered if the file descriptor is ready to perform IO operations that are non-blocking. Allows the state of the IO to be repeatedly detected at any time, and it is not necessary to perform as many io.select,poll as possible after each descriptor is in the horizontal trigger.

Edge Trigger: A notification is triggered if a file descriptor has a new IO activity since the last state change. To perform as many IO operations as possible after receiving an IO event notification, Because if you do not complete IO in one notification, you will need to wait until the next new IO activity arrives to get the ready descriptor. The signal-driven IO is an edge trigger.

The epoll can be triggered either horizontally or by edge.

You may not be fully aware of the differences between the two models, we can illustrate: a pipeline received 1kb of data, Epoll will immediately return, this time read 512 bytes of data, and then call Epoll again. If it is triggered horizontally, Epoll will return immediately, Because there is data ready. If the edge trigger does not return immediately, because the data is readable but has triggered a notification, there is no new data to arrive at this time, until new data arrives Epoll will return, when the old data and new data can be read to ( Of course it is necessary for you to read as much as possible this time).

Here we also explain from an electronic point of view:

Horizontal trigger: The notification is triggered only when the high level (1) or low (0) is activated, as long as the two States are notified. As long as there is data readable (descriptor ready), the horizontally triggered epoll returns immediately.

Edge triggering: Notifications are triggered only when the level changes (high to low, or low to high). The above mentioned that even if there is data to be readable, but no new IO activity arrives, Epoll will not return immediately.

Edge Trigger (edge-triggered) ET: an event is triggered whenever the state changes.

"to read the socket example, assume that after a long period of silence, there are now 100 bytes, and both the edge trigger and the conditional trigger will produce a read Ready notification notification application. The application reads 50 bytes and then calls the API again to wait for the IO event. At this point the horizontally triggered API will return the user immediately to a read ready notification because there are still 50 bytes of readable. The edge-triggered API is stuck for long waits because the readable state does not change. So when using edge-triggered APIs, be aware that each time you read the socket back to ewouldblock, otherwise the socket is obsolete. When using the conditional-triggered API, do not focus on the socket writable event if the application does not need to write, or it will return a write ready notification an unlimited number of times. Everyone commonly used Select is the level trigger this category, long-term concern socket write event will appear CPU 100% problem.

2. /*************************************************************************
4. > File name:t_select.c
6. > Author:liuxingen
8. > Mail: [email protected]
10. > Created time:2014 August 11 Monday 21:22 32 seconds
12. ************************************************************************/
16. #include <stdio.h>
18. #include <unistd.h>
20. #include <sys/types.h>
22. #include <sys/time.h>
24. #include <sys/select.h>
26. #include <string.h>
28. #include <errno.h>
32. int Main (int argc, char *argv[])
34. {
36. struct Timeval timeout;
38. Char buf[10];
40. Fd_set Readfds;
42. int nread, Nfds, ready, FD;
46. while (1)
48. {
50. Timeout.tv_sec = 20L;
52. timeout.tv_usec = 0;
56. FD = 0; Stdin
58. Nfds = fd + 1;
60. Fd_zero (&readfds);
62. Fd_set (FD, &readfds);
66. Ready = Select (Nfds, &readfds, NULL, NULL, &timeout);
68. if (ready = =-1 && errno = = eintr)
70. {
72. Continue
74. }else if (ready = =-1)
76. {
78. fprintf (stderr, "select Error:%s\n", Strerror (errno));
80. }
82. for (fd = 0; fd < Nfds; fd++)
84. {
86. if (Fd_isset (FD, &readfds))
88. {
90. Nread = Read (FD, buf, 9);
92. Buf[nread] = ' + ';
94. Puts (BUF);
96. }
98. }
100. }
104. return 0;
106. }

The above example reads up to 9 bytes at a time, and when we enter 20 bytes at a time and then three calls to select, the data is immediately read every time, which proves that the select will return as soon as the data is ready in the horizontal trigger.

[Plain]View Plaincopy

1. [Email protected]:~/station$./t_select
2. Ni hao ma, wo hen hao A, ni ne???
3. Ni hao Ma
4. , Wo Hen
5. Hao A, ni
6. Ne???
8. ^c

[CPP]View Plaincopy

2. /*************************************************************************
4. > File name:demo_sigio.c
6. > Author:liuxingen
8. > Mail: [email protected]
10. > Created time:2014 August 14 Thursday 21:32 03 seconds
12. ************************************************************************/
16. #include <stdio.h>
18. #include <unistd.h>
20. #include <string.h>
22. #include <errno.h>
24. #include <ctype.h>
26. #include <signal.h>
28. #include <fcntl.h>
32. static int g_fd;
36. static void Sigio_handler (int signum)
38. {
40. char buf[8] = {0};
44. if (read (G_FD, buf, 7) < 0)
46. {
48. fprintf (stderr, "read error:%s\n", Strerror (errno));
50. }else
52. {
54. printf ("Sigio recv:%s\n", buf);
56. }
58. }
60. int Main (int argc, char *argv[])
62. {
64. struct Sigaction Act;
66. int flags, i = 1, fds[2];
68. pid_t pid;
72. if (pipe (FDS) < 0)
74. {
76. fprintf (stderr, "Pipe error:%s\n", strerror (errno));
78. return 1;
80. }
82. if ((PID = fork ()) > 0)
84. {
86. Close (fds[1]);
88. Dup2 (Fds[0], g_fd);
92. Sigemptyset (&act.sa_mask);
94. Act.sa_flags = Sa_restart;
96. Act.sa_handler = Sigio_handler;
98. if (Sigaction (SIGIO, &act, NULL) = =-1)
100. {
102. fprintf (stderr, "Sigaction error:%s\n", Strerror (errno));
104. return 1;
106. }
110. if (Fcntl (G_FD, F_setown, getpid ()) = =-1)
112. {
114. fprintf (stderr, "Fcntl f_setown error:%s\n", Strerror (errno));
116. return 1;
118. }
122. Flags = FCNTL (G_FD, F_GETFL);
124. if (Fcntl (G_FD, F_SETFL, Flags | O_async | O_nonblock) = =-1)
126. {
128. fprintf (stderr, "Fcntl f_getfl error:%s\n", Strerror (errno));
130. return 1;
132. }
134. while (1)
136. {
138. Sleep (10);
140. }
142. }else
144. {
146. char buf[20] = {0};
148. Close (Fds[0]);
150. for (i = 0; i < 3; i++)
152. {
154. snprintf (BUF, "This is loop%d", i);
156. Write (Fds[1], buf, strlen (BUF));
158. printf ("Loop%d\n", i);
160. Sleep (3);
162. }
164. }
168. return 0;
170. }

Because the signal-driven IO is an edge trigger, the above is an example of a signal driver. From the output below you can tell: we write 14 bytes at a time, but we only read 7 bytes at a time, unless we wait until the next data write and no longer trigger the sigio signal. And the last unread data will continue to be read the next time.

[Plain]View Plaincopy

1. [Email protected]:~/station$./demo_sigio
2. Loop 0
3. Sigio Recv:this is
4. Loop 1
5. Sigio Recv:loop 0
6. Loop 2
7. Sigio Recv:this is
8. Sigio Recv:loop 1
9. ^c

The difference between horizontal departure and edge departure