Python/thread_nt.h

   1
   2 /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */
   3 /* Fast NonRecursiveMutex support by Yakov Markovitch, markovitch@iso.ru */
   4 /* Eliminated some memory leaks, gsw@agere.com */
   5
   6 #include <windows.h>
   7 #include <limits.h>
   8 #include <process.h>
   9
  10 typedef struct NRMUTEX {
  11         LONG   owned ;
  12         DWORD  thread_id ;
  13         HANDLE hevent ;
  14 } NRMUTEX, *PNRMUTEX ;
  15
  16 typedef PVOID WINAPI interlocked_cmp_xchg_t(PVOID *dest, PVOID exc, PVOID comperand) ;
  17
  18 /* Sorry mate, but we haven't got InterlockedCompareExchange in Win95! */
  19 static PVOID WINAPI interlocked_cmp_xchg(PVOID *dest, PVOID exc, PVOID comperand)
  20 {
  21         static LONG spinlock = 0 ;
  22         PVOID result ;
  23         DWORD dwSleep = 0;
  24
  25         /* Acqire spinlock (yielding control to other threads if cant aquire for the moment) */
  26         while(InterlockedExchange(&spinlock, 1))
  27         {
  28                 // Using Sleep(0) can cause a priority inversion.
  29                 // Sleep(0) only yields the processor if there's
  30                 // another thread of the same priority that's
  31                 // ready to run.  If a high-priority thread is
  32                 // trying to acquire the lock, which is held by
  33                 // a low-priority thread, then the low-priority
  34                 // thread may never get scheduled and hence never
  35                 // free the lock.  NT attempts to avoid priority
  36                 // inversions by temporarily boosting the priority
  37                 // of low-priority runnable threads, but the problem
  38                 // can still occur if there's a medium-priority
  39                 // thread that's always runnable.  If Sleep(1) is used,
  40                 // then the thread unconditionally yields the CPU.  We
  41                 // only do this for the second and subsequent even
  42                 // iterations, since a millisecond is a long time to wait
  43                 // if the thread can be scheduled in again sooner
  44                 // (~100,000 instructions).
  45                 // Avoid priority inversion: 0, 1, 0, 1,...
  46                 Sleep(dwSleep);
  47                 dwSleep = !dwSleep;
  48         }
  49         result = *dest ;
  50         if (result == comperand)
  51                 *dest = exc ;
  52         /* Release spinlock */
  53         spinlock = 0 ;
  54         return result ;
  55 } ;
  56
  57 static interlocked_cmp_xchg_t *ixchg ;
  58 BOOL InitializeNonRecursiveMutex(PNRMUTEX mutex)
  59 {
  60         if (!ixchg)
  61         {
  62                 /* Sorely, Win95 has no InterlockedCompareExchange API (Win98 has), so we have to use emulation */
  63                 HANDLE kernel = GetModuleHandle("kernel32.dll") ;
  64                 if (!kernel || (ixchg = (interlocked_cmp_xchg_t *)GetProcAddress(kernel, "InterlockedCompareExchange")) == NULL)
  65                         ixchg = interlocked_cmp_xchg ;
  66         }
  67
  68         mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
  69         mutex->thread_id = 0 ;
  70         mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
  71         return mutex->hevent != NULL ;  /* TRUE if the mutex is created */
  72 }
  73
  74 #ifdef InterlockedCompareExchange
  75 #undef InterlockedCompareExchange
  76 #endif
  77 #define InterlockedCompareExchange(dest,exchange,comperand) (ixchg((dest), (exchange), (comperand)))
  78
  79 VOID DeleteNonRecursiveMutex(PNRMUTEX mutex)
  80 {
  81         /* No in-use check */
  82         CloseHandle(mutex->hevent) ;
  83         mutex->hevent = NULL ; /* Just in case */
  84 }
  85
  86 DWORD EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
  87 {
  88         /* Assume that the thread waits successfully */
  89         DWORD ret ;
  90
  91         /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
  92         if (!wait)
  93         {
  94                 if (InterlockedCompareExchange((PVOID *)&mutex->owned, (PVOID)0, (PVOID)-1) != (PVOID)-1)
  95                         return WAIT_TIMEOUT ;
  96                 ret = WAIT_OBJECT_0 ;
  97         }
  98         else
  99                 ret = InterlockedIncrement(&mutex->owned) ?
 100                         /* Some thread owns the mutex, let's wait... */
 101                         WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
 102
 103         mutex->thread_id = GetCurrentThreadId() ; /* We own it */
 104         return ret ;
 105 }
 106
 107 BOOL LeaveNonRecursiveMutex(PNRMUTEX mutex)
 108 {
 109         /* We don't own the mutex */
 110         mutex->thread_id = 0 ;
 111         return
 112                 InterlockedDecrement(&mutex->owned) < 0 ||
 113                 SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
 114 }
 115
 116 PNRMUTEX AllocNonRecursiveMutex(void)
 117 {
 118         PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
 119         if (mutex && !InitializeNonRecursiveMutex(mutex))
 120         {
 121                 free(mutex) ;
 122                 mutex = NULL ;
 123         }
 124         return mutex ;
 125 }
 126
 127 void FreeNonRecursiveMutex(PNRMUTEX mutex)
 128 {
 129         if (mutex)
 130         {
 131                 DeleteNonRecursiveMutex(mutex) ;
 132                 free(mutex) ;
 133         }
 134 }
 135
 136 long PyThread_get_thread_ident(void);
 137
 138 /*
 139  * Initialization of the C package, should not be needed.
 140  */
 141 static void PyThread__init_thread(void)
 142 {
 143 }
 144
 145 /*
 146  * Thread support.
 147  */
 148
 149 typedef struct {
 150         void (*func)(void*);
 151         void *arg;
 152         long id;
 153         HANDLE done;
 154 } callobj;
 155
 156 static int
 157 bootstrap(void *call)
 158 {
 159         callobj *obj = (callobj*)call;
 160         /* copy callobj since other thread might free it before we're done */
 161         void (*func)(void*) = obj->func;
 162         void *arg = obj->arg;
 163
 164         obj->id = PyThread_get_thread_ident();
 165         ReleaseSemaphore(obj->done, 1, NULL);
 166         func(arg);
 167         return 0;
 168 }
 169
 170 long
 171 PyThread_start_new_thread(void (*func)(void *), void *arg)
 172 {
 173         uintptr_t rv;
 174         callobj obj;
 175
 176         dprintf(("%ld: PyThread_start_new_thread called\n",
 177                  PyThread_get_thread_ident()));
 178         if (!initialized)
 179                 PyThread_init_thread();
 180
 181         obj.id = -1;    /* guilty until proved innocent */
 182         obj.func = func;
 183         obj.arg = arg;
 184         obj.done = CreateSemaphore(NULL, 0, 1, NULL);
 185         if (obj.done == NULL)
 186                 return -1;
 187
 188         rv = _beginthread(bootstrap, 0, &obj); /* use default stack size */
 189         if (rv == (uintptr_t)-1) {
 190                 /* I've seen errno == EAGAIN here, which means "there are
 191                  * too many threads".
 192                  */
 193                 dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",
 194                          PyThread_get_thread_ident(), rv, errno));
 195                 obj.id = -1;
 196         }
 197         else {
 198                 dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
 199                          PyThread_get_thread_ident(), rv));
 200                 /* wait for thread to initialize, so we can get its id */
 201                 WaitForSingleObject(obj.done, INFINITE);
 202                 assert(obj.id != -1);
 203         }
 204         CloseHandle((HANDLE)obj.done);
 205         return obj.id;
 206 }
 207
 208 /*
 209  * Return the thread Id instead of an handle. The Id is said to uniquely identify the
 210  * thread in the system
 211  */
 212 long PyThread_get_thread_ident(void)
 213 {
 214         if (!initialized)
 215                 PyThread_init_thread();
 216
 217         return GetCurrentThreadId();
 218 }
 219
 220 static void do_PyThread_exit_thread(int no_cleanup)
 221 {
 222         dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
 223         if (!initialized)
 224                 if (no_cleanup)
 225                         _exit(0);
 226                 else
 227                         exit(0);
 228         _endthread();
 229 }
 230
 231 void PyThread_exit_thread(void)
 232 {
 233         do_PyThread_exit_thread(0);
 234 }
 235
 236 void PyThread__exit_thread(void)
 237 {
 238         do_PyThread_exit_thread(1);
 239 }
 240
 241 #ifndef NO_EXIT_PROG
 242 static void do_PyThread_exit_prog(int status, int no_cleanup)
 243 {
 244         dprintf(("PyThread_exit_prog(%d) called\n", status));
 245         if (!initialized)
 246                 if (no_cleanup)
 247                         _exit(status);
 248                 else
 249                         exit(status);
 250 }
 251
 252 void PyThread_exit_prog(int status)
 253 {
 254         do_PyThread_exit_prog(status, 0);
 255 }
 256
 257 void PyThread__exit_prog(int status)
 258 {
 259         do_PyThread_exit_prog(status, 1);
 260 }
 261 #endif /* NO_EXIT_PROG */
 262
 263 /*
 264  * Lock support. It has too be implemented as semaphores.
 265  * I [Dag] tried to implement it with mutex but I could find a way to
 266  * tell whether a thread already own the lock or not.
 267  */
 268 PyThread_type_lock PyThread_allocate_lock(void)
 269 {
 270         PNRMUTEX aLock;
 271
 272         dprintf(("PyThread_allocate_lock called\n"));
 273         if (!initialized)
 274                 PyThread_init_thread();
 275
 276         aLock = AllocNonRecursiveMutex() ;
 277
 278         dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 279
 280         return (PyThread_type_lock) aLock;
 281 }
 282
 283 void PyThread_free_lock(PyThread_type_lock aLock)
 284 {
 285         dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 286
 287         FreeNonRecursiveMutex(aLock) ;
 288 }
 289
 290 /*
 291  * Return 1 on success if the lock was acquired
 292  *
 293  * and 0 if the lock was not acquired. This means a 0 is returned
 294  * if the lock has already been acquired by this thread!
 295  */
 296 int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 297 {
 298         int success ;
 299
 300         dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
 301
 302         success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
 303
 304         dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 305
 306         return success;
 307 }
 308
 309 void PyThread_release_lock(PyThread_type_lock aLock)
 310 {
 311         dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 312
 313         if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
 314                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 315 }