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 #ifndef DONT_HAVE_STDIO_H
  11 #include <stdio.h>
  12 #endif
  13
  14 #ifdef HAVE_STDLIB_H
  15 #include <stdlib.h>
  16 #else
  17 #ifdef Py_DEBUG
  18 extern char *getenv(const char *);
  19 #endif
  20 #endif
  21
  22 #ifdef __DGUX
  23 #define _USING_POSIX4A_DRAFT6
  24 #endif
  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 #if defined(__MWERKS__) && !defined(__BEOS__)
  49 #define _POSIX_THREADS
  50 #endif
  51
  52 #endif /* _POSIX_THREADS */
  53
  54
  55 #ifdef Py_DEBUG
  56 static int thread_debug = 0;
  57 #define dprintf(args)   (void)((thread_debug & 1) && printf args)
  58 #define d2printf(args)  ((thread_debug & 8) && printf args)
  59 #else
  60 #define dprintf(args)
  61 #define d2printf(args)
  62 #endif
  63
  64 static int initialized;
  65
  66 static void PyThread__init_thread(void); /* Forward */
  67
  68 void PyThread_init_thread(void)
  69 {
  70 #ifdef Py_DEBUG
  71         char *p = getenv("THREADDEBUG");
  72
  73         if (p) {
  74                 if (*p)
  75                         thread_debug = atoi(p);
  76                 else
  77                         thread_debug = 1;
  78         }
  79 #endif /* Py_DEBUG */
  80         if (initialized)
  81                 return;
  82         initialized = 1;
  83         dprintf(("PyThread_init_thread called\n"));
  84         PyThread__init_thread();
  85 }
  86
  87 #ifdef SGI_THREADS
  88 #include "thread_sgi.h"
  89 #endif
  90
  91 #ifdef SOLARIS_THREADS
  92 #include "thread_solaris.h"
  93 #endif
  94
  95 #ifdef SUN_LWP
  96 #include "thread_lwp.h"
  97 #endif
  98
  99 #ifdef HAVE_PTH
 100 #include "thread_pth.h"
 101 #undef _POSIX_THREADS
 102 #endif
 103
 104 #ifdef _POSIX_THREADS
 105 #include "thread_pthread.h"
 106 #endif
 107
 108 #ifdef C_THREADS
 109 #include "thread_cthread.h"
 110 #endif
 111
 112 #ifdef NT_THREADS
 113 #include "thread_nt.h"
 114 #endif
 115
 116 #ifdef OS2_THREADS
 117 #include "thread_os2.h"
 118 #endif
 119
 120 #ifdef BEOS_THREADS
 121 #include "thread_beos.h"
 122 #endif
 123
 124 #ifdef WINCE_THREADS
 125 #include "thread_wince.h"
 126 #endif
 127
 128 #ifdef PLAN9_THREADS
 129 #include "thread_plan9.h"
 130 #endif
 131
 132 #ifdef ATHEOS_THREADS
 133 #include "thread_atheos.h"
 134 #endif
 135
 136 /*
 137 #ifdef FOOBAR_THREADS
 138 #include "thread_foobar.h"
 139 #endif
 140 */
 141
 142 #ifndef Py_HAVE_NATIVE_TLS
 143 /* If the platform has not supplied a platform specific
 144    TLS implementation, provide our own.
 145
 146    This code stolen from "thread_sgi.h", where it was the only
 147    implementation of an existing Python TLS API.
 148 */
 149 /*
 150  * Per-thread data ("key") support.
 151  */
 152
 153 struct key {
 154         struct key *next;
 155         long id;
 156         int key;
 157         void *value;
 158 };
 159
 160 static struct key *keyhead = NULL;
 161 static int nkeys = 0;
 162 static PyThread_type_lock keymutex = NULL;
 163
 164 static struct key *find_key(int key, void *value)
 165 {
 166         struct key *p;
 167         long id = PyThread_get_thread_ident();
 168         for (p = keyhead; p != NULL; p = p->next) {
 169                 if (p->id == id && p->key == key)
 170                         return p;
 171         }
 172         if (value == NULL)
 173                 return NULL;
 174         p = (struct key *)malloc(sizeof(struct key));
 175         if (p != NULL) {
 176                 p->id = id;
 177                 p->key = key;
 178                 p->value = value;
 179                 PyThread_acquire_lock(keymutex, 1);
 180                 p->next = keyhead;
 181                 keyhead = p;
 182                 PyThread_release_lock(keymutex);
 183         }
 184         return p;
 185 }
 186
 187 int PyThread_create_key(void)
 188 {
 189         if (keymutex == NULL)
 190                 keymutex = PyThread_allocate_lock();
 191         return ++nkeys;
 192 }
 193
 194 void PyThread_delete_key(int key)
 195 {
 196         struct key *p, **q;
 197         PyThread_acquire_lock(keymutex, 1);
 198         q = &keyhead;
 199         while ((p = *q) != NULL) {
 200                 if (p->key == key) {
 201                         *q = p->next;
 202                         free((void *)p);
 203                         /* NB This does *not* free p->value! */
 204                 }
 205                 else
 206                         q = &p->next;
 207         }
 208         PyThread_release_lock(keymutex);
 209 }
 210
 211 int PyThread_set_key_value(int key, void *value)
 212 {
 213         struct key *p = find_key(key, value);
 214         if (p == NULL)
 215                 return -1;
 216         else
 217                 return 0;
 218 }
 219
 220 void *PyThread_get_key_value(int key)
 221 {
 222         struct key *p = find_key(key, NULL);
 223         if (p == NULL)
 224                 return NULL;
 225         else
 226                 return p->value;
 227 }
 228
 229 void PyThread_delete_key_value(int key)
 230 {
 231         long id = PyThread_get_thread_ident();
 232         struct key *p, **q;
 233         PyThread_acquire_lock(keymutex, 1);
 234         q = &keyhead;
 235         while ((p = *q) != NULL) {
 236                 if (p->key == key && p->id == id) {
 237                         *q = p->next;
 238                         free((void *)p);
 239                         /* NB This does *not* free p->value! */
 240                         break;
 241                 }
 242                 else
 243                         q = &p->next;
 244         }
 245         PyThread_release_lock(keymutex);
 246 }
 247
 248 #endif /* Py_HAVE_NATIVE_TLS */