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