blob: 41fa1e63139818bbe39a9301bfeb9d0e8fb39f28 [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 Wouters73e5a5b2006-06-08 15:35:45 +000078void
79PyThread_init_thread(void)
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000080{
Guido van Rossum408027e1996-12-30 16:17:54 +000081#ifdef Py_DEBUG
Christian Heimes790c8232008-01-07 21:14:23 +000082 char *p = Py_GETENV("PYTHONTHREADDEBUG");
Sjoerd Mullender66bca321993-12-03 16:54:45 +000083
84 if (p) {
85 if (*p)
86 thread_debug = atoi(p);
87 else
88 thread_debug = 1;
89 }
Guido van Rossum408027e1996-12-30 16:17:54 +000090#endif /* Py_DEBUG */
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000091 if (initialized)
92 return;
93 initialized = 1;
Guido van Rossum65d5b571998-12-21 19:32:43 +000094 dprintf(("PyThread_init_thread called\n"));
95 PyThread__init_thread();
Sjoerd Mullenderaee8bc11992-09-02 11:25:37 +000096}
97
Thomas Wouters0e3f5912006-08-11 14:57:12 +000098/* Support for runtime thread stack size tuning.
99 A value of 0 means using the platform's default stack size
100 or the size specified by the THREAD_STACK_SIZE macro. */
101static size_t _pythread_stacksize = 0;
102
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000103#ifdef SGI_THREADS
104#include "thread_sgi.h"
Sjoerd Mullender66bca321993-12-03 16:54:45 +0000105#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000106
107#ifdef SOLARIS_THREADS
108#include "thread_solaris.h"
109#endif
110
111#ifdef SUN_LWP
112#include "thread_lwp.h"
113#endif
114
Guido van Rossum9e8181b2000-09-19 00:46:46 +0000115#ifdef HAVE_PTH
Guido van Rossum07bd90e2000-05-08 13:41:38 +0000116#include "thread_pth.h"
Martin v. Löwis70849f82003-09-20 11:13:36 +0000117#undef _POSIX_THREADS
Guido van Rossum9e8181b2000-09-19 00:46:46 +0000118#endif
119
Sjoerd Mullender66bca321993-12-03 16:54:45 +0000120#ifdef _POSIX_THREADS
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000121#include "thread_pthread.h"
Sjoerd Mullendere8934121993-01-13 12:08:48 +0000122#endif
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000123
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000124#ifdef C_THREADS
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000125#include "thread_cthread.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000126#endif
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000127
Guido van Rossumc3f82b61995-01-17 16:29:31 +0000128#ifdef NT_THREADS
129#include "thread_nt.h"
130#endif
131
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000132#ifdef OS2_THREADS
133#include "thread_os2.h"
134#endif
135
Guido van Rossum2571cc81999-04-07 16:07:23 +0000136#ifdef WINCE_THREADS
137#include "thread_wince.h"
138#endif
139
Martin v. Löwis7d1cd692002-03-09 12:10:54 +0000140#ifdef PLAN9_THREADS
141#include "thread_plan9.h"
142#endif
143
Martin v. Löwisf90ae202002-06-11 06:22:31 +0000144#ifdef ATHEOS_THREADS
145#include "thread_atheos.h"
146#endif
147
Guido van Rossumf9f2e821992-08-17 08:59:08 +0000148/*
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000149#ifdef FOOBAR_THREADS
150#include "thread_foobar.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000151#endif
Guido van Rossum1d5735e1994-08-30 08:27:36 +0000152*/
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000153
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000154/* return the current thread stack size */
155size_t
156PyThread_get_stacksize(void)
157{
158 return _pythread_stacksize;
159}
160
161/* Only platforms defining a THREAD_SET_STACKSIZE() macro
162 in thread_<platform>.h support changing the stack size.
163 Return 0 if stack size is valid,
164 -1 if stack size value is invalid,
165 -2 if setting stack size is not supported. */
166int
167PyThread_set_stacksize(size_t size)
168{
169#if defined(THREAD_SET_STACKSIZE)
170 return THREAD_SET_STACKSIZE(size);
171#else
172 return -2;
173#endif
174}
175
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000176#ifndef Py_HAVE_NATIVE_TLS
177/* If the platform has not supplied a platform specific
178 TLS implementation, provide our own.
179
180 This code stolen from "thread_sgi.h", where it was the only
181 implementation of an existing Python TLS API.
182*/
Tim Petersfda787f2004-10-09 22:33:09 +0000183/* ------------------------------------------------------------------------
184Per-thread data ("key") support.
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000185
Tim Petersfda787f2004-10-09 22:33:09 +0000186Use PyThread_create_key() to create a new key. This is typically shared
187across threads.
188
189Use PyThread_set_key_value(thekey, value) to associate void* value with
190thekey in the current thread. Each thread has a distinct mapping of thekey
191to a void* value. Caution: if the current thread already has a mapping
192for thekey, value is ignored.
193
194Use PyThread_get_key_value(thekey) to retrieve the void* value associated
195with thekey in the current thread. This returns NULL if no value is
196associated with thekey in the current thread.
197
198Use PyThread_delete_key_value(thekey) to forget the current thread's associated
199value for thekey. PyThread_delete_key(thekey) forgets the values associated
200with thekey across *all* threads.
201
202While some of these functions have error-return values, none set any
203Python exception.
204
205None of the functions does memory management on behalf of the void* values.
206You need to allocate and deallocate them yourself. If the void* values
207happen to be PyObject*, these functions don't do refcount operations on
208them either.
209
210The GIL does not need to be held when calling these functions; they supply
211their own locking. This isn't true of PyThread_create_key(), though (see
212next paragraph).
213
214There's a hidden assumption that PyThread_create_key() will be called before
215any of the other functions are called. There's also a hidden assumption
216that calls to PyThread_create_key() are serialized externally.
217------------------------------------------------------------------------ */
218
219/* A singly-linked list of struct key objects remembers all the key->value
220 * associations. File static keyhead heads the list. keymutex is used
221 * to enforce exclusion internally.
222 */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000223struct key {
Tim Petersfda787f2004-10-09 22:33:09 +0000224 /* Next record in the list, or NULL if this is the last record. */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000225 struct key *next;
Tim Petersfda787f2004-10-09 22:33:09 +0000226
227 /* The thread id, according to PyThread_get_thread_ident(). */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000228 long id;
Tim Petersfda787f2004-10-09 22:33:09 +0000229
230 /* The key and its associated value. */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000231 int key;
232 void *value;
233};
234
235static struct key *keyhead = NULL;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000236static PyThread_type_lock keymutex = NULL;
Tim Petersfda787f2004-10-09 22:33:09 +0000237static int nkeys = 0; /* PyThread_create_key() hands out nkeys+1 next */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000238
Tim Petersfda787f2004-10-09 22:33:09 +0000239/* Internal helper.
240 * If the current thread has a mapping for key, the appropriate struct key*
241 * is returned. NB: value is ignored in this case!
242 * If there is no mapping for key in the current thread, then:
243 * If value is NULL, NULL is returned.
244 * Else a mapping of key to value is created for the current thread,
245 * and a pointer to a new struct key* is returned; except that if
246 * malloc() can't find room for a new struct key*, NULL is returned.
247 * So when value==NULL, this acts like a pure lookup routine, and when
248 * value!=NULL, this acts like dict.setdefault(), returning an existing
249 * mapping if one exists, else creating a new mapping.
Tim Peters263091e2004-10-10 01:58:44 +0000250 *
251 * Caution: this used to be too clever, trying to hold keymutex only
252 * around the "p->next = keyhead; keyhead = p" pair. That allowed
253 * another thread to mutate the list, via key deletion, concurrent with
254 * find_key() crawling over the list. Hilarity ensued. For example, when
255 * the for-loop here does "p = p->next", p could end up pointing at a
256 * record that PyThread_delete_key_value() was concurrently free()'ing.
257 * That could lead to anything, from failing to find a key that exists, to
258 * segfaults. Now we lock the whole routine.
Tim Petersfda787f2004-10-09 22:33:09 +0000259 */
Tim Peters19717fa2004-10-09 17:38:29 +0000260static struct key *
261find_key(int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000262{
263 struct key *p;
264 long id = PyThread_get_thread_ident();
Tim Petersfda787f2004-10-09 22:33:09 +0000265
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000266 if (!keymutex)
267 return NULL;
Tim Peters263091e2004-10-10 01:58:44 +0000268 PyThread_acquire_lock(keymutex, 1);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000269 for (p = keyhead; p != NULL; p = p->next) {
270 if (p->id == id && p->key == key)
Tim Peters263091e2004-10-10 01:58:44 +0000271 goto Done;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000272 }
Tim Peters263091e2004-10-10 01:58:44 +0000273 if (value == NULL) {
274 assert(p == NULL);
275 goto Done;
276 }
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000277 p = (struct key *)malloc(sizeof(struct key));
278 if (p != NULL) {
279 p->id = id;
280 p->key = key;
281 p->value = value;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000282 p->next = keyhead;
283 keyhead = p;
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000284 }
Tim Peters263091e2004-10-10 01:58:44 +0000285 Done:
286 PyThread_release_lock(keymutex);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000287 return p;
288}
289
Tim Petersfda787f2004-10-09 22:33:09 +0000290/* Return a new key. This must be called before any other functions in
291 * this family, and callers must arrange to serialize calls to this
292 * function. No violations are detected.
293 */
Tim Peters19717fa2004-10-09 17:38:29 +0000294int
295PyThread_create_key(void)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000296{
Tim Petersfda787f2004-10-09 22:33:09 +0000297 /* All parts of this function are wrong if it's called by multiple
298 * threads simultaneously.
299 */
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000300 if (keymutex == NULL)
301 keymutex = PyThread_allocate_lock();
302 return ++nkeys;
303}
304
Tim Petersfda787f2004-10-09 22:33:09 +0000305/* Forget the associations for key across *all* threads. */
Tim Peters19717fa2004-10-09 17:38:29 +0000306void
307PyThread_delete_key(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000308{
309 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000310
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000311 PyThread_acquire_lock(keymutex, 1);
312 q = &keyhead;
313 while ((p = *q) != NULL) {
314 if (p->key == key) {
315 *q = p->next;
316 free((void *)p);
317 /* NB This does *not* free p->value! */
318 }
319 else
320 q = &p->next;
321 }
322 PyThread_release_lock(keymutex);
323}
324
Tim Petersfda787f2004-10-09 22:33:09 +0000325/* Confusing: If the current thread has an association for key,
326 * value is ignored, and 0 is returned. Else an attempt is made to create
327 * an association of key to value for the current thread. 0 is returned
328 * if that succeeds, but -1 is returned if there's not enough memory
329 * to create the association. value must not be NULL.
330 */
Tim Peters19717fa2004-10-09 17:38:29 +0000331int
332PyThread_set_key_value(int key, void *value)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000333{
Tim Petersfda787f2004-10-09 22:33:09 +0000334 struct key *p;
335
336 assert(value != NULL);
337 p = find_key(key, value);
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000338 if (p == NULL)
339 return -1;
340 else
341 return 0;
342}
343
Tim Petersfda787f2004-10-09 22:33:09 +0000344/* Retrieve the value associated with key in the current thread, or NULL
345 * if the current thread doesn't have an association for key.
346 */
Tim Peters19717fa2004-10-09 17:38:29 +0000347void *
348PyThread_get_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000349{
350 struct key *p = find_key(key, NULL);
Tim Petersfda787f2004-10-09 22:33:09 +0000351
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000352 if (p == NULL)
353 return NULL;
354 else
355 return p->value;
356}
357
Tim Petersfda787f2004-10-09 22:33:09 +0000358/* Forget the current thread's association for key, if any. */
Tim Peters19717fa2004-10-09 17:38:29 +0000359void
360PyThread_delete_key_value(int key)
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000361{
362 long id = PyThread_get_thread_ident();
363 struct key *p, **q;
Tim Petersfda787f2004-10-09 22:33:09 +0000364
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000365 PyThread_acquire_lock(keymutex, 1);
366 q = &keyhead;
367 while ((p = *q) != NULL) {
368 if (p->key == key && p->id == id) {
369 *q = p->next;
370 free((void *)p);
371 /* NB This does *not* free p->value! */
372 break;
373 }
374 else
375 q = &p->next;
376 }
377 PyThread_release_lock(keymutex);
378}
379
Benjamin Petersone68df0f2008-06-13 00:26:50 +0000380/* Forget everything not associated with the current thread id.
381 * This function is called from PyOS_AfterFork(). It is necessary
382 * because other thread ids which were in use at the time of the fork
383 * may be reused for new threads created in the forked process.
384 */
385void
386PyThread_ReInitTLS(void)
387{
388 long id = PyThread_get_thread_ident();
389 struct key *p, **q;
390
391 if (!keymutex)
392 return;
393
394 /* As with interpreter_lock in PyEval_ReInitThreads()
395 we just create a new lock without freeing the old one */
396 keymutex = PyThread_allocate_lock();
397
398 /* Delete all keys which do not match the current thread id */
399 q = &keyhead;
400 while ((p = *q) != NULL) {
401 if (p->id != id) {
402 *q = p->next;
403 free((void *)p);
404 /* NB This does *not* free p->value! */
405 }
406 else
407 q = &p->next;
408 }
409}
410
Mark Hammond8d98d2c2003-04-19 15:41:53 +0000411#endif /* Py_HAVE_NATIVE_TLS */