Nginx source code learning notes (21) -- event Module 2 -- event-driven core ngx_process_events_and_timers

: This article mainly introduces the nginx source code learning notes (21) -- event Module 2 -- the event-driven core ngx_process_events_and_timers. if you are interested in the PHP Tutorial, refer to it. First, let's continue to recall that there was a non-involved ngx_process_events_and_timers in the previous sub-thread execution operation. today we will study this function.

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

Let's take a look at the part in section 19th:

Today we will mainly explain the event-driven functions, in the red part of the figure:

[Cpp] view plaincopyprint?

1. Src/event/ngx_event.c
3. Void
4. Ngx_process_events_and_timers (ngx_cycle_t * cycle)
5. {
6. Ngx_uint_t flags;
7. Ngx_msec_t timer, delta;
9. If (ngx_timer_resolution ){
10. Timer = NGX_TIMER_INFINITE;
11. Flags = 0;
13. } Else {
14. Timer = ngx_event_find_timer ();
15. Flags = NGX_UPDATE_TIME;
16. }
18. /*
19. The ngx_use_accept_mutex variable indicates whether to use the accept mutex.
20. It is used by default and can be disabled through the accept_mutex off Command;
21. The role of accept mutex is to avoid group alarms and achieve load balancing.
22. */
23. If (ngx_use_accept_mutex ){
25. /*
26. The ngx_accept_disabled variable is calculated in the ngx_event_accept function.
27. If ngx_accept_disabled is greater than 0, this indicates that the process has received too many connections,
28. Therefore, I gave up a chance to compete for accept mutex and reduced myself by one.
29. Then, continue to process the events on the existing connection.
30. Nginx uses this to achieve load balancing that inherits the basic connection.
31. */
32. If (ngx_accept_disabled> 0 ){
33. Ngx_accept_disabled --;
35. } Else {
36. /*
37. Try to lock accept mutex. only the process that successfully acquires the lock will put the listen socket in epoll.
38. Therefore, this ensures that only one process has a listening set interface, so when all processes are blocked in epoll_wait,
39. It is not surprising.
40. */
41. If (ngx_trylock_accept_mutex (cycle) = NGX_ERROR ){
42. Return;
43. }
45. If (ngx_accept_mutex_held ){
46. /*
47. If the process gets the lock, an NGX_POST_EVENTS flag is added.
48. This flag is used to put all generated events into oneQueueAfter being released, you are processing the event slowly.
49. Because the processing time may be very time-consuming. if the lock is not applied before processing, the process occupies the lock for a long time,
50. As a result, other processes cannot obtain the lock, which reduces the accept efficiency.
51. */
52. Flags | = NGX_POST_EVENTS;
54. } Else {
55. /*
56. No process is obtained. of course, the NGX_POST_EVENTS flag is not required.
57. However, you need to set the delay time to compete for the lock.
58. */
59. If (timer = NGX_TIMER_INFINITE
60. | Timer> ngx_accept_mutex_delay)
61. {
62. Timer = ngx_accept_mutex_delay;
63. }
64. }
65. }
66. }
68. Delta = ngx_current_msec;
70. /* Next, epoll starts wait events,
71. The specific implementation of ngx_process_events corresponds to the ngx_epoll_process_events function in the epoll module.
72. I will explain it in detail later.
73. */
74. (Void) ngx_process_events (cycle, timer, flags );
75. // Count the time consumed by this wait event
76. Delta = ngx_current_msec-delta;
78. Ngx_log_debug1 (NGX_LOG_DEBUG_EVENT, cycle-> log, 0,
79. "Timer delta: % M", delta );
81. /*
82. Ngx_posted_accept_events is an event.QueueTemporarily store the accept event from the listening set interface wait to epoll.
83. After the NGX_POST_EVENTS mark is used, all the accept events will be saved to thisQueue
84. */
85. If (ngx_posted_accept_events ){
86. Ngx_event_process_posted (cycle, & ngx_posted_accept_events );
87. }
88. // After all the accept events are processed, if the lock is held, it will be released.
89. If (ngx_accept_mutex_held ){
90. Ngx_shmtx_unlock (& ngx_accept_mutex );
91. }
93. /*
94. Delta is the time consumed in previous statistics. if the time consumed in milliseconds exists, it checks all the time timer,
95. If timeout is used, the expired timer is deleted from the time rbtree, and the handler function of the corresponding event is called for processing.
96. */
97. If (delta ){
98. Ngx_event_expire_timers ();
99. }
101. Ngx_log_debug1 (NGX_LOG_DEBUG_EVENT, cycle-> log, 0,
102. "Posted events % p", ngx_posted_events );
104. /*
105. Process common events (read/write events obtained on the connection ),
106. Because each event has its own handler method,
107. */
108. If (ngx_posted_events ){
109. If (ngx_threaded ){
110. Ngx_wakeup_worker_thread (cycle );
112. } Else {
113. Ngx_event_process_posted (cycle, & ngx_posted_events );
114. }
115. }
116. }

As mentioned before, the accept event is actually a new event on the listening set interface. The following describes the handler method of the accept time:

Ngx_event_accept:

[Cpp] view plaincopyprint?

1. Src/event/ngx_event_accept.c
3. Void
4. Ngx_event_accept (ngx_event_t * ev)
5. {
6. Socklen_t socklen;
7. Ngx_err_t err;
8. Ngx_log_t * log;
9. Ngx_socket_t s;
10. Ngx_event_t * rev, * wev;
11. Ngx_listening_t * ls;
12. Ngx_connection_t * c, * lc;
13. Ngx_event_conf_t * ecf;
14. U_char sa [NGX_SOCKADDRLEN];
16. // Omit part of the code
18. Lc = ev-> data;
19. Ls = lc-> listening;
20. Ev-> ready = 0;
22. Ngx_log_debug2 (NGX_LOG_DEBUG_EVENT, ev-> log, 0,
23. "Accept on % V, ready: % d", & ls-> addr_text, ev-> available );
25. Do {
26. Socklen = NGX_SOCKADDRLEN;
27. // Accept a new connection
28. S = accept (lc-> fd, (struct sockaddr *) sa, & socklen );
29. // Omit part of the code
31. /*
32. After the accept is connected to a new connection, it recalculates the value of ngx_accept_disabled,
33. It is mainly used for load balancing and has been mentioned before.
35. Here, we can see that his method is only
36. "1/8 of total connections-remaining connections"
37. Total connections are the maximum number of connections set by each process. this number can be specified in the configuration file.
39. Therefore, after each process reaches 7/8 of the total number of connections, ngx_accept_disabled is greater than zero, and the connection is overloaded.
41. */
43. Ngx_accept_disabled = ngx_cycle-> connection_n/8
44. -Ngx_cycle-> free_connection_n;
46. // Obtain a connection
47. C = ngx_get_connection (s, ev-> log );
49. // Create a memory pool for the new link
50. // The pool is released only when the connection is closed.
52. C-> pool = ngx_create_pool (ls-> pool_size, ev-> log );
53. If (c-> pool = NULL ){
54. Ngx_close_accepted_connection (c );
55. Return;
56. }
58. C-> sockaddr = ngx_palloc (c-> pool, socklen );
59. If (c-> sockaddr = NULL ){
60. Ngx_close_accepted_connection (c );
61. Return;
62. }
64. Ngx_memcpy (c-> sockaddr, sa, socklen );
66. Log = ngx_palloc (c-> pool, sizeof (ngx_log_t ));
67. If (log = NULL ){
68. Ngx_close_accepted_connection (c );
69. Return;
70. }
72. /* Set a blocking mode for aio and non-blocking mode for others */
74. If (ngx_inherited_nonblocking ){
75. If (ngx_event_flags & NGX_USE_AIO_EVENT ){
76. If (ngx_blocking (s) =-1 ){
77. Ngx_log_error (NGX_LOG_ALERT, ev-> log, ngx_socket_errno,
78. Ngx_blocking_n "failed ");
79. Ngx_close_accepted_connection (c );
80. Return;
81. }
82. }
84. } Else {
85. // We use the epoll model. Here we set the connection to nonblocking.
86. If (! (Ngx_event_flags & (NGX_USE_AIO_EVENT | NGX_USE_RTSIG_EVENT ))){
87. If (ngx_nonblocking (s) =-1 ){
88. Ngx_log_error (NGX_LOG_ALERT, ev-> log, ngx_socket_errno,
89. Ngx_nonblocking_n "failed ");
90. Ngx_close_accepted_connection (c );
91. Return;
92. }
93. }
94. }
96. * Log = ls-> log;
97. // Initialize a new connection
98. C-> recv = ngx_recv;
99. C-> send = ngx_send;
100. C-> recv_chain = ngx_recv_chain;
101. C-> send_chain = ngx_send_chain;
103. C-> log = log;
104. C-> pool-> log = log;
106. C-> socklen = socklen;
107. C-> listening = ls;
108. C-> local_sockaddr = ls-> sockaddr;
110. C-> unexpected_eof = 1;
112. # If (NGX_HAVE_UNIX_DOMAIN)
113. If (c-> sockaddr-> sa_family = AF_UNIX ){
114. C-> tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
115. C-> tcp_nodelay = NGX_TCP_NODELAY_DISABLED;
116. # If (NGX_SOLARIS)
117. /* Solaris's sendfilev () supports AF_NCA, AF_INET, and AF_INET6 */
118. C-> sendfile = 0;
119. # Endif
120. }
121. # Endif
123. Rev = c-> read;
124. Wev = c-> write;
126. Wev-> ready = 1;
128. If (ngx_event_flags & (NGX_USE_AIO_EVENT | NGX_USE_RTSIG_EVENT )){
129. /* Rtsig, aio, iocp */
130. Rev-> ready = 1;
131. }
133. If (ev-> deferred_accept ){
134. Rev-> ready = 1;
135. # If (NGX_HAVE_KQUEUE)
136. Rev-> available = 1;
137. # Endif
138. }
140. Rev-> log = log;
141. Wev-> log = log;
143. /*
144. * TODO: MT:-ngx_atomic_fetch_add ()
145. * Or protection by critical section or light mutex
146. *
147. * TODO: MP:-allocated in a shared memory
148. *-Ngx_atomic_fetch_add ()
149. * Or protection by critical section or light mutex
150. */
152. C-> number = ngx_atomic_fetch_add (ngx_connection_counter, 1 );
154. If (ngx_add_conn & (ngx_event_flags & NGX_USE_EPOLL_EVENT) = 0 ){
155. If (ngx_add_conn (c) = NGX_ERROR ){
156. Ngx_close_accepted_connection (c );
157. Return;
158. }
159. }
161. Log-> data = NULL;
162. Log-> handler = NULL;
164. /*
165. Here, listen handler is very important. it will complete the final initialization of the new connection,
166. At the same time, put the new connection from the accept into epoll; the function that hangs on the handler,
167. Ngx_http_init_connection is described in detail in the subsequent http module.
168. */
169. Ls-> handler (c );
171. If (ngx_event_flags & NGX_USE_KQUEUE_EVENT ){
172. Ev-> available --;
173. }
175. } While (ev-> available );
176. }

The handler method of the accpt event is the same. Then there is the handler method for each connection read/write event. This part will directly introduce us to the http Module. we are not in a hurry, but also need to learn epoll of the nginx classic module.

The above introduces the nginx source code learning notes (21) -- event Module 2 -- the event-driven core ngx_process_events_and_timers, including the Queue Content, hope to be helpful to friends who are interested in PHP tutorials.