Nginx Source Learning Notes (21)--event module Two--event-driven core ngx_process_events_and_timers

first of all continue to recall that, before the execution of the sub-thread has a content that is not involved ngx_process_events_and_timers, today we will study this function.

This post is from:http://blog.csdn.net/lengzijian/article/details/7601730

Let's take a look at section 19th:

Today's main explanation is the event-driven function, the red part of the diagram:

[CPP] View plaincopyprint?

2. Src/event/ngx_event.c
6. void
8. Ngx_process_events_and_timers (ngx_cycle_t *cycle)
10. {
12. NGX_UINT_T flags;
14. ngx_msec_t timer, Delta;
18. if (ngx_timer_resolution) {
20. timer = Ngx_timer_infinite;
22. Flags = 0;
26. } Else {
28. Timer = Ngx_event_find_timer ();
30. Flags = Ngx_update_time;
32. }
36. /*
38. The Ngx_use_accept_mutex variable represents whether the accept mutex is used
40. The default is to use, can pass Accept_mutex off;
42. the role of the accept mutex is to avoid surprise groups while achieving load balancing
44. */
46. if (Ngx_use_accept_mutex) {
50. /*
52. The ngx_accept_disabled variable is calculated in the Ngx_event_accept function.
54. if ngx_accept_disabled is greater than 0, it means that the process accepts more chains,
56. so give up a chance to grab the mutex and reduce yourself by one.
58. then, continue processing the events on the existing connection.
60. Nginx uses this to implement the basic load balancing of the connection.
62. */
64. if (ngx_accept_disabled > 0) {
66. ngx_accept_disabled--;
70. } Else {
72. /*
74. attempting to lock the accept mutex, only the process that successfully acquires the lock will place the listen socket in Epoll.
76. Therefore, this ensures that only one process has a listener interface, so all processes are blocked at epoll_wait,
78. will not surprise the group phenomenon.
80. */
82. if (Ngx_trylock_accept_mutex (cycle) = = Ngx_error) {
84. return ;
86. }
90. if (Ngx_accept_mutex_held) {
92. /*
94. If the process obtains a lock, a ngx_post_events flag is added.
96. The function of this flag is to put all the resulting events into a queue , and so on after the release, slowly to handle the event.
98. because processing times can be time-consuming, the process takes a long time to seize the lock without first casting the lock .
100. causes other processes to fail to acquire locks, so that the efficiency of the accept is low.
102. */
104. Flags |= ngx_post_events;
108. } Else {
110. /*
112. the process of not getting the proceeds, of course, does not require the NGX_POST_EVENTS flag.
114. but you need to set the delay for how long, then to scramble for the lock.
116. */
118. if (Timer = = Ngx_timer_infinite
120. || Timer > Ngx_accept_mutex_delay)
122. {
124. timer = Ngx_accept_mutex_delay;
126. }
128. }
130. }
132. }
136. Delta = ngx_current_msec;
140. / * Next, Epoll to start the wait event,
142. the specific implementation of ngx_process_events is the ngx_epoll_process_events function corresponding to the Epoll module.
144. This will be explained in detail later.
146. */
148. (void) ngx_process_events (cycle, timer, flags);
150. //Statistics The time-consuming of this wait event
152. Delta = Ngx_current_msec-delta;
156. NGX_LOG_DEBUG1 (ngx_log_debug_event, Cycle->log, 0,
158. "Timer Delta:%M" , Delta);
162. /*
164. Ngx_posted_accept_events is an event queue that holds epoll from the listener interface wait to the accept event.
166. once the ngx_post_events flag mentioned above is used, all of the accept events are staged to this queue
168. */
170. if (ngx_posted_accept_events) {
172. Ngx_event_process_posted (cycle, &ngx_posted_accept_events);
174. }
176. //After all the accept events have been processed, if the lock is held, it will be released.
178. if (Ngx_accept_mutex_held) {
180. Ngx_shmtx_unlock (&ngx_accept_mutex);
182. }
186. /*
188. The delta is time-consuming and time-consuming, with milliseconds to check the timer at all times ,
190. If timeout removes the expired timer from time Rbtree, the handler function that invokes the corresponding event is processed
192. */
194. if (Delta) {
196. Ngx_event_expire_timers ();
198. }
202. NGX_LOG_DEBUG1 (ngx_log_debug_event, Cycle->log, 0,
204. "posted Events%p" , ngx_posted_events);
208. /*
210. Handle Common events (read and write events obtained on the connection),
212. because each event has its own handler method,
214. */
216. if (ngx_posted_events) {
218. if (ngx_threaded) {
220. Ngx_wakeup_worker_thread (cycle);
224. } Else {
226. Ngx_event_process_posted (cycle, &ngx_posted_events);
228. }
230. }
232. }

Previously said that the accept event, in fact, he is the listener socket interface on whether there is a new event, the following introduction of the next Accept time handler method:

Ngx_event_accept:

[CPP] View plaincopyprint?

2. Src/event/ngx_event_accept.c
6. void
8. Ngx_event_accept (ngx_event_t *ev)
10. {
12. Socklen_t Socklen;
14. ngx_err_t err;
16. ngx_log_t *log;
18. ngx_socket_t s;
20. ngx_event_t *rev, *wev;
22. ngx_listening_t *ls;
24. Ngx_connection_t *c, *LC;
26. ngx_event_conf_t *ECF;
28. U_char Sa[ngx_sockaddrlen];
32. //Omit part of the code
36. LC = ev->data;
38. ls = lc->listening;
40. Ev->ready = 0;
44. Ngx_log_debug2 (ngx_log_debug_event, Ev->log, 0,
46. "Accept on%V, ready:%d" , &ls->addr_text, ev->available);
50. Do {
52. Socklen = Ngx_sockaddrlen;
54. //accept a new connection
56. s = Accept (LC->FD, (struct sockaddr *) SA, &socklen);
58. //Omit part of the code
62. /*
64. after the accept to a new connection, the value of the ngx_accept_disabled is recalculated,
66. It is mainly used to do load balancing, previously mentioned.
70. Here we can see his just the way
72. "one-eighth of total connections-number of remaining connections"
74. Total connections are the maximum number of connections per process set, which can be specified in the configuration file.
78. so after each process to 7/8 of the total number of connections, ngx_accept_disabled is more than 0, the connection is overloaded
82. */
86. ngx_accept_disabled = NGX_CYCLE->CONNECTION_N/8
88. -ngx_cycle->free_connection_n;
92. //Get a connection
94. c = ngx_get_connection (S, ev->log);
98. //Create a memory pool for the new link
100. //When the connection is closed, the pool is released
104. C->pool = Ngx_create_pool (ls->pool_size, Ev->log);
106. if (C->pool = = NULL) {
108. Ngx_close_accepted_connection (c);
110. return ;
112. }
116. C->SOCKADDR = Ngx_palloc (C->pool, Socklen);
118. if (c->sockaddr = = NULL) {
120. Ngx_close_accepted_connection (c);
122. return ;
124. }
128. ngx_memcpy (c->sockaddr, SA, Socklen);
132. Log = Ngx_palloc (C->pool, sizeof(ngx_log_t));
134. if (log = = NULL) {
136. Ngx_close_accepted_connection (c);
138. return ;
140. }
144. / * Set a blocking mode for AIO and non-blocking mode for others * /
148. if (ngx_inherited_nonblocking) {
150. if (Ngx_event_flags & ngx_use_aio_event) {
152. if (ngx_blocking (s) = =-1) {
154. Ngx_log_error (Ngx_log_alert, Ev->log, Ngx_socket_errno,
156. Ngx_blocking_n "failed");
158. Ngx_close_accepted_connection (c);
160. return ;
162. }
164. }
168. } Else {
170. //We use the Epoll model, here we set the connection as nonblocking
172. if (!( Ngx_event_flags & (ngx_use_aio_event| Ngx_use_rtsig_event )) {
174. if (ngx_nonblocking (s) = =-1) {
176. Ngx_log_error (Ngx_log_alert, Ev->log, Ngx_socket_errno,
178. Ngx_nonblocking_n "failed");
180. Ngx_close_accepted_connection (c);
182. return ;
184. }
186. }
188. }
192. *log = ls->log;
194. //Initialize a new connection
196. C->RECV = NGX_RECV;
198. C->send = Ngx_send;
200. C->recv_chain = Ngx_recv_chain;
202. C->send_chain = Ngx_send_chain;
206. C->log = log;
208. C->pool->log = log;
212. C->socklen = Socklen;
214. c->listening = ls;
216. C->LOCAL_SOCKADDR = ls->sockaddr;
220. c->unexpected_eof = 1;
224. #if (Ngx_have_unix_domain)
226. if (c->sockaddr->sa_family = = Af_unix) {
228. C->tcp_nopush = ngx_tcp_nopush_disabled;
230. C->tcp_nodelay = ngx_tcp_nodelay_disabled;
232. #if (Ngx_solaris)
234. /* Solaris ' s Sendfilev () supports Af_nca, af_inet, and Af_inet6 */
236. C->sendfile = 0;
238. #endif
240. }
242. #endif
246. Rev = c->read;
248. Wev = c->write;
252. Wev->ready = 1;
256. if (Ngx_event_flags & (ngx_use_aio_event| ngx_use_rtsig_event)) {
258. / * Rtsig, AIO, IOCP * /
260. Rev->ready = 1;
262. }
266. if (ev->deferred_accept) {
268. Rev->ready = 1;
270. #if (ngx_have_kqueue)
272. rev->available = 1;
274. #endif
276. }
280. Rev->log = log;
282. Wev->log = log;
286. /*
288. * TODO:MT:-Ngx_atomic_fetch_add ()
290. * or protection by critical sections or light mutexes
292. *
294. * TODO:MP:-Allocated in a shared memory
296. *-Ngx_atomic_fetch_add ()
298. * or protection by critical sections or light mutexes
300. */
304. C->number = Ngx_atomic_fetch_add (Ngx_connection_counter, 1);
308. if (Ngx_add_conn && (ngx_event_flags & ngx_use_epoll_event) = = 0) {
310. if (Ngx_add_conn (c) = = Ngx_error) {
312. Ngx_close_accepted_connection (c);
314. return ;
316. }
318. }
322. Log->data = NULL;
324. Log->handler = NULL;
328. /*
330. Here Listen handler is important, it will complete the final initialization of the new connection,
332. at the same time, the new connection to the accept is put into epoll, and the function hanging on this handler,
334. is ngx_http_init_connection in the following HTTP module in detail
336. */
338. Ls->handler (c);
342. if (Ngx_event_flags & ngx_use_kqueue_event) {
344. ev->available--;
346. }
350. } while (ev->available);
352. }

So is the handler method of the Accpt event. Then is the read-write event of each connection handler method, this part will directly introduce us to the HTTP module, we are not urgent, but also learn the Nginx Classic module epoll.

The above describes the Nginx source learning notes (21)--event module Two--event-driven core ngx_process_events_and_timers, including the content of the queue, I hope to be interested in PHP tutorial friends helpful.

