Implement the GIL with critical sections in Windows

Python/thread_nt.h

 
 /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */
 /* Fast NonRecursiveMutex support by Yakov Markovitch, markovitch@iso.ru */
 /* Eliminated some memory leaks, gsw@agere.com */
+/* EXPERIMENTAL critical section & semaphore code by Phillip Sitbon, phillip@sitbon.net */
 
 #include <windows.h>
 #include <limits.h>
 #ifdef HAVE_PROCESS_H
 #include <process.h>
 #endif
 
-typedef struct NRMUTEX {
+#define WITH_CRITICAL_SECTION_LOCKING_BREAKING_THREAD_LOCKS
+/* #define WITH_SEMAPHORE_LOCKING */
+
+#ifdef WITH_CRITICAL_SECTION_LOCKING_BREAKING_THREAD_LOCKS
+  /* Implement locking as a pseudo-recursive critical section */
+
+typedef CRITICAL_SECTION NTMUTEX;
+typedef LPCRITICAL_SECTION PNTMUTEX;
+
+BOOL
+InitializeNtMutex(PNTMUTEX mutex)
+{
+        InitializeCriticalSection(mutex);
+        /* Spin mutex would be: InitializeCriticalSectionAndSpinCount(mutex, SpinCount#); */
+        return TRUE; /* failure is a segfault for this function */
+}
+
+VOID
+DeleteNtMutex(PNTMUTEX mutex)
+{
+        /* ideally would set the pointer to zero here, might be a good reason to
+           encapsulate CRITICAL_SECTION */
+        DeleteCriticalSection(mutex);
+}
+
+
+DWORD
+EnterNtMutex(PNTMUTEX mutex, BOOL wait)
+{
+        const DWORD ThisThread = GetCurrentThreadId();
+
+        /*
+          We can only effectively disallow recursion when the
+          caller doesn't want to wait. There are two other options
+          in the presence of recursion:
+          (1) allow recursion no matter what, or
+          (2) force a deadlock (i.e. acquire an unused semaphore).
+        
+          Option 1 breaks code that does sanity checks assuming that
+          we can't lock it if we own it already without blocking.
+          Option 2 preserves semantics, but is not desirable.
+
+          The solution here disallows recursion when wait == 0, and
+          silently allows it otherwise.
+        */
+
+        if ( !wait )
+        {
+                /* warning: using NT internals. this value is always the thread id,
+                   but we are bypassing the opaqueness of CRITICAL_SECTION */
+                if ( ((DWORD)(mutex->OwningThread) == ThisThread) ||
+                     (TryEnterCriticalSection(mutex) == FALSE) ) /* try to acquire if not owner */
+                        return WAIT_TIMEOUT; /* recursion or unavailable */
+        }
+        else /* wait always passed as INFINITE anyway, so ignore it */
+                EnterCriticalSection(mutex);
+
+        return WAIT_OBJECT_0;
+}
+
+BOOL
+LeaveNtMutex(PNTMUTEX mutex)
+{
+        /* It might be important here to fail if a thread not owning this object
+           tries to release it. It will work with events AFAIK, but not critical
+           sections.
+        */
+        LeaveCriticalSection(mutex);
+        return TRUE;
+}
+
+#elif defined(WITH_SEMAPHORE_LOCKING)
+  /* Implement locking as a semaphore */
+
+typedef HANDLE NTMUTEX;
+typedef LPHANDLE PNTMUTEX;
+
+BOOL
+InitializeNtMutex(PNTMUTEX mutex)
+{
+        *mutex = CreateSemaphore(NULL, 1, LONG_MAX, NULL);
+        return *mutex != NULL;
+}
+
+VOID
+DeleteNtMutex(PNTMUTEX mutex)
+{
+        CloseHandle(*mutex);
+}
+
+
+DWORD
+EnterNtMutex(PNTMUTEX mutex, DWORD wait) /* second parameter type changed to DWORD */
+{
+        return WaitForSingleObject(*mutex, wait);
+}
+
+BOOL
+LeaveNtMutex(PNTMUTEX mutex)
+{
+        return ReleaseSemaphore(*mutex, 1, NULL);
+}
+
+#else /* Use an event-based non-recursive mutex */
+
+typedef struct NTMUTEX {
         LONG   owned ;
         DWORD  thread_id ;
         HANDLE hevent ;
-} NRMUTEX, *PNRMUTEX ;
+} NTMUTEX, *PNTMUTEX ;
 
 
 BOOL
-InitializeNonRecursiveMutex(PNRMUTEX mutex)
+InitializeNtMutex(PNTMUTEX mutex)
 {
         mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
         mutex->thread_id = 0 ;
         mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
         return mutex->hevent != NULL ;  /* TRUE if the mutex is created */
 }
 
 VOID
-DeleteNonRecursiveMutex(PNRMUTEX mutex)
+DeleteNtMutex(PNTMUTEX mutex)
 {
         /* No in-use check */
         CloseHandle(mutex->hevent) ;
         mutex->hevent = NULL ; /* Just in case */
 }
 
 DWORD
-EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
+EnterNtMutex(PNTMUTEX mutex, BOOL wait)
 {
         /* Assume that the thread waits successfully */
         DWORD ret ;
 
         /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
         if (!wait)
         {
                 if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
                         return WAIT_TIMEOUT ;
                 ret = WAIT_OBJECT_0 ;
         }
         else
                 ret = InterlockedIncrement(&mutex->owned) ?
                         /* Some thread owns the mutex, let's wait... */
                         WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
 
         mutex->thread_id = GetCurrentThreadId() ; /* We own it */
         return ret ;
 }
 
 BOOL
-LeaveNonRecursiveMutex(PNRMUTEX mutex)
+LeaveNtMutex(PNTMUTEX mutex)
 {
         /* We don't own the mutex */
         mutex->thread_id = 0 ;
         return
                 InterlockedDecrement(&mutex->owned) < 0 ||
                 SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
 }
 
-PNRMUTEX
-AllocNonRecursiveMutex(void)
+#endif /* WITH_CRITICAL_SECTION_GIL */
+
+
+PNTMUTEX
+AllocNtMutex(void)
 {
-        PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
-        if (mutex && !InitializeNonRecursiveMutex(mutex))
+        PNTMUTEX mutex = (PNTMUTEX)malloc(sizeof(NTMUTEX)) ;
+        if (mutex && !InitializeNtMutex(mutex))
         {
                 free(mutex) ;
                 mutex = NULL ;
         }
         return mutex ;
 }
 
 void
-FreeNonRecursiveMutex(PNRMUTEX mutex)
+FreeNtMutex(PNTMUTEX mutex)
 {
         if (mutex)
         {
-                DeleteNonRecursiveMutex(mutex) ;
+                DeleteNtMutex(mutex) ;
                 free(mutex) ;
         }
 }
 
 long PyThread_get_thread_ident(void);
 
 /*
  * Initialization of the C package, should not be needed.
  */
 static void
@@ skipping 110 matching lines @@
 #ifndef NO_EXIT_PROG
 void
 PyThread_exit_prog(int status)
 {
         dprintf(("PyThread_exit_prog(%d) called\n", status));
         if (!initialized)
                 exit(status);
 }
 #endif /* NO_EXIT_PROG */
 
-/*
- * Lock support. It has too be implemented as semaphores.
- * I [Dag] tried to implement it with mutex but I could find a way to
- * tell whether a thread already own the lock or not.
- */
 PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-        PNRMUTEX aLock;
+        PNTMUTEX aLock;
 
         dprintf(("PyThread_allocate_lock called\n"));
         if (!initialized)
                 PyThread_init_thread();
 
-        aLock = AllocNonRecursiveMutex() ;
+        aLock = AllocNtMutex() ;
 
         dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 
         return (PyThread_type_lock) aLock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock aLock)
 {
         dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-        FreeNonRecursiveMutex(aLock) ;
+        FreeNtMutex(aLock) ;
 }
 
 /*
  * Return 1 on success if the lock was acquired
  *
  * and 0 if the lock was not acquired. This means a 0 is returned
  * if the lock has already been acquired by this thread!
  */
 int
 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 {
         int success ;
 
         dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
 
-        success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
+        success = aLock && EnterNtMutex((PNTMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
 
         dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 
         return success;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock aLock)
 {
         dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-        if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
+        if (!(aLock && LeaveNtMutex((PNTMUTEX) aLock)))
                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 }
 
 /* minimum/maximum thread stack sizes supported */
 #define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
 #define THREAD_MAX_STACKSIZE    0x10000000      /* 256MB */
 
 /* set the thread stack size.
  * Return 0 if size is valid, -1 otherwise.
  */
@@ skipping 79 matching lines @@
 }
 
 /* reinitialization of TLS is not necessary after fork when using
  * the native TLS functions.  And forking isn't supported on Windows either.
  */
 void
 PyThread_ReInitTLS(void)
 {}
 
 #endif