Python/thread_cthread.h

   1
   2 #ifdef MACH_C_THREADS
   3 #include <mach/cthreads.h>
   4 #endif
   5
   6 #ifdef HURD_C_THREADS
   7 #include <cthreads.h>
   8 #endif
   9
  10 /*
  11  * Initialization.
  12  */
  13 static void
  14 PyThread__init_thread(void)
  15 {
  16 #ifndef HURD_C_THREADS
  17         /* Roland McGrath said this should not be used since this is
  18         done while linking to threads */
  19         cthread_init();
  20 #else
  21 /* do nothing */
  22         ;
  23 #endif
  24 }
  25
  26 /*
  27  * Thread support.
  28  */
  29 long
  30 PyThread_start_new_thread(void (*func)(void *), void *arg)
  31 {
  32         int success = 0;        /* init not needed when SOLARIS_THREADS and */
  33                                 /* C_THREADS implemented properly */
  34
  35         dprintf(("PyThread_start_new_thread called\n"));
  36         if (!initialized)
  37                 PyThread_init_thread();
  38         /* looks like solaris detaches the thread to never rejoin
  39          * so well do it here
  40          */
  41         cthread_detach(cthread_fork((cthread_fn_t) func, arg));
  42         return success < 0 ? -1 : 0;
  43 }
  44
  45 long
  46 PyThread_get_thread_ident(void)
  47 {
  48         if (!initialized)
  49                 PyThread_init_thread();
  50         return (long) cthread_self();
  51 }
  52
  53 static void
  54 do_PyThread_exit_thread(int no_cleanup)
  55 {
  56         dprintf(("PyThread_exit_thread called\n"));
  57         if (!initialized)
  58                 if (no_cleanup)
  59                         _exit(0);
  60                 else
  61                         exit(0);
  62         cthread_exit(0);
  63 }
  64
  65 void
  66 PyThread_exit_thread(void)
  67 {
  68         do_PyThread_exit_thread(0);
  69 }
  70
  71 void
  72 PyThread__exit_thread(void)
  73 {
  74         do_PyThread_exit_thread(1);
  75 }
  76
  77 #ifndef NO_EXIT_PROG
  78 static
  79 void do_PyThread_exit_prog(int status, int no_cleanup)
  80 {
  81         dprintf(("PyThread_exit_prog(%d) called\n", status));
  82         if (!initialized)
  83                 if (no_cleanup)
  84                         _exit(status);
  85                 else
  86                         exit(status);
  87         if (no_cleanup)
  88                 _exit(status);
  89         else
  90                 exit(status);
  91 }
  92
  93 void
  94 PyThread_exit_prog(int status)
  95 {
  96         do_PyThread_exit_prog(status, 0);
  97 }
  98
  99 void
 100 PyThread__exit_prog(int status)
 101 {
 102         do_PyThread_exit_prog(status, 1);
 103 }
 104 #endif /* NO_EXIT_PROG */
 105
 106 /*
 107  * Lock support.
 108  */
 109 PyThread_type_lock
 110 PyThread_allocate_lock(void)
 111 {
 112         mutex_t lock;
 113
 114         dprintf(("PyThread_allocate_lock called\n"));
 115         if (!initialized)
 116                 PyThread_init_thread();
 117
 118         lock = mutex_alloc();
 119         if (mutex_init(lock)) {
 120                 perror("mutex_init");
 121                 free((void *) lock);
 122                 lock = 0;
 123         }
 124         dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 125         return (PyThread_type_lock) lock;
 126 }
 127
 128 void
 129 PyThread_free_lock(PyThread_type_lock lock)
 130 {
 131         dprintf(("PyThread_free_lock(%p) called\n", lock));
 132         mutex_free(lock);
 133 }
 134
 135 int
 136 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 137 {
 138         int success = FALSE;
 139
 140         dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 141         if (waitflag) {         /* blocking */
 142                 mutex_lock((mutex_t)lock);
 143                 success = TRUE;
 144         } else {                /* non blocking */
 145                 success = mutex_try_lock((mutex_t)lock);
 146         }
 147         dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 148         return success;
 149 }
 150
 151 void
 152 PyThread_release_lock(PyThread_type_lock lock)
 153 {
 154         dprintf(("PyThread_release_lock(%p) called\n", lock));
 155         mutex_unlock((mutex_t )lock);
 156 }