Mercurial > hg > nginx

comparison src/os/unix/ngx_pthread_thread.c @ 376:d0451e402e27

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.7-2004-07-05-10:55:54 import
author Igor Sysoev <igor@sysoev.ru>
date Mon, 05 Jul 2004 06:55:54 +0000
parents
children 73688d5d7fc3
comparison
equal deleted inserted replaced
375:744ccb59062d 376:d0451e402e27
1
2 /*
3 * Copyright (C) 2002-2004 Igor Sysoev, http://sysoev.ru/en/
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_CORE, 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_CORE, 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_CORE, m->log, 0, "try lock mutex " PTR_FMT, m);
145
146 err = pthread_mutex_trylock(&m->mutex);
147
148 if (err != 0) {
149 ngx_log_error(NGX_LOG_ALERT, m->log, err,
150 "pthread_mutex_trylock(" PTR_FMT ") failed", m);
151 return NGX_ERROR;
152 }
153
154 ngx_log_debug1(NGX_LOG_DEBUG_CORE, m->log, 0,
155 "mutex " PTR_FMT " is locked", m);
156
157 return NGX_OK;
158 }
159
160
161 ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
162 {
163 int err;
164
165 if (!ngx_threaded) {
166 return NGX_OK;
167 }
168
169 ngx_log_debug1(NGX_LOG_DEBUG_CORE, m->log, 0, "unlock mutex " PTR_FMT, m);
170
171 err = pthread_mutex_unlock(&m->mutex);
172
173 if (err != 0) {
174 ngx_log_error(NGX_LOG_ALERT, m->log, err,
175 "pthread_mutex_unlock(" PTR_FMT ") failed", m);
176 return NGX_ERROR;
177 }
178
179 ngx_log_debug1(NGX_LOG_DEBUG_CORE, m->log, 0,
180 "mutex " PTR_FMT " is unlocked", m);
181
182 return NGX_OK;
183 }
184
185
186 ngx_cond_t *ngx_cond_init(ngx_log_t *log)
187 {
188 int err;
189 ngx_cond_t *cv;
190
191 if (!(cv = ngx_alloc(sizeof(ngx_cond_t), log))) {
192 return NULL;
193 }
194
195 cv->log = log;
196
197 err = pthread_cond_init(&cv->cond, NULL);
198
199 if (err != 0) {
200 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
201 "pthread_cond_init() failed");
202 return NULL;
203 }
204
205 return cv;
206 }
207
208
209 void ngx_cond_destroy(ngx_cond_t *cv)
210 {
211 int err;
212
213 err = pthread_cond_destroy(&cv->cond);
214
215 if (err != 0) {
216 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
217 "pthread_cond_destroy(" PTR_FMT ") failed", cv);
218 }
219
220 ngx_free(cv);
221 }
222
223
224 ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
225 {
226 int err;
227
228 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
229 "cv " PTR_FMT " wait", cv);
230
231 err = pthread_cond_wait(&cv->cond, &m->mutex);
232
233 if (err != 0) {
234 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
235 "pthread_cond_wait(" PTR_FMT ") failed", cv);
236 return NGX_ERROR;
237 }
238
239 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
240 "cv " PTR_FMT " is waked up", cv);
241
242 ngx_log_debug1(NGX_LOG_DEBUG_CORE, m->log, 0,
243 "mutex " PTR_FMT " is locked", m);
244
245 return NGX_OK;
246 }
247
248
249 ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
250 {
251 int err;
252
253 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
254 "cv " PTR_FMT " to signal", cv);
255
256 err = pthread_cond_signal(&cv->cond);
257
258 if (err != 0) {
259 ngx_log_error(NGX_LOG_ALERT, cv->log, err,
260 "pthread_cond_signal(" PTR_FMT ") failed", cv);
261 return NGX_ERROR;
262 }
263
264 ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
265 "cv " PTR_FMT " is signaled", cv);
266
267 return NGX_OK;
268 }