Python/thread_pthread.h

   1
   2 /* Posix threads interface */
   3
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <pthread.h>
   7
   8
   9 /* try to determine what version of the Pthread Standard is installed.
  10  * this is important, since all sorts of parameter types changed from
  11  * draft to draft and there are several (incompatible) drafts in
  12  * common use.  these macros are a start, at least.
  13  * 12 May 1997 -- david arnold <davida@pobox.com>
  14  */
  15
  16 #if defined(__ultrix) && defined(__mips) && defined(_DECTHREADS_)
  17 /* _DECTHREADS_ is defined in cma.h which is included by pthread.h */
  18 #  define PY_PTHREAD_D4
  19
  20 #elif defined(__osf__) && defined (__alpha)
  21 /* _DECTHREADS_ is defined in cma.h which is included by pthread.h */
  22 #  if !defined(_PTHREAD_ENV_ALPHA) || defined(_PTHREAD_USE_D4) || defined(PTHREAD_USE_D4)
  23 #    define PY_PTHREAD_D4
  24 #  else
  25 #    define PY_PTHREAD_STD
  26 #  endif
  27
  28 #elif defined(_AIX)
  29 /* SCHED_BG_NP is defined if using AIX DCE pthreads
  30  * but it is unsupported by AIX 4 pthreads. Default
  31  * attributes for AIX 4 pthreads equal to NULL. For
  32  * AIX DCE pthreads they should be left unchanged.
  33  */
  34 #  if !defined(SCHED_BG_NP)
  35 #    define PY_PTHREAD_STD
  36 #  else
  37 #    define PY_PTHREAD_D7
  38 #  endif
  39
  40 #elif defined(__DGUX)
  41 #  define PY_PTHREAD_D6
  42
  43 #elif defined(__hpux) && defined(_DECTHREADS_)
  44 #  define PY_PTHREAD_D4
  45
  46 #else /* Default case */
  47 #  define PY_PTHREAD_STD
  48
  49 #endif
  50
  51
  52 /* set default attribute object for different versions */
  53
  54 #if defined(PY_PTHREAD_D4) || defined(PY_PTHREAD_D7)
  55 #  define pthread_attr_default pthread_attr_default
  56 #  define pthread_mutexattr_default pthread_mutexattr_default
  57 #  define pthread_condattr_default pthread_condattr_default
  58 #elif defined(PY_PTHREAD_STD) || defined(PY_PTHREAD_D6)
  59 #  define pthread_attr_default ((pthread_attr_t *)NULL)
  60 #  define pthread_mutexattr_default ((pthread_mutexattr_t *)NULL)
  61 #  define pthread_condattr_default ((pthread_condattr_t *)NULL)
  62 #endif
  63
  64
  65 /* A pthread mutex isn't sufficient to model the Python lock type
  66  * because, according to Draft 5 of the docs (P1003.4a/D5), both of the
  67  * following are undefined:
  68  *  -> a thread tries to lock a mutex it already has locked
  69  *  -> a thread tries to unlock a mutex locked by a different thread
  70  * pthread mutexes are designed for serializing threads over short pieces
  71  * of code anyway, so wouldn't be an appropriate implementation of
  72  * Python's locks regardless.
  73  *
  74  * The pthread_lock struct implements a Python lock as a "locked?" bit
  75  * and a <condition, mutex> pair.  In general, if the bit can be acquired
  76  * instantly, it is, else the pair is used to block the thread until the
  77  * bit is cleared.     9 May 1994 tim@ksr.com
  78  */
  79
  80 typedef struct {
  81         char             locked; /* 0=unlocked, 1=locked */
  82         /* a <cond, mutex> pair to handle an acquire of a locked lock */
  83         pthread_cond_t   lock_released;
  84         pthread_mutex_t  mut;
  85 } pthread_lock;
  86
  87 #define CHECK_STATUS(name)  if (status != 0) { perror(name); error = 1; }
  88
  89 /*
  90  * Initialization.
  91  */
  92
  93 #ifdef _HAVE_BSDI
  94 static
  95 void _noop(void)
  96 {
  97 }
  98
  99 static void
 100 PyThread__init_thread(void)
 101 {
 102         /* DO AN INIT BY STARTING THE THREAD */
 103         static int dummy = 0;
 104         pthread_t thread1;
 105         pthread_create(&thread1, NULL, (void *) _noop, &dummy);
 106         pthread_join(thread1, NULL);
 107 }
 108
 109 #else /* !_HAVE_BSDI */
 110
 111 static void
 112 PyThread__init_thread(void)
 113 {
 114 #if defined(_AIX) && defined(__GNUC__)
 115         pthread_init();
 116 #endif
 117 }
 118
 119 #endif /* !_HAVE_BSDI */
 120
 121 /*
 122  * Thread support.
 123  */
 124
 125
 126 int
 127 PyThread_start_new_thread(void (*func)(void *), void *arg)
 128 {
 129         pthread_t th;
 130         int success;
 131         dprintf(("PyThread_start_new_thread called\n"));
 132         if (!initialized)
 133                 PyThread_init_thread();
 134
 135         success = pthread_create(&th,
 136 #if defined(PY_PTHREAD_D4)
 137                                  pthread_attr_default,
 138                                  (pthread_startroutine_t)func,
 139                                  (pthread_addr_t)arg
 140 #elif defined(PY_PTHREAD_D6)
 141                                  pthread_attr_default,
 142                                  (void* (*)(void *))func,
 143                                  arg
 144 #elif defined(PY_PTHREAD_D7)
 145                                  pthread_attr_default,
 146                                  func,
 147                                  arg
 148 #elif defined(PY_PTHREAD_STD)
 149                                  (pthread_attr_t*)NULL,
 150                                  (void* (*)(void *))func,
 151                                  (void *)arg
 152 #endif
 153                                  );
 154
 155         if (success == 0) {
 156 #if defined(PY_PTHREAD_D4) || defined(PY_PTHREAD_D6) || defined(PY_PTHREAD_D7)
 157                 pthread_detach(&th);
 158 #elif defined(PY_PTHREAD_STD)
 159                 pthread_detach(th);
 160 #endif
 161         }
 162         return success != 0 ? 0 : 1;
 163 }
 164
 165 /* XXX This implementation is considered (to quote Tim Peters) "inherently
 166    hosed" because:
 167      - It does not guanrantee the promise that a non-zero integer is returned.
 168      - The cast to long is inherently unsafe.
 169      - It is not clear that the 'volatile' (for AIX?) and ugly casting in the
 170        latter return statement (for Alpha OSF/1) are any longer necessary.
 171 */
 172 long
 173 PyThread_get_thread_ident(void)
 174 {
 175         volatile pthread_t threadid;
 176         if (!initialized)
 177                 PyThread_init_thread();
 178         /* Jump through some hoops for Alpha OSF/1 */
 179         threadid = pthread_self();
 180 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG
 181         return (long) threadid;
 182 #else
 183         return (long) *(long *) &threadid;
 184 #endif
 185 }
 186
 187 static void
 188 do_PyThread_exit_thread(int no_cleanup)
 189 {
 190         dprintf(("PyThread_exit_thread called\n"));
 191         if (!initialized) {
 192                 if (no_cleanup)
 193                         _exit(0);
 194                 else
 195                         exit(0);
 196         }
 197 }
 198
 199 void
 200 PyThread_exit_thread(void)
 201 {
 202         do_PyThread_exit_thread(0);
 203 }
 204
 205 void
 206 PyThread__exit_thread(void)
 207 {
 208         do_PyThread_exit_thread(1);
 209 }
 210
 211 #ifndef NO_EXIT_PROG
 212 static void
 213 do_PyThread_exit_prog(int status, int no_cleanup)
 214 {
 215         dprintf(("PyThread_exit_prog(%d) called\n", status));
 216         if (!initialized)
 217                 if (no_cleanup)
 218                         _exit(status);
 219                 else
 220                         exit(status);
 221 }
 222
 223 void
 224 PyThread_exit_prog(int status)
 225 {
 226         do_PyThread_exit_prog(status, 0);
 227 }
 228
 229 void
 230 PyThread__exit_prog(int status)
 231 {
 232         do_PyThread_exit_prog(status, 1);
 233 }
 234 #endif /* NO_EXIT_PROG */
 235
 236 /*
 237  * Lock support.
 238  */
 239 PyThread_type_lock
 240 PyThread_allocate_lock(void)
 241 {
 242         pthread_lock *lock;
 243         int status, error = 0;
 244
 245         dprintf(("PyThread_allocate_lock called\n"));
 246         if (!initialized)
 247                 PyThread_init_thread();
 248
 249         lock = (pthread_lock *) malloc(sizeof(pthread_lock));
 250         memset((void *)lock, '\0', sizeof(pthread_lock));
 251         if (lock) {
 252                 lock->locked = 0;
 253
 254                 status = pthread_mutex_init(&lock->mut,
 255                                             pthread_mutexattr_default);
 256                 CHECK_STATUS("pthread_mutex_init");
 257
 258                 status = pthread_cond_init(&lock->lock_released,
 259                                            pthread_condattr_default);
 260                 CHECK_STATUS("pthread_cond_init");
 261
 262                 if (error) {
 263                         free((void *)lock);
 264                         lock = 0;
 265                 }
 266         }
 267
 268         dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 269         return (PyThread_type_lock) lock;
 270 }
 271
 272 void
 273 PyThread_free_lock(PyThread_type_lock lock)
 274 {
 275         pthread_lock *thelock = (pthread_lock *)lock;
 276         int status, error = 0;
 277
 278         dprintf(("PyThread_free_lock(%p) called\n", lock));
 279
 280         status = pthread_mutex_destroy( &thelock->mut );
 281         CHECK_STATUS("pthread_mutex_destroy");
 282
 283         status = pthread_cond_destroy( &thelock->lock_released );
 284         CHECK_STATUS("pthread_cond_destroy");
 285
 286         free((void *)thelock);
 287 }
 288
 289 int
 290 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 291 {
 292         int success;
 293         pthread_lock *thelock = (pthread_lock *)lock;
 294         int status, error = 0;
 295
 296         dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 297
 298         status = pthread_mutex_lock( &thelock->mut );
 299         CHECK_STATUS("pthread_mutex_lock[1]");
 300         success = thelock->locked == 0;
 301         if (success) thelock->locked = 1;
 302         status = pthread_mutex_unlock( &thelock->mut );
 303         CHECK_STATUS("pthread_mutex_unlock[1]");
 304
 305         if ( !success && waitflag ) {
 306                 /* continue trying until we get the lock */
 307
 308                 /* mut must be locked by me -- part of the condition
 309                  * protocol */
 310                 status = pthread_mutex_lock( &thelock->mut );
 311                 CHECK_STATUS("pthread_mutex_lock[2]");
 312                 while ( thelock->locked ) {
 313                         status = pthread_cond_wait(&thelock->lock_released,
 314                                                    &thelock->mut);
 315                         CHECK_STATUS("pthread_cond_wait");
 316                 }
 317                 thelock->locked = 1;
 318                 status = pthread_mutex_unlock( &thelock->mut );
 319                 CHECK_STATUS("pthread_mutex_unlock[2]");
 320                 success = 1;
 321         }
 322         if (error) success = 0;
 323         dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 324         return success;
 325 }
 326
 327 void
 328 PyThread_release_lock(PyThread_type_lock lock)
 329 {
 330         pthread_lock *thelock = (pthread_lock *)lock;
 331         int status, error = 0;
 332
 333         dprintf(("PyThread_release_lock(%p) called\n", lock));
 334
 335         status = pthread_mutex_lock( &thelock->mut );
 336         CHECK_STATUS("pthread_mutex_lock[3]");
 337
 338         thelock->locked = 0;
 339
 340         status = pthread_mutex_unlock( &thelock->mut );
 341         CHECK_STATUS("pthread_mutex_unlock[3]");
 342
 343         /* wake up someone (anyone, if any) waiting on the lock */
 344         status = pthread_cond_signal( &thelock->lock_released );
 345         CHECK_STATUS("pthread_cond_signal");
 346 }
 347
 348 /*
 349  * Semaphore support.
 350  */
 351
 352 struct semaphore {
 353         pthread_mutex_t mutex;
 354         pthread_cond_t cond;
 355         int value;
 356 };
 357
 358 PyThread_type_sema
 359 PyThread_allocate_sema(int value)
 360 {
 361         struct semaphore *sema;
 362         int status, error = 0;
 363
 364         dprintf(("PyThread_allocate_sema called\n"));
 365         if (!initialized)
 366                 PyThread_init_thread();
 367
 368         sema = (struct semaphore *) malloc(sizeof(struct semaphore));
 369         if (sema != NULL) {
 370                 sema->value = value;
 371                 status = pthread_mutex_init(&sema->mutex,
 372                                             pthread_mutexattr_default);
 373                 CHECK_STATUS("pthread_mutex_init");
 374                 status = pthread_cond_init(&sema->cond,
 375                                            pthread_condattr_default);
 376                 CHECK_STATUS("pthread_cond_init");
 377                 if (error) {
 378                         free((void *) sema);
 379                         sema = NULL;
 380                 }
 381         }
 382         dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
 383         return (PyThread_type_sema) sema;
 384 }
 385
 386 void
 387 PyThread_free_sema(PyThread_type_sema sema)
 388 {
 389         int status, error = 0;
 390         struct semaphore *thesema = (struct semaphore *) sema;
 391
 392         dprintf(("PyThread_free_sema(%p) called\n",  sema));
 393         status = pthread_cond_destroy(&thesema->cond);
 394         CHECK_STATUS("pthread_cond_destroy");
 395         status = pthread_mutex_destroy(&thesema->mutex);
 396         CHECK_STATUS("pthread_mutex_destroy");
 397         free((void *) thesema);
 398 }
 399
 400 int
 401 PyThread_down_sema(PyThread_type_sema sema, int waitflag)
 402 {
 403         int status, error = 0, success;
 404         struct semaphore *thesema = (struct semaphore *) sema;
 405
 406         dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));
 407         status = pthread_mutex_lock(&thesema->mutex);
 408         CHECK_STATUS("pthread_mutex_lock");
 409         if (waitflag) {
 410                 while (!error && thesema->value <= 0) {
 411                         status = pthread_cond_wait(&thesema->cond,
 412                                                    &thesema->mutex);
 413                         CHECK_STATUS("pthread_cond_wait");
 414                 }
 415         }
 416         if (error)
 417                 success = 0;
 418         else if (thesema->value > 0) {
 419                 thesema->value--;
 420                 success = 1;
 421         }
 422         else
 423                 success = 0;
 424         status = pthread_mutex_unlock(&thesema->mutex);
 425         CHECK_STATUS("pthread_mutex_unlock");
 426         dprintf(("PyThread_down_sema(%p) return\n",  sema));
 427         return success;
 428 }
 429
 430 void
 431 PyThread_up_sema(PyThread_type_sema sema)
 432 {
 433         int status, error = 0;
 434         struct semaphore *thesema = (struct semaphore *) sema;
 435
 436         dprintf(("PyThread_up_sema(%p)\n",  sema));
 437         status = pthread_mutex_lock(&thesema->mutex);
 438         CHECK_STATUS("pthread_mutex_lock");
 439         thesema->value++;
 440         status = pthread_cond_signal(&thesema->cond);
 441         CHECK_STATUS("pthread_cond_signal");
 442         status = pthread_mutex_unlock(&thesema->mutex);
 443         CHECK_STATUS("pthread_mutex_unlock");
 444 }