/Python/thread.c

  1
  2/* 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
  8#include "Python.h"
  9
 10
 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
 20#ifndef DONT_HAVE_STDIO_H
 21#include <stdio.h>
 22#endif
 23
 24#include <stdlib.h>
 25
 26#ifdef __sgi
 27#ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.in */
 28#undef _POSIX_THREADS
 29#endif
 30#endif
 31
 32#include "pythread.h"
 33
 34#ifndef _POSIX_THREADS
 35
 36#ifdef __sgi
 37#define SGI_THREADS
 38#endif
 39
 40#ifdef HAVE_THREAD_H
 41#define SOLARIS_THREADS
 42#endif
 43
 44#if defined(sun) && !defined(SOLARIS_THREADS)
 45#define SUN_LWP
 46#endif
 47
 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 
 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
 62#endif /* _POSIX_THREADS */
 63
 64
 65#ifdef Py_DEBUG
 66static int thread_debug = 0;
 67#define dprintf(args)	(void)((thread_debug & 1) && printf args)
 68#define d2printf(args)	((thread_debug & 8) && printf args)
 69#else
 70#define dprintf(args)
 71#define d2printf(args)
 72#endif
 73
 74static int initialized;
 75
 76static void PyThread__init_thread(void); /* Forward */
 77
 78void
 79PyThread_init_thread(void)
 80{
 81#ifdef Py_DEBUG
 82	char *p = Py_GETENV("PYTHONTHREADDEBUG");
 83
 84	if (p) {
 85		if (*p)
 86			thread_debug = atoi(p);
 87		else
 88			thread_debug = 1;
 89	}
 90#endif /* Py_DEBUG */
 91	if (initialized)
 92		return;
 93	initialized = 1;
 94	dprintf(("PyThread_init_thread called\n"));
 95	PyThread__init_thread();
 96}
 97
 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. */
101static size_t _pythread_stacksize = 0;
102
103#ifdef SGI_THREADS
104#include "thread_sgi.h"
105#endif
106
107#ifdef SOLARIS_THREADS
108#include "thread_solaris.h"
109#endif
110
111#ifdef SUN_LWP
112#include "thread_lwp.h"
113#endif
114
115#ifdef HAVE_PTH
116#include "thread_pth.h"
117#undef _POSIX_THREADS
118#endif
119
120#ifdef _POSIX_THREADS
121#include "thread_pthread.h"
122#endif
123
124#ifdef C_THREADS
125#include "thread_cthread.h"
126#endif
127
128#ifdef NT_THREADS
129#include "thread_nt.h"
130#endif
131
132#ifdef OS2_THREADS
133#include "thread_os2.h"
134#endif
135
136#ifdef BEOS_THREADS
137#include "thread_beos.h"
138#endif
139
140#ifdef WINCE_THREADS
141#include "thread_wince.h"
142#endif
143
144#ifdef PLAN9_THREADS
145#include "thread_plan9.h"
146#endif
147
148#ifdef ATHEOS_THREADS
149#include "thread_atheos.h"
150#endif
151
152/*
153#ifdef FOOBAR_THREADS
154#include "thread_foobar.h"
155#endif
156*/
157
158/* return the current thread stack size */
159size_t
160PyThread_get_stacksize(void)
161{
162	return _pythread_stacksize;
163}
164
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. */
170int
171PyThread_set_stacksize(size_t size)
172{
173#if defined(THREAD_SET_STACKSIZE)
174	return THREAD_SET_STACKSIZE(size);
175#else
176	return -2;
177#endif
178}
179
180#ifndef Py_HAVE_NATIVE_TLS
181/* If the platform has not supplied a platform specific
182   TLS implementation, provide our own.
183
184   This code stolen from "thread_sgi.h", where it was the only
185   implementation of an existing Python TLS API.
186*/
187/* ------------------------------------------------------------------------
188Per-thread data ("key") support.
189
190Use PyThread_create_key() to create a new key.  This is typically shared
191across threads.
192
193Use PyThread_set_key_value(thekey, value) to associate void* value with
194thekey in the current thread.  Each thread has a distinct mapping of thekey
195to a void* value.  Caution:  if the current thread already has a mapping
196for thekey, value is ignored.
197
198Use PyThread_get_key_value(thekey) to retrieve the void* value associated
199with thekey in the current thread.  This returns NULL if no value is
200associated with thekey in the current thread.
201
202Use PyThread_delete_key_value(thekey) to forget the current thread's associated
203value for thekey.  PyThread_delete_key(thekey) forgets the values associated
204with thekey across *all* threads.
205
206While some of these functions have error-return values, none set any
207Python exception.
208
209None of the functions does memory management on behalf of the void* values.
210You need to allocate and deallocate them yourself.  If the void* values
211happen to be PyObject*, these functions don't do refcount operations on
212them either.
213
214The GIL does not need to be held when calling these functions; they supply
215their own locking.  This isn't true of PyThread_create_key(), though (see
216next paragraph).
217
218There's a hidden assumption that PyThread_create_key() will be called before
219any of the other functions are called.  There's also a hidden assumption
220that calls to PyThread_create_key() are serialized externally.
221------------------------------------------------------------------------ */
222
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.
226 */
227struct key {
228	/* Next record in the list, or NULL if this is the last record. */
229	struct key *next;
230
231	/* The thread id, according to PyThread_get_thread_ident(). */
232	long id;
233
234	/* The key and its associated value. */
235	int key;
236	void *value;
237};
238
239static struct key *keyhead = NULL;
240static PyThread_type_lock keymutex = NULL;
241static int nkeys = 0;  /* PyThread_create_key() hands out nkeys+1 next */
242
243/* Internal helper.
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.
254 *
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.
263 */
264static struct key *
265find_key(int key, void *value)
266{
267	struct key *p, *prev_p;
268	long id = PyThread_get_thread_ident();
269
270	if (!keymutex)
271		return NULL;
272	PyThread_acquire_lock(keymutex, 1);
273	prev_p = NULL;
274	for (p = keyhead; p != NULL; p = p->next) {
275		if (p->id == id && p->key == key)
276			goto Done;
277		/* Sanity check.  These states should never happen but if
278		 * they do we must abort.  Otherwise we'll end up spinning in
279		 * in a tight loop with the lock held.  A similar check is done
280		 * in pystate.c tstate_delete_common().  */
281		if (p == prev_p)
282			Py_FatalError("tls find_key: small circular list(!)");
283		prev_p = p;
284		if (p->next == keyhead)
285			Py_FatalError("tls find_key: circular list(!)");
286	}
287	if (value == NULL) {
288		assert(p == NULL);
289		goto Done;
290	}
291	p = (struct key *)malloc(sizeof(struct key));
292	if (p != NULL) {
293		p->id = id;
294		p->key = key;
295		p->value = value;
296		p->next = keyhead;
297		keyhead = p;
298	}
299 Done:
300	PyThread_release_lock(keymutex);
301	return p;
302}
303
304/* Return a new key.  This must be called before any other functions in
305 * this family, and callers must arrange to serialize calls to this
306 * function.  No violations are detected.
307 */
308int
309PyThread_create_key(void)
310{
311	/* All parts of this function are wrong if it's called by multiple
312	 * threads simultaneously.
313	 */
314	if (keymutex == NULL)
315		keymutex = PyThread_allocate_lock();
316	return ++nkeys;
317}
318
319/* Forget the associations for key across *all* threads. */
320void
321PyThread_delete_key(int key)
322{
323	struct key *p, **q;
324
325	PyThread_acquire_lock(keymutex, 1);
326	q = &keyhead;
327	while ((p = *q) != NULL) {
328		if (p->key == key) {
329			*q = p->next;
330			free((void *)p);
331			/* NB This does *not* free p->value! */
332		}
333		else
334			q = &p->next;
335	}
336	PyThread_release_lock(keymutex);
337}
338
339/* Confusing:  If the current thread has an association for key,
340 * value is ignored, and 0 is returned.  Else an attempt is made to create
341 * an association of key to value for the current thread.  0 is returned
342 * if that succeeds, but -1 is returned if there's not enough memory
343 * to create the association.  value must not be NULL.
344 */
345int
346PyThread_set_key_value(int key, void *value)
347{
348	struct key *p;
349
350	assert(value != NULL);
351	p = find_key(key, value);
352	if (p == NULL)
353		return -1;
354	else
355		return 0;
356}
357
358/* Retrieve the value associated with key in the current thread, or NULL
359 * if the current thread doesn't have an association for key.
360 */
361void *
362PyThread_get_key_value(int key)
363{
364	struct key *p = find_key(key, NULL);
365
366	if (p == NULL)
367		return NULL;
368	else
369		return p->value;
370}
371
372/* Forget the current thread's association for key, if any. */
373void
374PyThread_delete_key_value(int key)
375{
376	long id = PyThread_get_thread_ident();
377	struct key *p, **q;
378
379	PyThread_acquire_lock(keymutex, 1);
380	q = &keyhead;
381	while ((p = *q) != NULL) {
382		if (p->key == key && p->id == id) {
383			*q = p->next;
384			free((void *)p);
385			/* NB This does *not* free p->value! */
386			break;
387		}
388		else
389			q = &p->next;
390	}
391	PyThread_release_lock(keymutex);
392}
393
394/* Forget everything not associated with the current thread id.
395 * This function is called from PyOS_AfterFork().  It is necessary
396 * because other thread ids which were in use at the time of the fork
397 * may be reused for new threads created in the forked process.
398 */
399void
400PyThread_ReInitTLS(void)
401{
402	long id = PyThread_get_thread_ident();
403	struct key *p, **q;
404
405	if (!keymutex)
406		return;
407	
408	/* As with interpreter_lock in PyEval_ReInitThreads()
409	   we just create a new lock without freeing the old one */
410	keymutex = PyThread_allocate_lock();
411
412	/* Delete all keys which do not match the current thread id */
413	q = &keyhead;
414	while ((p = *q) != NULL) {
415		if (p->id != id) {
416			*q = p->next;
417			free((void *)p);
418			/* NB This does *not* free p->value! */
419		}
420		else
421			q = &p->next;
422	}
423}
424
425#endif /* Py_HAVE_NATIVE_TLS */