Mercurial > hg > nginx-ranges

comparison src/os/unix/ngx_pthread_thread.c @ 0:f0b350454894 NGINX_0_1_0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.1.0 *) The first public version.
author Igor Sysoev <http://sysoev.ru>
date Mon, 04 Oct 2004 00:00:00 +0400
parents
children 46833bd150cb
comparison
equal deleted inserted replaced
-1:000000000000 0:f0b350454894
1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9
10
11 static ngx_uint_t nthreads;
12 static ngx_uint_t max_threads;
13
14
15 static pthread_attr_t thr_attr;
16
17
18 int ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
19 ngx_log_t *log)
20 {
21 int err;
22
23 if (nthreads >= max_threads) {
24 ngx_log_error(NGX_LOG_CRIT, log, 0,
25 "no more than %d threads can be created", max_threads);
26 return NGX_ERROR;
27 }
28
29 err = pthread_create(tid, &thr_attr, func, arg);
30
31 if (err != 0) {
32 ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_create() failed");
33 return err;
34 }
35
36 ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
37 "thread is created: " TID_T_FMT, *tid);
38
39 nthreads++;
40
41 return err;
42 }
43
44
45 ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
46 {
47 int err;
48
49 max_threads = n;
50
51 err = pthread_attr_init(&thr_attr);
52
53 if (err != 0) {
54 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
55 "pthread_attr_init() failed");
56 return NGX_ERROR;
57 }
58
59 err = pthread_attr_setstacksize(&thr_attr, size);
60
61 if (err != 0) {
62 ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
63 "pthread_attr_setstacksize() failed");
64 return NGX_ERROR;
65 }
66
67 ngx_threaded = 1;
68
69 return NGX_OK;
70 }
71
72
73 ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, uint flags)
74 {
75 int err;
76 ngx_mutex_t *m;
77
78 if (!(m = ngx_alloc(sizeof(ngx_mutex_t), log))) {
79 return NULL;
80 }
81
82 m->log = log;
83
84 err = pthread_mutex_init(&m->mutex, NULL);
85
86 if (err != 0) {
87 ngx_log_error(NGX_LOG_ALERT, m->log, err,
88 "pthread_mutex_init() failed");
89 return NULL;
90 }
91
92 return m;
93 }
94
95
96 void ngx_mutex_destroy(ngx_mutex_t *m)
97 {
98 int err;
99
100 err = pthread_mutex_destroy(&m->mutex);
101
102 if (err != 0) {
103 ngx_log_error(NGX_LOG_ALERT, m->log, err,
104 "pthread_mutex_destroy(" PTR_FMT ") failed", m);
105 }
106
107 ngx_free(m);
108 }
109
110
111 ngx_int_t ngx_mutex_lock(ngx_mutex_t *m)
112 {
113 int err;
114
115 if (!ngx_threaded) {
116 return NGX_OK;
117 }
118
119 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "lock mutex " PTR_FMT, m);
120
121 err = pthread_mutex_lock(&m->mutex);
122
123 if (err != 0) {
124 ngx_log_error(NGX_LOG_ALERT, m->log, err,
125 "pthread_mutex_lock(" PTR_FMT ") failed", m);
126 return NGX_ERROR;
127 }
128
129 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
130 "mutex " PTR_FMT " is locked", m);
131
132 return NGX_OK;
133 }
134
135
136 ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m)
137 {
138 int err;
139
140 if (!ngx_threaded) {
141 return NGX_OK;
142 }
143
144 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
145 "try lock mutex " PTR_FMT, m);
146
147 err = pthread_mutex_trylock(&m->mutex);
148
149 if (err == NGX_EBUSY) {
150 return NGX_AGAIN;
151 }
152
153 if (err != 0) {
154 ngx_log_error(NGX_LOG_ALERT, m->log, err,
155 "pthread_mutex_trylock(" PTR_FMT ") failed", m);
156 return NGX_ERROR;
157 }
158
159 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
160 "mutex " PTR_FMT " is locked", m);
161
162 return NGX_OK;
163 }
164
165
166 ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
167 {
168 int err;
169
170 if (!ngx_threaded) {
171 return NGX_OK;
172 }
173
174 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "unlock mutex " PTR_FMT, m);
175
176 err = pthread_mutex_unlock(&m->mutex);
177
178 if (err != 0) {
179 ngx_log_error(NGX_LOG_ALERT, m->log, err,
180 "pthread_mutex_unlock(" PTR_FMT ") failed", m);
181 return NGX_ERROR;
182 }
183
184 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
185 "mutex " PTR_FMT " is unlocked", m);
186
187 return NGX_OK;
188 }
189
190
191 ngx_cond_t *ngx_cond_init(ngx_log_t *log)
192 {
193 int err;
194 ngx_cond_t *cv;
195
196 if (!(cv = ngx_alloc(sizeof(ngx_cond_t), log))) {
197 return NULL;
198 }
199
200 cv->log = log;
201
202 err = pthread_cond_init(&cv->cond, NULL);
203
204 if (err != 0) {
205 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
206 "pthread_cond_init() failed");
207 return NULL;
208 }
209
210 return cv;
211 }
212
213
214 void ngx_cond_destroy(ngx_cond_t *cv)
215 {
216 int err;
217
218 err = pthread_cond_destroy(&cv->cond);
219
220 if (err != 0) {
221 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
222 "pthread_cond_destroy(" PTR_FMT ") failed", cv);
223 }
224
225 ngx_free(cv);
226 }
227
228
229 ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
230 {
231 int err;
232
233 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
234 "cv " PTR_FMT " wait", cv);
235
236 err = pthread_cond_wait(&cv->cond, &m->mutex);
237
238 if (err != 0) {
239 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
240 "pthread_cond_wait(" PTR_FMT ") failed", cv);
241 return NGX_ERROR;
242 }
243
244 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
245 "cv " PTR_FMT " is waked up", cv);
246
247 ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
248 "mutex " PTR_FMT " is locked", m);
249
250 return NGX_OK;
251 }
252
253
254 ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
255 {
256 int err;
257
258 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
259 "cv " PTR_FMT " to signal", cv);
260
261 err = pthread_cond_signal(&cv->cond);
262
263 if (err != 0) {
264 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
265 "pthread_cond_signal(" PTR_FMT ") failed", cv);
266 return NGX_ERROR;
267 }
268
269 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
270 "cv " PTR_FMT " is signaled", cv);
271
272 return NGX_OK;
273 }