Python/thread_os2.h

   1 /* This code implemented by cvale@netcom.com */
   2
   3 #define INCL_DOSPROCESS
   4 #define INCL_DOSSEMAPHORES
   5 #include "os2.h"
   6 #include "limits.h"
   7
   8 #include "process.h"
   9
  10 #if defined(PYCC_GCC)
  11 #include <sys/builtin.h>
  12 #include <sys/fmutex.h>
  13 #else
  14 long PyThread_get_thread_ident(void);
  15 #endif
  16
  17 #if !defined(THREAD_STACK_SIZE)
  18 #define THREAD_STACK_SIZE       0x10000
  19 #endif
  20
  21 /*
  22  * Initialization of the C package, should not be needed.
  23  */
  24 static void
  25 PyThread__init_thread(void)
  26 {
  27 }
  28
  29 /*
  30  * Thread support.
  31  */
  32 long
  33 PyThread_start_new_thread(void (*func)(void *), void *arg)
  34 {
  35         int aThread;
  36         int success = 0;
  37
  38         aThread = _beginthread(func, NULL, THREAD_STACK_SIZE, arg);
  39
  40         if (aThread == -1) {
  41                 success = -1;
  42                 fprintf(stderr, "aThread failed == %d", aThread);
  43                 dprintf(("_beginthread failed. return %ld\n", errno));
  44         }
  45
  46         return success;
  47 }
  48
  49 long
  50 PyThread_get_thread_ident(void)
  51 {
  52 #if !defined(PYCC_GCC)
  53         PPIB pib;
  54         PTIB tib;
  55 #endif
  56
  57         if (!initialized)
  58                 PyThread_init_thread();
  59
  60 #if defined(PYCC_GCC)
  61         return _gettid();
  62 #else
  63         DosGetInfoBlocks(&tib, &pib);
  64         return tib->tib_ptib2->tib2_ultid;
  65 #endif
  66 }
  67
  68 static void
  69 do_PyThread_exit_thread(int no_cleanup)
  70 {
  71         dprintf(("%ld: PyThread_exit_thread called\n",
  72                  PyThread_get_thread_ident()));
  73         if (!initialized)
  74                 if (no_cleanup)
  75                         _exit(0);
  76                 else
  77                         exit(0);
  78         _endthread();
  79 }
  80
  81 void
  82 PyThread_exit_thread(void)
  83 {
  84         do_PyThread_exit_thread(0);
  85 }
  86
  87 void
  88 PyThread__exit_thread(void)
  89 {
  90         do_PyThread_exit_thread(1);
  91 }
  92
  93 #ifndef NO_EXIT_PROG
  94 static void
  95 do_PyThread_exit_prog(int status, int no_cleanup)
  96 {
  97         dprintf(("PyThread_exit_prog(%d) called\n", status));
  98         if (!initialized)
  99                 if (no_cleanup)
 100                         _exit(status);
 101                 else
 102                         exit(status);
 103 }
 104
 105 void
 106 PyThread_exit_prog(int status)
 107 {
 108         do_PyThread_exit_prog(status, 0);
 109 }
 110
 111 void
 112 PyThread__exit_prog(int status)
 113 {
 114         do_PyThread_exit_prog(status, 1);
 115 }
 116 #endif /* NO_EXIT_PROG */
 117
 118 /*
 119  * Lock support.  This is implemented with an event semaphore and critical
 120  * sections to make it behave more like a posix mutex than its OS/2
 121  * counterparts.
 122  */
 123
 124 typedef struct os2_lock_t {
 125         int is_set;
 126         HEV changed;
 127 } *type_os2_lock;
 128
 129 PyThread_type_lock
 130 PyThread_allocate_lock(void)
 131 {
 132 #if defined(PYCC_GCC)
 133         _fmutex *sem = malloc(sizeof(_fmutex));
 134         if (!initialized)
 135                 PyThread_init_thread();
 136         dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
 137                  PyThread_get_thread_ident(),
 138                  (long)sem));
 139         if (_fmutex_create(sem, 0)) {
 140                 free(sem);
 141                 sem = NULL;
 142         }
 143         return (PyThread_type_lock)sem;
 144 #else
 145         APIRET rc;
 146         type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
 147
 148         dprintf(("PyThread_allocate_lock called\n"));
 149         if (!initialized)
 150                 PyThread_init_thread();
 151
 152         lock->is_set = 0;
 153
 154         DosCreateEventSem(NULL, &lock->changed, 0, 0);
 155
 156         dprintf(("%ld: PyThread_allocate_lock() -> %p\n",
 157                  PyThread_get_thread_ident(),
 158                  lock->changed));
 159
 160         return (PyThread_type_lock)lock;
 161 #endif
 162 }
 163
 164 void
 165 PyThread_free_lock(PyThread_type_lock aLock)
 166 {
 167 #if !defined(PYCC_GCC)
 168         type_os2_lock lock = (type_os2_lock)aLock;
 169 #endif
 170
 171         dprintf(("%ld: PyThread_free_lock(%p) called\n",
 172                  PyThread_get_thread_ident(),aLock));
 173
 174 #if defined(PYCC_GCC)
 175         if (aLock) {
 176                 _fmutex_close((_fmutex *)aLock);
 177                 free((_fmutex *)aLock);
 178         }
 179 #else
 180         DosCloseEventSem(lock->changed);
 181         free(aLock);
 182 #endif
 183 }
 184
 185 /*
 186  * Return 1 on success if the lock was acquired
 187  *
 188  * and 0 if the lock was not acquired.
 189  */
 190 int
 191 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 192 {
 193 #if !defined(PYCC_GCC)
 194         int   done = 0;
 195         ULONG count;
 196         PID   pid = 0;
 197         TID   tid = 0;
 198         type_os2_lock lock = (type_os2_lock)aLock;
 199 #endif
 200
 201         dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
 202                  PyThread_get_thread_ident(),
 203                  aLock,
 204                  waitflag));
 205
 206 #if defined(PYCC_GCC)
 207         /* always successful if the lock doesn't exist */
 208         if (aLock &&
 209             _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
 210                 return 0;
 211 #else
 212         while (!done) {
 213                 /* if the lock is currently set, we have to wait for
 214                  * the state to change
 215                  */
 216                 if (lock->is_set) {
 217                         if (!waitflag)
 218                                 return 0;
 219                         DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
 220                 }
 221
 222                 /* enter a critical section and try to get the semaphore.  If
 223                  * it is still locked, we will try again.
 224                  */
 225                 if (DosEnterCritSec())
 226                         return 0;
 227
 228                 if (!lock->is_set) {
 229                         lock->is_set = 1;
 230                         DosResetEventSem(lock->changed, &count);
 231                         done = 1;
 232                 }
 233
 234                 DosExitCritSec();
 235         }
 236 #endif
 237
 238         return 1;
 239 }
 240
 241 void PyThread_release_lock(PyThread_type_lock aLock)
 242 {
 243 #if !defined(PYCC_GCC)
 244         type_os2_lock lock = (type_os2_lock)aLock;
 245 #endif
 246
 247         dprintf(("%ld: PyThread_release_lock(%p) called\n",
 248                  PyThread_get_thread_ident(),
 249                  aLock));
 250
 251 #if defined(PYCC_GCC)
 252         if (aLock)
 253                 _fmutex_release((_fmutex *)aLock);
 254 #else
 255         if (!lock->is_set) {
 256                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
 257                          PyThread_get_thread_ident(),
 258                          aLock,
 259                          GetLastError()));
 260                 return;
 261         }
 262
 263         if (DosEnterCritSec()) {
 264                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
 265                          PyThread_get_thread_ident(),
 266                          aLock,
 267                          GetLastError()));
 268                 return;
 269         }
 270
 271         lock->is_set = 0;
 272         DosPostEventSem(lock->changed);
 273
 274         DosExitCritSec();
 275 #endif
 276 }