This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
make die/warn and other diagnostics go to wherever STDERR happens
[perl5.git] / thread.h
1 #ifdef USE_THREADS
2
3 #ifdef WIN32
4 #  include <win32thread.h>
5 #else
6 #  ifdef OLD_PTHREADS_API /* Here be dragons. */
7 #    define DETACH(t)                           \
8     STMT_START {                                \
9         if (pthread_detach(&(t)->self)) {       \
10             MUTEX_UNLOCK(&(t)->mutex);          \
11             Perl_croak(aTHX_ "panic: DETACH");          \
12         }                                       \
13     } STMT_END
14 #    define THR getTHR()
15 struct perl_thread *getTHR (void);
16 #    define PTHREAD_GETSPECIFIC_INT
17 #    ifdef DJGPP
18 #      define pthread_addr_t any_t
19 #      define NEED_PTHREAD_INIT
20 #      define PTHREAD_CREATE_JOINABLE (1)
21 #    endif
22 #    ifdef __OPEN_VM
23 #      define pthread_addr_t void *
24 #    endif
25 #    ifdef VMS
26 #      define pthread_attr_init(a) pthread_attr_create(a)
27 #      define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_setdetach_np(a,s)
28 #      define PTHREAD_CREATE(t,a,s,d) pthread_create(t,a,s,d)
29 #      define pthread_key_create(k,d) pthread_keycreate(k,(pthread_destructor_t)(d))
30 #      define pthread_mutexattr_init(a) pthread_mutexattr_create(a)
31 #      define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t)
32 #    endif
33 #    if defined(DJGPP) || defined(__OPEN_VM)
34 #      define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,&(s))
35 #      define YIELD pthread_yield(NULL)
36 #    endif
37 #  endif
38 #    define pthread_mutexattr_default NULL
39 #    define pthread_condattr_default  NULL
40 #endif
41
42 #ifndef PTHREAD_CREATE
43 /* You are not supposed to pass NULL as the 2nd arg of PTHREAD_CREATE(). */
44 #  define PTHREAD_CREATE(t,a,s,d) pthread_create(t,&(a),s,d)
45 #endif
46
47 #ifndef PTHREAD_ATTR_SETDETACHSTATE
48 #  define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,s)
49 #endif
50
51 #ifndef PTHREAD_CREATE_JOINABLE
52 #  ifdef OLD_PTHREAD_CREATE_JOINABLE
53 #    define PTHREAD_CREATE_JOINABLE OLD_PTHREAD_CREATE_JOINABLE
54 #  else
55 #    define PTHREAD_CREATE_JOINABLE 0 /* Panic?  No, guess. */
56 #  endif
57 #endif
58
59 #ifdef I_MACH_CTHREADS
60
61 /* cthreads interface */
62
63 /* #include <mach/cthreads.h> is in perl.h #ifdef I_MACH_CTHREADS */
64
65 #define MUTEX_INIT(m)                                   \
66         STMT_START {                                    \
67                 *m = mutex_alloc();                     \
68                 if (*m) {                               \
69                         mutex_init(*m);                 \
70                 } else {                                \
71                         Perl_croak(aTHX_ "panic: MUTEX_INIT");  \
72                 }                                       \
73         } STMT_END
74
75 #define MUTEX_LOCK(m)           mutex_lock(*m)
76 #define MUTEX_UNLOCK(m)         mutex_unlock(*m)
77 #define MUTEX_DESTROY(m)                                \
78         STMT_START {                                    \
79                 mutex_free(*m);                         \
80                 *m = 0;                                 \
81         } STMT_END
82
83 #define COND_INIT(c)                                    \
84         STMT_START {                                    \
85                 *c = condition_alloc();                 \
86                 if (*c) {                               \
87                         condition_init(*c);             \
88                 } else {                                \
89                         Perl_croak(aTHX_ "panic: COND_INIT");   \
90                 }                                       \
91         } STMT_END
92
93 #define COND_SIGNAL(c)          condition_signal(*c)
94 #define COND_BROADCAST(c)       condition_broadcast(*c)
95 #define COND_WAIT(c, m)         condition_wait(*c, *m)
96 #define COND_DESTROY(c)                         \
97         STMT_START {                            \
98                 condition_free(*c);             \
99                 *c = 0;                         \
100         } STMT_END
101
102 #define THREAD_CREATE(thr, f)   (thr->self = cthread_fork(f, thr), 0)
103 #define THREAD_POST_CREATE(thr)
104
105 #define THREAD_RET_TYPE         any_t
106 #define THREAD_RET_CAST(x)      ((any_t) x)
107
108 #define DETACH(t)               cthread_detach(t->self)
109 #define JOIN(t, avp)            (*(avp) = (AV *)cthread_join(t->self))
110
111 #define SET_THR(thr)            cthread_set_data(cthread_self(), thr)
112 #define THR                     cthread_data(cthread_self())
113
114 #define INIT_THREADS            cthread_init()
115 #define YIELD                   cthread_yield()
116 #define ALLOC_THREAD_KEY
117 #define SET_THREAD_SELF(thr)    (thr->self = cthread_self())
118
119 #endif /* I_MACH_CTHREADS */
120
121 #ifndef YIELD
122 #  ifdef SCHED_YIELD
123 #    define YIELD SCHED_YIELD
124 #  else
125 #    ifdef HAS_SCHED_YIELD
126 #      define YIELD sched_yield()
127 #    else
128 #      ifdef HAS_PTHREAD_YIELD
129     /* pthread_yield(NULL) platforms are expected
130      * to have #defined YIELD for themselves. */
131 #        define YIELD pthread_yield()
132 #      endif
133 #    endif
134 #  endif
135 #endif
136
137 #ifdef __hpux
138 #  define MUTEX_INIT_NEEDS_MUTEX_ZEROED
139 #endif
140
141 #ifndef MUTEX_INIT
142 #ifdef MUTEX_INIT_NEEDS_MUTEX_ZEROED
143     /* Temporary workaround, true bug is deeper. --jhi 1999-02-25 */
144 #define MUTEX_INIT(m)                                           \
145     STMT_START {                                                \
146         Zero((m), 1, perl_mutex);                               \
147         if (pthread_mutex_init((m), pthread_mutexattr_default)) \
148             Perl_croak(aTHX_ "panic: MUTEX_INIT");                              \
149     } STMT_END
150 #else
151 #define MUTEX_INIT(m)                                           \
152     STMT_START {                                                \
153         if (pthread_mutex_init((m), pthread_mutexattr_default)) \
154             Perl_croak(aTHX_ "panic: MUTEX_INIT");                              \
155     } STMT_END
156 #endif
157 #define MUTEX_LOCK(m)                           \
158     STMT_START {                                \
159         if (pthread_mutex_lock((m)))            \
160             Perl_croak(aTHX_ "panic: MUTEX_LOCK");              \
161     } STMT_END
162 #define MUTEX_UNLOCK(m)                         \
163     STMT_START {                                \
164         if (pthread_mutex_unlock((m)))          \
165             Perl_croak(aTHX_ "panic: MUTEX_UNLOCK");    \
166     } STMT_END
167 #define MUTEX_LOCK_NOCONTEXT(m)                         \
168     STMT_START {                                        \
169         if (pthread_mutex_lock((m)))                    \
170             Perl_croak_nocontext("panic: MUTEX_LOCK");  \
171     } STMT_END
172 #define MUTEX_UNLOCK_NOCONTEXT(m)                       \
173     STMT_START {                                        \
174         if (pthread_mutex_unlock((m)))                  \
175             Perl_croak_nocontext("panic: MUTEX_UNLOCK");\
176     } STMT_END
177 #define MUTEX_DESTROY(m)                        \
178     STMT_START {                                \
179         if (pthread_mutex_destroy((m)))         \
180             Perl_croak(aTHX_ "panic: MUTEX_DESTROY");   \
181     } STMT_END
182 #endif /* MUTEX_INIT */
183
184 #ifndef COND_INIT
185 #define COND_INIT(c)                                            \
186     STMT_START {                                                \
187         if (pthread_cond_init((c), pthread_condattr_default))   \
188             Perl_croak(aTHX_ "panic: COND_INIT");                               \
189     } STMT_END
190 #define COND_SIGNAL(c)                          \
191     STMT_START {                                \
192         if (pthread_cond_signal((c)))           \
193             Perl_croak(aTHX_ "panic: COND_SIGNAL");     \
194     } STMT_END
195 #define COND_BROADCAST(c)                       \
196     STMT_START {                                \
197         if (pthread_cond_broadcast((c)))        \
198             Perl_croak(aTHX_ "panic: COND_BROADCAST");  \
199     } STMT_END
200 #define COND_WAIT(c, m)                         \
201     STMT_START {                                \
202         if (pthread_cond_wait((c), (m)))        \
203             Perl_croak(aTHX_ "panic: COND_WAIT");               \
204     } STMT_END
205 #define COND_DESTROY(c)                         \
206     STMT_START {                                \
207         if (pthread_cond_destroy((c)))          \
208             Perl_croak(aTHX_ "panic: COND_DESTROY");    \
209     } STMT_END
210 #endif /* COND_INIT */
211
212 /* DETACH(t) must only be called while holding t->mutex */
213 #ifndef DETACH
214 #define DETACH(t)                               \
215     STMT_START {                                \
216         if (pthread_detach((t)->self)) {        \
217             MUTEX_UNLOCK(&(t)->mutex);          \
218             Perl_croak(aTHX_ "panic: DETACH");          \
219         }                                       \
220     } STMT_END
221 #endif /* DETACH */
222
223 #ifndef JOIN
224 #define JOIN(t, avp)                                    \
225     STMT_START {                                        \
226         if (pthread_join((t)->self, (void**)(avp)))     \
227             Perl_croak(aTHX_ "panic: pthread_join");            \
228     } STMT_END
229 #endif /* JOIN */
230
231 #ifndef SET_THR
232 #define SET_THR(t)                                      \
233     STMT_START {                                        \
234         if (pthread_setspecific(PL_thr_key, (void *) (t)))      \
235             Perl_croak(aTHX_ "panic: pthread_setspecific");     \
236     } STMT_END
237 #endif /* SET_THR */
238
239 #ifndef THR
240 #define THR ((struct perl_thread *) pthread_getspecific(PL_thr_key))
241 #endif
242
243 /*
244  * dTHR is performance-critical. Here, we only do the pthread_get_specific
245  * if there may be more than one thread in existence, otherwise we get thr
246  * from thrsv which is cached in the per-interpreter structure.
247  * Systems with very fast pthread_get_specific (which should be all systems
248  * but unfortunately isn't) may wish to simplify to "...*thr = THR".
249  *
250  * The use of PL_threadnum should be safe here.
251  */
252 #ifndef dTHR
253 #  define dTHR \
254     struct perl_thread *thr = PL_threadnum? THR : (struct perl_thread*)SvPVX(PL_thrsv)
255 #endif /* dTHR */
256
257 #ifndef INIT_THREADS
258 #  ifdef NEED_PTHREAD_INIT
259 #    define INIT_THREADS pthread_init()
260 #  else
261 #    define INIT_THREADS NOOP
262 #  endif
263 #endif
264
265 /* Accessor for per-thread SVs */
266 #define THREADSV(i) (thr->threadsvp[i])
267
268 /*
269  * LOCK_SV_MUTEX and UNLOCK_SV_MUTEX are performance-critical. Here, we
270  * try only locking them if there may be more than one thread in existence.
271  * Systems with very fast mutexes (and/or slow conditionals) may wish to
272  * remove the "if (threadnum) ..." test.
273  * XXX do NOT use C<if (PL_threadnum) ...> -- it sets up race conditions!
274  */
275 #define LOCK_SV_MUTEX                           \
276     STMT_START {                                \
277         MUTEX_LOCK(&PL_sv_mutex);               \
278     } STMT_END
279
280 #define UNLOCK_SV_MUTEX                         \
281     STMT_START {                                \
282         MUTEX_UNLOCK(&PL_sv_mutex);             \
283     } STMT_END
284
285 /* Likewise for strtab_mutex */
286 #define LOCK_STRTAB_MUTEX                       \
287     STMT_START {                                \
288         MUTEX_LOCK(&PL_strtab_mutex);           \
289     } STMT_END
290
291 #define UNLOCK_STRTAB_MUTEX                     \
292     STMT_START {                                \
293         MUTEX_UNLOCK(&PL_strtab_mutex);         \
294     } STMT_END
295
296 #ifndef THREAD_RET_TYPE
297 #  define THREAD_RET_TYPE       void *
298 #  define THREAD_RET_CAST(p)    ((void *)(p))
299 #endif /* THREAD_RET */
300
301
302 /* Values and macros for thr->flags */
303 #define THRf_STATE_MASK 7
304 #define THRf_R_JOINABLE 0
305 #define THRf_R_JOINED   1
306 #define THRf_R_DETACHED 2
307 #define THRf_ZOMBIE     3
308 #define THRf_DEAD       4
309
310 #define THRf_DID_DIE    8
311
312 /* ThrSTATE(t) and ThrSETSTATE(t) must only be called while holding t->mutex */
313 #define ThrSTATE(t) ((t)->flags & THRf_STATE_MASK)
314 #define ThrSETSTATE(t, s) STMT_START {          \
315         (t)->flags &= ~THRf_STATE_MASK;         \
316         (t)->flags |= (s);                      \
317         DEBUG_S(PerlIO_printf(Perl_debug_log,   \
318                               "thread %p set to state %d\n", (t), (s))); \
319     } STMT_END
320
321 typedef struct condpair {
322     perl_mutex  mutex;          /* Protects all other fields */
323     perl_cond   owner_cond;     /* For when owner changes at all */
324     perl_cond   cond;           /* For cond_signal and cond_broadcast */
325     Thread      owner;          /* Currently owning thread */
326 } condpair_t;
327
328 #define MgMUTEXP(mg) (&((condpair_t *)(mg->mg_ptr))->mutex)
329 #define MgOWNERCONDP(mg) (&((condpair_t *)(mg->mg_ptr))->owner_cond)
330 #define MgCONDP(mg) (&((condpair_t *)(mg->mg_ptr))->cond)
331 #define MgOWNER(mg) ((condpair_t *)(mg->mg_ptr))->owner
332
333 #else
334 /* USE_THREADS is not defined */
335 #define MUTEX_LOCK(m)
336 #define MUTEX_LOCK_NOCONTEXT(m)
337 #define MUTEX_UNLOCK(m)
338 #define MUTEX_UNLOCK_NOCONTEXT(m)
339 #define MUTEX_INIT(m)
340 #define MUTEX_DESTROY(m)
341 #define COND_INIT(c)
342 #define COND_SIGNAL(c)
343 #define COND_BROADCAST(c)
344 #define COND_WAIT(c, m)
345 #define COND_DESTROY(c)
346 #define LOCK_SV_MUTEX
347 #define UNLOCK_SV_MUTEX
348 #define LOCK_STRTAB_MUTEX
349 #define UNLOCK_STRTAB_MUTEX
350
351 #define THR
352 #define dTHR dNOOP
353 #endif /* USE_THREADS */