Linux epoll introduction and program instance http://blog.csdn.net/sparkliang/article/details/4770655

Linux epoll introduction and program example

1. Where is epoll sacred?

Epoll is currently a hot candidate for developing large-scale concurrent network programs in Linux. epoll is officially introduced in the linux2.6 kernel, similar to select, in fact bothI/OMultiplexing TechnologyAnd there is nothing mysterious.

In fact, there is always no way to design concurrent network programs in Linux, such as the typical Apache model (process per connection (PPC) and TPC (thread per connection) models, as well as the select model and poll model, why should we introduce epoll? That's something to talk about...

2. disadvantages of common models

If the disadvantages of other models are not shown, how can we compare the advantages of epoll.

2.1 PPC/TPC Model

These two models share the same idea:Let every incoming connection work on its own. Don't bother me anymore.. Only PPC opens a process for it, while TPC opens a thread. But don't bother me. There is a price. It requires time and space. When there are too many connections, so many processes/threads will switch, and this overhead will come up; therefore, the maximum number of connections that this type of model can accept is not high, generally about several hundred.

2.2 select model

1. maximum number of concurrent threads, because the FD opened by a process (file descriptor) is limited, which is set by fd_setsize. The default value is 1024/2048, therefore, the maximum concurrency of the select model is limited accordingly. Modify fd_setsize by yourself? Although the idea is good, let's take a look at the following...

2. efficiency problems: each select call will linearly scan all FD sets, which will result in a linear decline in efficiency. The consequence of increasing the fd_setsize is that everyone is coming slowly. What? All timeout ??!!

3. How does the kernel notify the user of the FD message when copying the kernel/user space memory? On this issue, select adopts the memory copy method.

2.3 poll Model

Basically, the efficiency is the same as that of select. The two and three disadvantages of select are not modified.

3. epoll Improvement

I criticized other models one by one. Let's take a look at epoll's improvements. In fact, the disadvantages of select are the advantages of epoll.

3.1. epoll does not have the maximum number of concurrent connections. The maximum number is the maximum number of files that can be opened. This number is generally greater than 2048,Generally, this number has a great relationship with the system memory.The number can be viewed in CAT/proc/sys/fs/file-max.

3.2. The biggest advantage of epoll is its efficiency improvementOnly your "active" ConnectionsAnd has nothing to do with the total number of connections. Therefore, in the actual network environment, epoll is much more efficient than select and poll.

3.3. memory copy, epoll uses"Shared Memory", This memory copy is also omitted.

 

 

4. Why is epoll efficient?

The efficiency of epoll is inseparable from the design of its data structure, which will be mentioned below.

First, let's recall the select model. When an I/O event arrives, select notifies the application that an event has been processed quickly, and the application must Round-Robin all FD sets, test whether an event occurs in each FD and process the event. The Code is as follows:

 

Int res = select (maxfd + 1, & readfds, null, null, and 120 );

If (RES> 0)

{

For (INT I = 0; I <max_connection; I ++)

{

If (fd_isset (allconnection [I], & readfds ))

{

Handleevent (allconnection [I]);

}

}

}

// If (RES = 0) handle timeout, Res <0 handle error

 

Epoll not only tells the application that there is an I/0 event, but also tells the application-related information, which is filled by the application, therefore, based on this information, the application can directly locate the event without traversing the entire FD set.

Int res = epoll_wait (epfd, events, 20,120 );

For (INT I = 0; I <res; I ++)

{

Handleevent (events [N]);

}

5. epoll Key Data Structure

As mentioned above, epoll is fast and closely related to its data structure. Its key data structure is:

Struct epoll_event {

_ Uint32_t events; // epoll events

Epoll_data_t data; // user data variable

};

Typedef Union epoll_data {

Void * PTR;

Int FD;

_ Uint32_t u32;

_ Uint64_t u64;

} Epoll_data_t;

It can be seen that epoll_data is a Union struct, which can store many types of information such as FD and pointer. With it, the application can directly locate the target.

6. Use epoll

Since epoll is better than select, how can it be used? Will it be complicated... Let's take a look at the three functions below to see how easy epoll is to use.

 

Int epoll_create (INT size );

Generating an epoll-specific file descriptor is actually applying for a kernel space to store whether or not the socket FD you want to pay attention to occurs and what events have occurred. Size is the maximum number of socket FD you can pay attention to on this epoll FD. The size is customized as long as the memory is sufficient.

Int epoll_ctl (INT epfd, int op, int FD, struct epoll_event * event );

Controls events on an epoll file descriptor: Registration, modification, and deletion. The epfd parameter is the file descriptor used to create epoll for epoll_create. Compared with the fd_set and fd_clr macros in the select model.

Int epoll_wait (INT epfd, struct epoll_event * events, int maxevents, int timeout );

Wait for the occurrence of an I/O event. parameter description:

Epfd:Epoll_create ()The generated epoll-specific file descriptor;

Epoll_event: the array used to return the events to be processed;

Maxevents: Number of events that can be processed each time;

Timeout: the timeout value for waiting for an I/O event;

Number of events returned.

Compared with the select function in the select model.

7. Example Program

The following is an example of a simple echo server program. Although it is small and dirty, it also contains a simple timeout check mechanism. For the sake of simplicity, no error handling is performed.

 

[CPP]View plaincopy

1. //
2. // A simple echo server using epoll in Linux
3. //
4. // 11-011-
5. // By sparkling
6. //
7. # Include <sys/socket. h>
8. # Include <sys/epoll. h>
9. # Include <netinet/in. h>
10. # Include <ARPA/inet. h>
11. # Include <fcntl. h>
12. # Include <unistd. h>
13. # Include <stdio. h>
14. # Include <errno. h>
15. # Include <iostream>
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) <0)
54. Printf ("event add failed [FD = % d]/n", ev-> FD );
55. Else
56. Printf ("event add OK [FD = % d]/n", ev-> FD );
57. }
58. // Delete an event from epoll
59. Void eventdel (INT epollfd, myevent_s * eV)
60. {
61. Struct epoll_event EPV = {0, {0 }};
62. If (ev-> status! = 1) return;
63. EPV. Data. PTR = EV;
64. Ev-> Status = 0;
65. Epoll_ctl (epollfd, epoll_ctl_del, ev-> FD, & EPV );
66. }
67. Int g_epollfd;
68. Myevent_s g_events [max_events + 1]; // g_events [max_events] is used by listen FD
69. Void recvdata (int fd, int events, void * Arg );
70. Void senddata (int fd, int events, void * Arg );
71. // Accept new connections from clients
72. Void acceptconn (int fd, int events, void * Arg)
73. {
74. Struct sockaddr_in sin;
75. Socklen_t Len = sizeof (struct sockaddr_in );
76. Int NFD, I;
77. // Accept
78. If (NFD = accept (FD, (struct sockaddr *) & sin, & Len) =-1)
79. {
80. If (errno! = Eagain & errno! = Eintr)
81. {
82. Printf ("% s: Bad accept", _ FUNC __);
83. }
84. Return;
85. }
86. Do
87. {
88. For (I = 0; I <max_events; I ++)
89. {
90. If (g_events [I]. Status = 0)
91. {
92. Break;
93. }
94. }
95. If (I = max_events)
96. {
97. Printf ("% s: Max connection limit [% d].", _ FUNC __, max_events );
98. Break;
99. }
100. // Set nonblocking
101. If (fcntl (NFD, f_setfl, o_nonblock) <0) break;
102. // Add a read event for receive data
103. Eventset (& g_events [I], NFD, recvdata, & g_events [I]);
104. Eventadd (g_epollfd, epollin | epollet, & g_events [I]);
105. Printf ("New conn [% s: % d] [Time: % d]/n", inet_ntoa (sin. sin_addr), ntohs (sin. sin_port), g_events [I]. last_active );
106. } While (0 );
107. }
108. // Receive data
109. Void recvdata (int fd, int events, void * Arg)
110. {
111. Struct myevent_s * EV = (struct myevent_s *) ARG;
112. Int Len;
113. // Receive data
114. Len = Recv (FD, ev-> buff, sizeof (ev-> buff)-1, 0 );
115. Eventdel (g_epollfd, Ev );
116. If (LEN> 0)
117. {
118. Ev-> Len = Len;
119. Ev-> buff [Len] = '/0 ';
120. Printf ("C [% d]: % s/n", FD, ev-> buff );
121. // Change to send event
122. Eventset (EV, FD, senddata, Ev );
123. Eventadd (g_epollfd, epollout | epollet, Ev );
124. }
125. Else if (LEN = 0)
126. {
127. Close (ev-> FD );
128. Printf ("[FD = % d] closed gracefully./N", FD );
129. }
130. Else
131. {
132. Close (ev-> FD );
133. Printf ("Recv [FD = % d] error [% d]: % s/n", FD, errno, strerror (errno ));
134. }
135. }
136. // Send data
137. Void senddata (int fd, int events, void * Arg)
138. {
139. Struct myevent_s * EV = (struct myevent_s *) ARG;
140. Int Len;
141. // Send data
142. Len = Send (FD, ev-> buff, ev-> Len, 0 );
143. Ev-> Len = 0;
144. Eventdel (g_epollfd, Ev );
145. If (LEN> 0)
146. {
147. // Change to receive event
148. Eventset (EV, FD, recvdata, Ev );
149. Eventadd (g_epollfd, epollin | epollet, Ev );
150. }
151. Else
152. {
153. Close (ev-> FD );
154. Printf ("Recv [FD = % d] error [% d]/n", FD, errno );
155. }
156. }
157. Void initlistensocket (INT epollfd, short port)
158. {
159. Int listenfd = socket (af_inet, sock_stream, 0 );
160. Fcntl (listenfd, f_setfl, o_nonblock); // set non-blocking
161. Printf ("server listen FD = % d/N", listenfd );
162. Eventset (& g_events [max_events], listenfd, acceptconn, & g_events [max_events]);
163. // Add listen socket
164. Eventadd (epollfd, epollin | epollet, & g_events [max_events]);
165. // Bind & listen
166. Sockaddr_in sin;
167. Bzero (& sin, sizeof (SIN ));
168. Sin. sin_family = af_inet;
169. Sin. sin_addr.s_addr = inaddr_any;
170. Sin. sin_port = htons (port );
171. BIND (listenfd, (const sockaddr *) & sin, sizeof (SIN ));
172. Listen (listenfd, 5 );
173. }
174. Int main (INT argc, char ** argv)
175. {
176. Short Port = 12345; // default port
177. If (argc = 2 ){
178. Port = atoi (argv [1]);
179. }
180. // Create epoll
181. G_epollfd = epoll_create (max_events );
182. If (g_epollfd <= 0) printf ("create epoll failed. % d/N", g_epollfd );
183. // Create & bind listen socket, and add to epoll, set non-blocking
184. Initlistensocket (g_epollfd, Port );
185. // Event Loop
186. Struct epoll_event events [max_events];
187. Printf ("server running: Port [% d]/n", Port );
188. Int checkpos = 0;
189. While (1 ){
190. // A simple timeout check here, every time 100, better to use a mini-heap, and add timer event
191. Long Now = Time (null );
192. For (INT I = 0; I <100; I ++, checkpos ++) // doesn' t check listen FD
193. {
194. If (checkpos = max_events) checkpos = 0; // Recycle
195. If (g_events [checkpos]. status! = 1) continue;
196. Long Duration = now-g_events [checkpos]. last_active;
197. If (duration> = 60) // 60 s timeout
198. {
199. Close (g_events [checkpos]. FD );
200. Printf ("[FD = % d] timeout [% d -- % d]./N", g_events [checkpos]. FD, g_events [checkpos]. last_active, now );
201. Eventdel (g_epollfd, & g_events [checkpos]);
202. }
203. }
204. // Wait for events to happen
205. Int FDS = epoll_wait (g_epollfd, events, max_events, 1000 );
206. If (FDS <0 ){
207. Printf ("epoll_wait error, exit/N ");
208. Break;
209. }
210. For (INT I = 0; I <FDS; I ++ ){
211. Myevent_s * EV = (struct myevent_s *) events [I]. Data. PTR;
212. If (events [I]. Events & epollin) & (ev-> events & epollin) // read event
213. {
214. Ev-> call_back (ev-> FD, events [I]. Events, ev-> Arg );
215. }
216. If (events [I]. Events & epollout) & (ev-> events & epollout) // write event
217. {
218. Ev-> call_back (ev-> FD, events [I]. Events, ev-> Arg );
219. }
220. }
221. }
222. // Free resource
223. Return 0;
224. }