Python/thread_nt.h

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