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. */
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 */
20 #ifndef DONT_HAVE_STDIO_H
27 #ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.in */
34 #ifndef _POSIX_THREADS
41 #define SOLARIS_THREADS
44 #if defined(sun) && !defined(SOLARIS_THREADS)
48 /* 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
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
58 #define _POSIX_THREADS
62 #endif /* _POSIX_THREADS */
66 static int thread_debug
= 0;
67 #define dprintf(args) (void)((thread_debug & 1) && printf args)
68 #define d2printf(args) ((thread_debug & 8) && printf args)
71 #define d2printf(args)
74 static int initialized
;
76 static void PyThread__init_thread(void); /* Forward */
79 PyThread_init_thread(void)
82 char *p
= Py_GETENV("PYTHONTHREADDEBUG");
86 thread_debug
= atoi(p
);
94 dprintf(("PyThread_init_thread called\n"));
95 PyThread__init_thread();
98 /* 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. */
101 static size_t _pythread_stacksize
= 0;
104 #include "thread_sgi.h"
107 #ifdef SOLARIS_THREADS
108 #include "thread_solaris.h"
112 #include "thread_lwp.h"
116 #include "thread_pth.h"
117 #undef _POSIX_THREADS
120 #ifdef _POSIX_THREADS
121 #include "thread_pthread.h"
125 #include "thread_cthread.h"
129 #include "thread_nt.h"
133 #include "thread_os2.h"
137 #include "thread_beos.h"
141 #include "thread_wince.h"
145 #include "thread_plan9.h"
148 #ifdef ATHEOS_THREADS
149 #include "thread_atheos.h"
153 #ifdef FOOBAR_THREADS
154 #include "thread_foobar.h"
158 /* return the current thread stack size */
160 PyThread_get_stacksize(void)
162 return _pythread_stacksize
;
165 /* Only platforms defining a THREAD_SET_STACKSIZE() macro
166 in thread_<platform>.h support changing the stack size.
167 Return 0 if stack size is valid,
168 -1 if stack size value is invalid,
169 -2 if setting stack size is not supported. */
171 PyThread_set_stacksize(size_t size
)
173 #if defined(THREAD_SET_STACKSIZE)
174 return THREAD_SET_STACKSIZE(size
);
180 #ifndef Py_HAVE_NATIVE_TLS
181 /* If the platform has not supplied a platform specific
182 TLS implementation, provide our own.
184 This code stolen from "thread_sgi.h", where it was the only
185 implementation of an existing Python TLS API.
187 /* ------------------------------------------------------------------------
188 Per-thread data ("key") support.
190 Use PyThread_create_key() to create a new key. This is typically shared
193 Use PyThread_set_key_value(thekey, value) to associate void* value with
194 thekey in the current thread. Each thread has a distinct mapping of thekey
195 to a void* value. Caution: if the current thread already has a mapping
196 for thekey, value is ignored.
198 Use PyThread_get_key_value(thekey) to retrieve the void* value associated
199 with thekey in the current thread. This returns NULL if no value is
200 associated with thekey in the current thread.
202 Use PyThread_delete_key_value(thekey) to forget the current thread's associated
203 value for thekey. PyThread_delete_key(thekey) forgets the values associated
204 with thekey across *all* threads.
206 While some of these functions have error-return values, none set any
209 None of the functions does memory management on behalf of the void* values.
210 You need to allocate and deallocate them yourself. If the void* values
211 happen to be PyObject*, these functions don't do refcount operations on
214 The GIL does not need to be held when calling these functions; they supply
215 their own locking. This isn't true of PyThread_create_key(), though (see
218 There's a hidden assumption that PyThread_create_key() will be called before
219 any of the other functions are called. There's also a hidden assumption
220 that calls to PyThread_create_key() are serialized externally.
221 ------------------------------------------------------------------------ */
223 /* A singly-linked list of struct key objects remembers all the key->value
224 * associations. File static keyhead heads the list. keymutex is used
225 * to enforce exclusion internally.
228 /* Next record in the list, or NULL if this is the last record. */
231 /* The thread id, according to PyThread_get_thread_ident(). */
234 /* The key and its associated value. */
239 static struct key
*keyhead
= NULL
;
240 static PyThread_type_lock keymutex
= NULL
;
241 static int nkeys
= 0; /* PyThread_create_key() hands out nkeys+1 next */
244 * If the current thread has a mapping for key, the appropriate struct key*
245 * is returned. NB: value is ignored in this case!
246 * If there is no mapping for key in the current thread, then:
247 * If value is NULL, NULL is returned.
248 * Else a mapping of key to value is created for the current thread,
249 * and a pointer to a new struct key* is returned; except that if
250 * malloc() can't find room for a new struct key*, NULL is returned.
251 * So when value==NULL, this acts like a pure lookup routine, and when
252 * value!=NULL, this acts like dict.setdefault(), returning an existing
253 * mapping if one exists, else creating a new mapping.
255 * Caution: this used to be too clever, trying to hold keymutex only
256 * around the "p->next = keyhead; keyhead = p" pair. That allowed
257 * another thread to mutate the list, via key deletion, concurrent with
258 * find_key() crawling over the list. Hilarity ensued. For example, when
259 * the for-loop here does "p = p->next", p could end up pointing at a
260 * record that PyThread_delete_key_value() was concurrently free()'ing.
261 * That could lead to anything, from failing to find a key that exists, to
262 * segfaults. Now we lock the whole routine.
265 find_key(int key
, void *value
)
268 long id
= PyThread_get_thread_ident();
272 PyThread_acquire_lock(keymutex
, 1);
273 for (p
= keyhead
; p
!= NULL
; p
= p
->next
) {
274 if (p
->id
== id
&& p
->key
== key
)
281 p
= (struct key
*)malloc(sizeof(struct key
));
290 PyThread_release_lock(keymutex
);
294 /* Return a new key. This must be called before any other functions in
295 * this family, and callers must arrange to serialize calls to this
296 * function. No violations are detected.
299 PyThread_create_key(void)
301 /* All parts of this function are wrong if it's called by multiple
302 * threads simultaneously.
304 if (keymutex
== NULL
)
305 keymutex
= PyThread_allocate_lock();
309 /* Forget the associations for key across *all* threads. */
311 PyThread_delete_key(int key
)
315 PyThread_acquire_lock(keymutex
, 1);
317 while ((p
= *q
) != NULL
) {
321 /* NB This does *not* free p->value! */
326 PyThread_release_lock(keymutex
);
329 /* Confusing: If the current thread has an association for key,
330 * value is ignored, and 0 is returned. Else an attempt is made to create
331 * an association of key to value for the current thread. 0 is returned
332 * if that succeeds, but -1 is returned if there's not enough memory
333 * to create the association. value must not be NULL.
336 PyThread_set_key_value(int key
, void *value
)
340 assert(value
!= NULL
);
341 p
= find_key(key
, value
);
348 /* Retrieve the value associated with key in the current thread, or NULL
349 * if the current thread doesn't have an association for key.
352 PyThread_get_key_value(int key
)
354 struct key
*p
= find_key(key
, NULL
);
362 /* Forget the current thread's association for key, if any. */
364 PyThread_delete_key_value(int key
)
366 long id
= PyThread_get_thread_ident();
369 PyThread_acquire_lock(keymutex
, 1);
371 while ((p
= *q
) != NULL
) {
372 if (p
->key
== key
&& p
->id
== id
) {
375 /* NB This does *not* free p->value! */
381 PyThread_release_lock(keymutex
);
384 /* Forget everything not associated with the current thread id.
385 * This function is called from PyOS_AfterFork(). It is necessary
386 * because other thread ids which were in use at the time of the fork
387 * may be reused for new threads created in the forked process.
390 PyThread_ReInitTLS(void)
392 long id
= PyThread_get_thread_ident();
398 /* As with interpreter_lock in PyEval_ReInitThreads()
399 we just create a new lock without freeing the old one */
400 keymutex
= PyThread_allocate_lock();
402 /* Delete all keys which do not match the current thread id */
404 while ((p
= *q
) != NULL
) {
408 /* NB This does *not* free p->value! */
415 #endif /* Py_HAVE_NATIVE_TLS */