AppPkg/Applications/Python/Python-2.7.2/Python/thread_solaris.h

   1
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <errno.h>
   5 #include </usr/include/thread.h>
   6 #undef _POSIX_THREADS
   7
   8
   9 /*
  10  * Initialization.
  11  */
  12 static void PyThread__init_thread(void)
  13 {
  14 }
  15
  16 /*
  17  * Thread support.
  18  */
  19 struct func_arg {
  20     void (*func)(void *);
  21     void *arg;
  22 };
  23
  24 static void *
  25 new_func(void *funcarg)
  26 {
  27     void (*func)(void *);
  28     void *arg;
  29
  30     func = ((struct func_arg *) funcarg)->func;
  31     arg = ((struct func_arg *) funcarg)->arg;
  32     free(funcarg);
  33     (*func)(arg);
  34     return 0;
  35 }
  36
  37
  38 long
  39 PyThread_start_new_thread(void (*func)(void *), void *arg)
  40 {
  41     thread_t tid;
  42     struct func_arg *funcarg;
  43
  44     dprintf(("PyThread_start_new_thread called\n"));
  45     if (!initialized)
  46         PyThread_init_thread();
  47     funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
  48     funcarg->func = func;
  49     funcarg->arg = arg;
  50     if (thr_create(0, 0, new_func, funcarg,
  51                    THR_DETACHED | THR_NEW_LWP, &tid)) {
  52         perror("thr_create");
  53         free((void *) funcarg);
  54         return -1;
  55     }
  56     return tid;
  57 }
  58
  59 long
  60 PyThread_get_thread_ident(void)
  61 {
  62     if (!initialized)
  63         PyThread_init_thread();
  64     return thr_self();
  65 }
  66
  67 void
  68 PyThread_exit_thread(void)
  69 {
  70     dprintf(("PyThread_exit_thread called\n"));
  71     if (!initialized)
  72         exit(0);
  73     thr_exit(0);
  74 }
  75
  76 /*
  77  * Lock support.
  78  */
  79 PyThread_type_lock
  80 PyThread_allocate_lock(void)
  81 {
  82     mutex_t *lock;
  83
  84     dprintf(("PyThread_allocate_lock called\n"));
  85     if (!initialized)
  86         PyThread_init_thread();
  87
  88     lock = (mutex_t *) malloc(sizeof(mutex_t));
  89     if (mutex_init(lock, USYNC_THREAD, 0)) {
  90         perror("mutex_init");
  91         free((void *) lock);
  92         lock = 0;
  93     }
  94     dprintf(("PyThread_allocate_lock() -> %p\n", lock));
  95     return (PyThread_type_lock) lock;
  96 }
  97
  98 void
  99 PyThread_free_lock(PyThread_type_lock lock)
 100 {
 101     dprintf(("PyThread_free_lock(%p) called\n", lock));
 102     mutex_destroy((mutex_t *) lock);
 103     free((void *) lock);
 104 }
 105
 106 int
 107 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 108 {
 109     int success;
 110
 111     dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 112     if (waitflag)
 113         success = mutex_lock((mutex_t *) lock);
 114     else
 115         success = mutex_trylock((mutex_t *) lock);
 116     if (success < 0)
 117         perror(waitflag ? "mutex_lock" : "mutex_trylock");
 118     else
 119         success = !success; /* solaris does it the other way round */
 120     dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 121     return success;
 122 }
 123
 124 void
 125 PyThread_release_lock(PyThread_type_lock lock)
 126 {
 127     dprintf(("PyThread_release_lock(%p) called\n", lock));
 128     if (mutex_unlock((mutex_t *) lock))
 129         perror("mutex_unlock");
 130 }