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
  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)
  69 #else
  70 #define dprintf(args)
  71 #define d2printf(args)
  72 #endif
  73
  74 static int initialized;
  75
  76 static void PyThread__init_thread(void); /* Forward */
  77
  78 void
  79 PyThread_init_thread(void)
  80 {
  81 #ifdef Py_DEBUG
  82         char *p = getenv("THREADDEBUG");
  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. */
 101 static 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 */
 159 size_t
 160 PyThread_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. */
 170 int
 171 PyThread_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 /* ------------------------------------------------------------------------
 188 Per-thread data ("key") support.
 189
 190 Use PyThread_create_key() to create a new key.  This is typically shared
 191 across threads.
 192
 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.
 197
 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.
 201
 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.
 205
 206 While some of these functions have error-return values, none set any
 207 Python exception.
 208
 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
 212 them either.
 213
 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
 216 next paragraph).
 217
 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 ------------------------------------------------------------------------ */
 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  */
 227 struct 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
 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 */
 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  */
 264 static struct key *
 265 find_key(int key, void *value)
 266 {
 267         struct key *p;
 268         long id = PyThread_get_thread_ident();
 269
 270         PyThread_acquire_lock(keymutex, 1);
 271         for (p = keyhead; p != NULL; p = p->next) {
 272                 if (p->id == id && p->key == key)
 273                         goto Done;
 274         }
 275         if (value == NULL) {
 276                 assert(p == NULL);
 277                 goto Done;
 278         }
 279         p = (struct key *)malloc(sizeof(struct key));
 280         if (p != NULL) {
 281                 p->id = id;
 282                 p->key = key;
 283                 p->value = value;
 284                 p->next = keyhead;
 285                 keyhead = p;
 286         }
 287  Done:
 288         PyThread_release_lock(keymutex);
 289         return p;
 290 }
 291
 292 /* Return a new key.  This must be called before any other functions in
 293  * this family, and callers must arrange to serialize calls to this
 294  * function.  No violations are detected.
 295  */
 296 int
 297 PyThread_create_key(void)
 298 {
 299         /* All parts of this function are wrong if it's called by multiple
 300          * threads simultaneously.
 301          */
 302         if (keymutex == NULL)
 303                 keymutex = PyThread_allocate_lock();
 304         return ++nkeys;
 305 }
 306
 307 /* Forget the associations for key across *all* threads. */
 308 void
 309 PyThread_delete_key(int key)
 310 {
 311         struct key *p, **q;
 312
 313         PyThread_acquire_lock(keymutex, 1);
 314         q = &keyhead;
 315         while ((p = *q) != NULL) {
 316                 if (p->key == key) {
 317                         *q = p->next;
 318                         free((void *)p);
 319                         /* NB This does *not* free p->value! */
 320                 }
 321                 else
 322                         q = &p->next;
 323         }
 324         PyThread_release_lock(keymutex);
 325 }
 326
 327 /* Confusing:  If the current thread has an association for key,
 328  * value is ignored, and 0 is returned.  Else an attempt is made to create
 329  * an association of key to value for the current thread.  0 is returned
 330  * if that succeeds, but -1 is returned if there's not enough memory
 331  * to create the association.  value must not be NULL.
 332  */
 333 int
 334 PyThread_set_key_value(int key, void *value)
 335 {
 336         struct key *p;
 337
 338         assert(value != NULL);
 339         p = find_key(key, value);
 340         if (p == NULL)
 341                 return -1;
 342         else
 343                 return 0;
 344 }
 345
 346 /* Retrieve the value associated with key in the current thread, or NULL
 347  * if the current thread doesn't have an association for key.
 348  */
 349 void *
 350 PyThread_get_key_value(int key)
 351 {
 352         struct key *p = find_key(key, NULL);
 353
 354         if (p == NULL)
 355                 return NULL;
 356         else
 357                 return p->value;
 358 }
 359
 360 /* Forget the current thread's association for key, if any. */
 361 void
 362 PyThread_delete_key_value(int key)
 363 {
 364         long id = PyThread_get_thread_ident();
 365         struct key *p, **q;
 366
 367         PyThread_acquire_lock(keymutex, 1);
 368         q = &keyhead;
 369         while ((p = *q) != NULL) {
 370                 if (p->key == key && p->id == id) {
 371                         *q = p->next;
 372                         free((void *)p);
 373                         /* NB This does *not* free p->value! */
 374                         break;
 375                 }
 376                 else
 377                         q = &p->next;
 378         }
 379         PyThread_release_lock(keymutex);
 380 }
 381
 382 #endif /* Py_HAVE_NATIVE_TLS */