blob: dd9c3ad5886f6e64481d492d2c0b3190d2b40821 [file] [log] [blame]
Guido van Rossum34679b71993-01-26 13:33:44 +00001
Guido van Rossum1d5735e1994-08-30 08:27:36 +00002/* Thread package.
3 This is intended to be usable independently from Python.
4 The implementation for system foobar is in a file thread_foobar.h
5 which is included by this file dependent on config settings.
6 Stuff shared by all thread_*.h files is collected here. */
7
Martin v. Löwiscdc44512002-01-12 11:05:12 +00008#include "Python.h"
Guido van Rossum1d5735e1994-08-30 08:27:36 +00009
Matthias Klosea2542be2004-08-16 11:35:51 +000010
11#ifndef _POSIX_THREADS
12/* This means pthreads are not implemented in libc headers, hence the macro
13 not present in unistd.h. But they still can be implemented as an external
14 library (e.g. gnu pth in pthread emulation) */
15# ifdef HAVE_PTHREAD_H
16# include <pthread.h> /* _POSIX_THREADS */
17# endif
18#endif
19
Guido van Rossum2571cc81999-04-07 16:07:23 +000020#ifndef DONT_HAVE_STDIO_H
Guido van Rossum1d5735e1994-08-30 08:27:36 +000021#include <stdio.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +000022#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +000023
Guido van Rossum1d5735e1994-08-30 08:27:36 +000024#include <stdlib.h>
Guido van Rossum1d5735e1994-08-30 08:27:36 +000025
Guido van Rossumd11bfdd1997-04-29 21:48:34 +000026#ifdef __sgi
27#ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.in */
28#undef _POSIX_THREADS
29#endif
30#endif
31
Guido van Rossum49b56061998-10-01 20:42:43 +000032#include "pythread.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +000033
Guido van Rossum1d5735e1994-08-30 08:27:36 +000034#ifndef _POSIX_THREADS
35
Guido van Rossum1984f1e1992-08-04 12:41:02 +000036#ifdef __sgi
Guido van Rossum1d5735e1994-08-30 08:27:36 +000037#define SGI_THREADS
Guido van Rossum1984f1e1992-08-04 12:41:02 +000038#endif
Guido van Rossum1984f1e1992-08-04 12:41:02 +000039
Guido van Rossum1d5735e1994-08-30 08:27:36 +000040#ifdef HAVE_THREAD_H
41#define SOLARIS_THREADS
42#endif
Guido van Rossum1984f1e1992-08-04 12:41:02 +000043
Guido van Rossum1d5735e1994-08-30 08:27:36 +000044#if defined(sun) && !defined(SOLARIS_THREADS)
45#define SUN_LWP
46#endif
47
Guido van Rossum539c6622005-09-14 17:49:54 +000048/* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
49 enough of the Posix threads package is implimented to support python
50 threads.
51
52 This is valid for HP-UX 11.23 running on an ia64 system. If needed, add
53 a check of __ia64 to verify that we're running on a ia64 system instead
54 of a pa-risc system.
55*/
56#ifdef __hpux
57#ifdef _SC_THREADS
58#define _POSIX_THREADS
59#endif
60#endif
61
Sjoerd Mullender66bca321993-12-03 16:54:45 +000062#endif /* _POSIX_THREADS */
Guido van Rossum1984f1e1992-08-04 12:41:02 +000063
Guido van Rossum1984f1e1992-08-04 12:41:02 +000064
Guido van Rossum408027e1996-12-30 16:17:54 +000065#ifdef Py_DEBUG
Guido van Rossum1d5735e1994-08-30 08:27:36 +000066static int thread_debug = 0;
Jeremy Hyltonbd232892002-06-25 19:26:34 +000067#define dprintf(args) (void)((thread_debug & 1) && printf args)
Guido van Rossum1d5735e1994-08-30 08:27:36 +000068#define d2printf(args) ((thread_debug & 8) && printf args)
69#else
70#define dprintf(args)
71#define d2printf(args)
72#endif
73
Guido van Rossum1984f1e1992-08-04 12:41:02 +000074static int initialized;
75
Thomas Wouters8ec68fd2000-07-24 14:39:50 +000076static void PyThread__init_thread(void); /* Forward */
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000077
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000078void PyThread_init_thread(void)
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000079{
Guido van Rossum408027e1996-12-30 16:17:54 +000080#ifdef Py_DEBUG
Sjoerd Mullender66bca321993-12-03 16:54:45 +000081 char *p = getenv("THREADDEBUG");
82
83 if (p) {
84 if (*p)
85 thread_debug = atoi(p);
86 else
87 thread_debug = 1;
88 }
Guido van Rossum408027e1996-12-30 16:17:54 +000089#endif /* Py_DEBUG */
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000090 if (initialized)
91 return;
92 initialized = 1;
Guido van Rossum65d5b571998-12-21 19:32:43 +000093 dprintf(("PyThread_init_thread called\n"));
94 PyThread__init_thread();
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000095}
96
Andrew MacIntyre6539d2d2006-06-04 12:31:09 +000097/* Support for runtime thread stack size tuning.
98 A value of 0 means using the platform's default stack size
99 or the size specified by the THREAD_STACK_SIZE macro. */
100static size_t _pythread_stacksize = 0;
101
102size_t
103PyThread_get_stacksize(void)
104{
105 return _pythread_stacksize;
106}
107
108static int
109_pythread_unsupported_set_stacksize(size_t size)
110{
111 return PyErr_Warn(PyExc_RuntimeWarning,
112 "setting thread stack size not supported on "
113 "this platform");
114}
115
116/* Only platforms with THREAD_SET_STACKSIZE() defined in
117 pthread_<platform>.h, overriding this default definition,
118 will support changing the stack size.
119 Return 1 if an exception is pending, 0 otherwise. */
120#define THREAD_SET_STACKSIZE(x) _pythread_unsupported_set_stacksize(x)
121
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000122#ifdef SGI_THREADS
123#include "thread_sgi.h"
Sjoerd Mullender66bca321993-12-03 16:54:45 +0000124#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000125
126#ifdef SOLARIS_THREADS
127#include "thread_solaris.h"
128#endif
129
130#ifdef SUN_LWP
131#include "thread_lwp.h"
132#endif
133
Guido van Rossum9e8181b2000-09-19 00:46:46 +0000134#ifdef HAVE_PTH
Guido van Rossum07bd90e2000-05-08 13:41:38 +0000135#include "thread_pth.h"
Martin v. Löwis70849f82003-09-20 11:13:36 +0000136#undef _POSIX_THREADS
Guido van Rossum9e8181b2000-09-19 00:46:46 +0000137#endif
138
Sjoerd Mullender66bca321993-12-03 16:54:45 +0000139#ifdef _POSIX_THREADS
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000140#include "thread_pthread.h"
Sjoerd Mullendere8934121993-01-13 12:08:48 +0000141#endif
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000142
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000143#ifdef C_THREADS
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000144#include "thread_cthread.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000145#endif
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000146
Guido van Rossumc3f82b61995-01-17 16:29:31 +0000147#ifdef NT_THREADS
148#include "thread_nt.h"
149#endif
150
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000151#ifdef OS2_THREADS
152#include "thread_os2.h"
153#endif
154
Guido van Rossum1a8791e1998-08-04 22:46:29 +0000155#ifdef BEOS_THREADS
156#include "thread_beos.h"
157#endif
158
Guido van Rossum2571cc81999-04-07 16:07:23 +0000159#ifdef WINCE_THREADS
160#include "thread_wince.h"
161#endif
162
Martin v. Löwis7d1cd692002-03-09 12:10:54 +0000163#ifdef PLAN9_THREADS
164#include "thread_plan9.h"
165#endif
166
Martin v. Löwisf90ae202002-06-11 06:22:31 +0000167#ifdef ATHEOS_THREADS
168#include "thread_atheos.h"
169#endif
170
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000171/*
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000172#ifdef FOOBAR_THREADS
173#include "thread_foobar.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000174#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000175*/
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000176
Andrew MacIntyre6539d2d2006-06-04 12:31:09 +0000177/* use appropriate thread stack size setting routine.
178 Return 1 if an exception is pending, 0 otherwise. */
179int
180PyThread_set_stacksize(size_t size)
181{
182 return THREAD_SET_STACKSIZE(size);
183}
184
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000185#ifndef Py_HAVE_NATIVE_TLS
186/* If the platform has not supplied a platform specific
187 TLS implementation, provide our own.
188
189 This code stolen from "thread_sgi.h", where it was the only
190 implementation of an existing Python TLS API.
191*/
Tim Petersfda787f2004-10-09 22:33:09 +0000192/* ------------------------------------------------------------------------
193Per-thread data ("key") support.
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000194
Tim Petersfda787f2004-10-09 22:33:09 +0000195Use PyThread_create_key() to create a new key. This is typically shared
196across threads.
197
198Use PyThread_set_key_value(thekey, value) to associate void* value with
199thekey in the current thread. Each thread has a distinct mapping of thekey
200to a void* value. Caution: if the current thread already has a mapping
201for thekey, value is ignored.
202
203Use PyThread_get_key_value(thekey) to retrieve the void* value associated
204with thekey in the current thread. This returns NULL if no value is
205associated with thekey in the current thread.
206
207Use PyThread_delete_key_value(thekey) to forget the current thread's associated
208value for thekey. PyThread_delete_key(thekey) forgets the values associated
209with thekey across *all* threads.
210
211While some of these functions have error-return values, none set any
212Python exception.
213
214None of the functions does memory management on behalf of the void* values.
215You need to allocate and deallocate them yourself. If the void* values
216happen to be PyObject*, these functions don't do refcount operations on
217them either.
218
219The GIL does not need to be held when calling these functions; they supply
220their own locking. This isn't true of PyThread_create_key(), though (see
221next paragraph).
222
223There's a hidden assumption that PyThread_create_key() will be called before
224any of the other functions are called. There's also a hidden assumption
225that calls to PyThread_create_key() are serialized externally.
226------------------------------------------------------------------------ */
227
228/* A singly-linked list of struct key objects remembers all the key->value
229 * associations. File static keyhead heads the list. keymutex is used
230 * to enforce exclusion internally.
231 */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000232struct key {
Tim Petersfda787f2004-10-09 22:33:09 +0000233 /* Next record in the list, or NULL if this is the last record. */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000234 struct key *next;
Tim Petersfda787f2004-10-09 22:33:09 +0000235
236 /* The thread id, according to PyThread_get_thread_ident(). */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000237 long id;
Tim Petersfda787f2004-10-09 22:33:09 +0000238
239 /* The key and its associated value. */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000240 int key;
241 void *value;
242};
243
244static struct key *keyhead = NULL;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000245static PyThread_type_lock keymutex = NULL;
Tim Petersfda787f2004-10-09 22:33:09 +0000246static int nkeys = 0; /* PyThread_create_key() hands out nkeys+1 next */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000247
Tim Petersfda787f2004-10-09 22:33:09 +0000248/* Internal helper.
249 * If the current thread has a mapping for key, the appropriate struct key*
250 * is returned. NB: value is ignored in this case!
251 * If there is no mapping for key in the current thread, then:
252 * If value is NULL, NULL is returned.
253 * Else a mapping of key to value is created for the current thread,
254 * and a pointer to a new struct key* is returned; except that if
255 * malloc() can't find room for a new struct key*, NULL is returned.
256 * So when value==NULL, this acts like a pure lookup routine, and when
257 * value!=NULL, this acts like dict.setdefault(), returning an existing
258 * mapping if one exists, else creating a new mapping.
Tim Peters263091e2004-10-10 01:58:44 +0000259 *
260 * Caution: this used to be too clever, trying to hold keymutex only
261 * around the "p->next = keyhead; keyhead = p" pair. That allowed
262 * another thread to mutate the list, via key deletion, concurrent with
263 * find_key() crawling over the list. Hilarity ensued. For example, when
264 * the for-loop here does "p = p->next", p could end up pointing at a
265 * record that PyThread_delete_key_value() was concurrently free()'ing.
266 * That could lead to anything, from failing to find a key that exists, to
267 * segfaults. Now we lock the whole routine.
Tim Petersfda787f2004-10-09 22:33:09 +0000268 */
Tim Peters19717fa2004-10-09 17:38:29 +0000269static struct key *
270find_key(int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000271{
272 struct key *p;
273 long id = PyThread_get_thread_ident();
Tim Petersfda787f2004-10-09 22:33:09 +0000274
Tim Peters263091e2004-10-10 01:58:44 +0000275 PyThread_acquire_lock(keymutex, 1);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000276 for (p = keyhead; p != NULL; p = p->next) {
277 if (p->id == id && p->key == key)
Tim Peters263091e2004-10-10 01:58:44 +0000278 goto Done;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000279 }
Tim Peters263091e2004-10-10 01:58:44 +0000280 if (value == NULL) {
281 assert(p == NULL);
282 goto Done;
283 }
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000284 p = (struct key *)malloc(sizeof(struct key));
285 if (p != NULL) {
286 p->id = id;
287 p->key = key;
288 p->value = value;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000289 p->next = keyhead;
290 keyhead = p;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000291 }
Tim Peters263091e2004-10-10 01:58:44 +0000292 Done:
293 PyThread_release_lock(keymutex);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000294 return p;
295}
296
Tim Petersfda787f2004-10-09 22:33:09 +0000297/* Return a new key. This must be called before any other functions in
298 * this family, and callers must arrange to serialize calls to this
299 * function. No violations are detected.
300 */
Tim Peters19717fa2004-10-09 17:38:29 +0000301int
302PyThread_create_key(void)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000303{
Tim Petersfda787f2004-10-09 22:33:09 +0000304 /* All parts of this function are wrong if it's called by multiple
305 * threads simultaneously.
306 */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000307 if (keymutex == NULL)
308 keymutex = PyThread_allocate_lock();
309 return ++nkeys;
310}
311
Tim Petersfda787f2004-10-09 22:33:09 +0000312/* Forget the associations for key across *all* threads. */
Tim Peters19717fa2004-10-09 17:38:29 +0000313void
314PyThread_delete_key(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000315{
316 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000317
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000318 PyThread_acquire_lock(keymutex, 1);
319 q = &keyhead;
320 while ((p = *q) != NULL) {
321 if (p->key == key) {
322 *q = p->next;
323 free((void *)p);
324 /* NB This does *not* free p->value! */
325 }
326 else
327 q = &p->next;
328 }
329 PyThread_release_lock(keymutex);
330}
331
Tim Petersfda787f2004-10-09 22:33:09 +0000332/* Confusing: If the current thread has an association for key,
333 * value is ignored, and 0 is returned. Else an attempt is made to create
334 * an association of key to value for the current thread. 0 is returned
335 * if that succeeds, but -1 is returned if there's not enough memory
336 * to create the association. value must not be NULL.
337 */
Tim Peters19717fa2004-10-09 17:38:29 +0000338int
339PyThread_set_key_value(int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000340{
Tim Petersfda787f2004-10-09 22:33:09 +0000341 struct key *p;
342
343 assert(value != NULL);
344 p = find_key(key, value);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000345 if (p == NULL)
346 return -1;
347 else
348 return 0;
349}
350
Tim Petersfda787f2004-10-09 22:33:09 +0000351/* Retrieve the value associated with key in the current thread, or NULL
352 * if the current thread doesn't have an association for key.
353 */
Tim Peters19717fa2004-10-09 17:38:29 +0000354void *
355PyThread_get_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000356{
357 struct key *p = find_key(key, NULL);
Tim Petersfda787f2004-10-09 22:33:09 +0000358
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000359 if (p == NULL)
360 return NULL;
361 else
362 return p->value;
363}
364
Tim Petersfda787f2004-10-09 22:33:09 +0000365/* Forget the current thread's association for key, if any. */
Tim Peters19717fa2004-10-09 17:38:29 +0000366void
367PyThread_delete_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000368{
369 long id = PyThread_get_thread_ident();
370 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000371
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000372 PyThread_acquire_lock(keymutex, 1);
373 q = &keyhead;
374 while ((p = *q) != NULL) {
375 if (p->key == key && p->id == id) {
376 *q = p->next;
377 free((void *)p);
378 /* NB This does *not* free p->value! */
379 break;
380 }
381 else
382 q = &p->next;
383 }
384 PyThread_release_lock(keymutex);
385}
386
387#endif /* Py_HAVE_NATIVE_TLS */