nginx source code study notes (21) - event module 2 - event-driven core ngx_process_events_and

First of all, let’s continue to recall that there is an uninvolved content ngx_process_events_and_timers in the previous sub-thread execution operation. Today we will study this function.

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

First, let’s take a look at some screenshots of Section 19:

nginx 源码学习笔记（二十一）—— event 模块二 ——事件驱动核心ngx_process_events_and_timers

Today we mainly explain the event-driven function, the red part in the picture:

[cpp] view plaincopyprint?

src/event/ngx_event.c
void
ngx_process_events_and_timers(ngx _cycle_t *cycle)
{
ngx_uint_t flags;
ngx_msec_t timer, delta;
(ngx_timer_resolution) time r = NGX_TIMER_INFINITE; flags = 0;
} else
{
timer = ngx_event_find_timer(); flags = NGX_UPDATE_TIME;
}
/*
The ngx_use_accept_mutex variable represents whether to use accept The mutex
is used by default and can be turned off through the accept_mutex off; command; */
ngx_accept_disabled variable is calculated in the ngx_event_accept function.
If ngx_accept_disabled is greater than 0, it means that the process accepts too many links, Therefore, it gives up an opportunity to compete for the accept mutex and reduces itself by one.
Then, continue to process events on existing connections.
nginx takes advantage of this to implement basic load balancing of inherited connections.
ngx_accept_disabled--; /*
Try to lock Accept Mutex. Only by successfully obtaining the lock can the Listen put word in EPOLL.
Therefore, this ensures that only one process has the listening socket, so when all processes are blocked in epoll_wait,
will not cause a group panic.
If the process acquires the lock, a NGX_POST_EVENTS flag will be added.
The function of this flag is to put all generated events into a queue, and then process the events slowly after they are released. Because the processing time may be time -consuming, if the lock is not applied first before processing, the process will occupy the lock for a long time. The efficiency is low.
else{
But you need to set the delay time before fighting for the lock.
*/
(timer == ngx_timer_infinite
|| timer & gt; ngx_accept_mutex_dlay) {
timer = ngx_acceth_mutex_delay;
/*Next, epoll will start the wait event ,
The specific implementation of ngx_process_events corresponds to the ngx_epoll_process_events function in the epoll module
Will be explained in detail here later
*/
( void
) ngx_process_events(cycle, timer, flags);
delta = ngx_current_msec-delta;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
ngx_posted_accept_events is An event queue
After the NGX_POST_EVENTS flag mentioned above is used, all accept events will be temporarily stored in this queue
*/
(ngx_posted_accept_events ) { ngx_event_process_posted(cycle, &ngx_posted_accept_events);
}

if (ngx_accept_mutex_held) {
ngx_shmtx_unlock(&ngx_accept_mutex);
}
/*
delta is before For statistical time-consuming, if there is millisecond-level time-consuming, check the timers of all times.
If it is timeout, delete the expired timer from the time rbtree, and call the handler function of the corresponding event to process
*/
if (delta) {
ngx_event_expire_timers();
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle-> ;log, 0,
/*
Processing ordinary events (read and write data obtained on the connection event),
Because each event has its own handler method,
*/
if
(ngx_posted_events) {
ngx_wakeup_worker_thread(cycle); : }
}
I have talked about the accept event before. In fact, it is to monitor whether there are new events on the socket. Here is 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. //省略部分代码
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一个新的连接
28. s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
29. //省略部分代码
31. /*
32. accept到一个新的连接后，就重新计算ngx_accept_disabled的值，
33. 它主要是用来做负载均衡，之前有提过。
35. 这里，我们可以看到他的就只方式
36. “总连接数的八分之一 - 剩余的连接数“
37. 总连接指每个进程设定的最大连接数，这个数字可以再配置文件中指定。After the 7/8 of the total number of connections to the total number of connections, the NGX_ACCEPT_DISABLED is greater than zero, and the connection is overloaded
39. */
41. ngx_accept_disabled = ngx_cycle->connection_n / 8
45. //Only released when the connection is closed pool
47. if (c->pool == NULL ) {
49. );
50. ngx_memcpy(c->sockaddr, sa, socklen);
51. log = ngx_palloc(c->pool, sizeof
52. (ngx_log_t));
53. if (log == null) { ngx_close_accepted_connection (c);
54. Roturn
55. ; }
57. /* set a blocking mode for aio and non-blocking mode for others */
59. if (ngx_inherited_nonblocking) {
60. if (ngx_event_flags & NGX_USE_AIO_EVENT) {
61. if (ngx_blocking(s) == -1) {
62. ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
63. ngx_blocking_n " failed");
64. ngx_close_accepted_connection(c);
65. return;
66. }
67. }
69. } else {
70. //我们使用epoll模型，这里我们设置连接为nonblocking
71. if (!(ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT))) {
72. if (ngx_nonblocking(s) == -1) {
73. ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
74. ngx_nonblocking_n " failed");
75. ngx_close_accepted_connection(c);
76. return;
77. }
78. }
79. }
81. *log = ls->log;
82. //初始化新的连接
83. c->recv = ngx_recv;
84. c->send = ngx_send;
85. c->recv_chain = ngx_recv_chain;
86. c->send_chain = ngx_send_chain;
88. c->log = log;
89. c->pool->log = log;
91. c->socklen = socklen;
92. c->listening = ls;
93. c->local_sockaddr = ls->sockaddr;
95. c->unexpected_eof = 1;
97. #if (NGX_HAVE_UNIX_DOMAIN)
98. if (c->sockaddr->sa_family == AF_UNIX) {
99. c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
100. c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;
101. #if (NGX_SOLARIS)
102. /* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */
103. c->sendfile = 0;
104. #endif
105. }
106. #endif
108. rev = c->read;
109. wev = c->write;
111. wev->ready = 1;
113. if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {
114. /* rtsig, aio, iocp */
115. rev->ready = 1;
116. }
118. if (ev->deferred_accept) {
119. rev->ready = 1;
120. #if (NGX_HAVE_KQUEUE)
121. rev->available = 1;
122. #endif
123. }
125. rev->log = log;
126. wev->log = log;
128. /*
129. * TODO: MT: - ngx_atomic_fetch_add()
130. * or protection by critical section or light mutex
131. *
132. * TODO: MP: - allocated in a shared memory
133. * - ngx_atomic_fetch_add()
134. * or protection by critical section or light mutex
135. */
137. c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
139. if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
140. if (ngx_add_conn(c) == NGX_ERROR) {
141. ngx_close_accepted_connection(c);
142. return;
143. }
144. }
146. log->data = NULL;
147. log->handler = NULL;
149. /*
150. 这里listen handler很重要，它将完成新连接的最后初始化工作，
151. 同时将accept到的新的连接放入epoll中；挂在这个handler上的函数，
152. 就是ngx_http_init_connection 在之后http模块中在详细介绍
153. */
154. ls->handler(c);
156. if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
157. ev->available--;
158. }
160. } while (ev->available);
161. }
accpt事件的handler方法也就是如此了。之后就是每个连接的读写事件handler方法，这一部分会直接将我们引入http模块，我们还不急，还要学习下nginx经典模块epoll。

The above introduces the nginx source code study notes (21) - event module 2 - the event-driven core ngx_process_events_and_timers, including queue content. I hope it will be helpful to friends who are interested in PHP tutorials.