Changeset 391 for python/trunk/Python/thread_nt.h

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Python/thread_nt.h (modified) (16 diffs)

python/trunk/Python/thread_nt.h

@@ -11 +11 @@
 
 typedef struct NRMUTEX {
-        LONG   owned ;
-        DWORD  thread_id ;
-        HANDLE hevent ;
+    LONG   owned ;
+    DWORD  thread_id ;
+    HANDLE hevent ;
 } NRMUTEX, *PNRMUTEX ;
 
@@ -20 +20 @@
 InitializeNonRecursiveMutex(PNRMUTEX 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 */
+    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 */
 }
 
@@ -29 +29 @@
 DeleteNonRecursiveMutex(PNRMUTEX mutex)
 {
-        /* No in-use check */
-        CloseHandle(mutex->hevent) ;
-        mutex->hevent = NULL ; /* Just in case */
+    /* No in-use check */
+    CloseHandle(mutex->hevent) ;
+    mutex->hevent = NULL ; /* Just in case */
 }
 
@@ -37 +37 @@
 EnterNonRecursiveMutex(PNRMUTEX 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 ;
+    /* 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 ;
 }
 
@@ -59 +59 @@
 LeaveNonRecursiveMutex(PNRMUTEX 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 */
+    /* 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 */
 }
 
@@ -69 +69 @@
 AllocNonRecursiveMutex(void)
 {
-        PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
-        if (mutex && !InitializeNonRecursiveMutex(mutex))
-        {
-                free(mutex) ;
-                mutex = NULL ;
-        }
-        return mutex ;
+    PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
+    if (mutex && !InitializeNonRecursiveMutex(mutex))
+    {
+        free(mutex) ;
+        mutex = NULL ;
+    }
+    return mutex ;
 }
 
@@ -81 +81 @@
 FreeNonRecursiveMutex(PNRMUTEX mutex)
 {
-        if (mutex)
-        {
-                DeleteNonRecursiveMutex(mutex) ;
-                free(mutex) ;
-        }
+    if (mutex)
+    {
+        DeleteNonRecursiveMutex(mutex) ;
+        free(mutex) ;
+    }
 }
 
@@ -103 +103 @@
 
 typedef struct {
-        void (*func)(void*);
-        void *arg;
-        long id;
-        HANDLE done;
+    void (*func)(void*);
+    void *arg;
 } callobj;
 
-static int
+/* thunker to call adapt between the function type used by the system's
+thread start function and the internally used one. */
+#if defined(MS_WINCE)
+static DWORD WINAPI
+#else
+static unsigned __stdcall
+#endif
 bootstrap(void *call)
 {
-        callobj *obj = (callobj*)call;
-        /* copy callobj since other thread might free it before we're done */
-        void (*func)(void*) = obj->func;
-        void *arg = obj->arg;
-
-        obj->id = PyThread_get_thread_ident();
-        ReleaseSemaphore(obj->done, 1, NULL);
-        func(arg);
-        return 0;
+    callobj *obj = (callobj*)call;
+    void (*func)(void*) = obj->func;
+    void *arg = obj->arg;
+    HeapFree(GetProcessHeap(), 0, obj);
+    func(arg);
+    return 0;
 }
 
@@ -126 +127 @@
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-        Py_uintptr_t rv;
-        callobj obj;
-
-        dprintf(("%ld: PyThread_start_new_thread called\n",
-                 PyThread_get_thread_ident()));
-        if (!initialized)
-                PyThread_init_thread();
-
-        obj.id = -1;    /* guilty until proved innocent */
-        obj.func = func;
-        obj.arg = arg;
-        obj.done = CreateSemaphore(NULL, 0, 1, NULL);
-        if (obj.done == NULL)
-                return -1;
-
-        rv = _beginthread(bootstrap,
-                          Py_SAFE_DOWNCAST(_pythread_stacksize,
-                                           Py_ssize_t, int),
-                          &obj);
-        if (rv == (Py_uintptr_t)-1) {
-                /* I've seen errno == EAGAIN here, which means "there are
-                 * too many threads".
-                 */
-                dprintf(("%ld: PyThread_start_new_thread failed: %p errno %d\n",
-                         PyThread_get_thread_ident(), (void*)rv, errno));
-                obj.id = -1;
-        }
-        else {
-                dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
-                         PyThread_get_thread_ident(), (void*)rv));
-                /* wait for thread to initialize, so we can get its id */
-                WaitForSingleObject(obj.done, INFINITE);
-                assert(obj.id != -1);
-        }
-        CloseHandle((HANDLE)obj.done);
-        return obj.id;
+    HANDLE hThread;
+    unsigned threadID;
+    callobj *obj;
+
+    dprintf(("%ld: PyThread_start_new_thread called\n",
+             PyThread_get_thread_ident()));
+    if (!initialized)
+        PyThread_init_thread();
+
+    obj = (callobj*)HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
+    if (!obj)
+        return -1;
+    obj->func = func;
+    obj->arg = arg;
+#if defined(MS_WINCE)
+    hThread = CreateThread(NULL,
+                           Py_SAFE_DOWNCAST(_pythread_stacksize, Py_ssize_t, SIZE_T),
+                           bootstrap, obj, 0, &threadID);
+#else
+    hThread = (HANDLE)_beginthreadex(0,
+                      Py_SAFE_DOWNCAST(_pythread_stacksize,
+                                       Py_ssize_t, unsigned int),
+                      bootstrap, obj,
+                      0, &threadID);
+#endif
+    if (hThread == 0) {
+#if defined(MS_WINCE)
+        /* Save error in variable, to prevent PyThread_get_thread_ident
+           from clobbering it. */
+        unsigned e = GetLastError();
+        dprintf(("%ld: PyThread_start_new_thread failed, win32 error code %u\n",
+                 PyThread_get_thread_ident(), e));
+#else
+        /* I've seen errno == EAGAIN here, which means "there are
+         * too many threads".
+         */
+        int e = errno;
+        dprintf(("%ld: PyThread_start_new_thread failed, errno %d\n",
+                 PyThread_get_thread_ident(), e));
+#endif
+        threadID = (unsigned)-1;
+        HeapFree(GetProcessHeap(), 0, obj);
+    }
+    else {
+        dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
+                 PyThread_get_thread_ident(), (void*)hThread));
+        CloseHandle(hThread);
+    }
+    return (long) threadID;
 }
 
@@ -171 +185 @@
 PyThread_get_thread_ident(void)
 {
-        if (!initialized)
-                PyThread_init_thread();
-
-        return GetCurrentThreadId();
-}
-
-static void
-do_PyThread_exit_thread(int no_cleanup)
-{
-        dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
-        if (!initialized)
-                if (no_cleanup)
-                        _exit(0);
-                else
-                        exit(0);
-        _endthread();
+    if (!initialized)
+        PyThread_init_thread();
+
+    return GetCurrentThreadId();
 }
 
@@ -192 +194 @@
 PyThread_exit_thread(void)
 {
-        do_PyThread_exit_thread(0);
-}
-
-void
-PyThread__exit_thread(void)
-{
-        do_PyThread_exit_thread(1);
-}
-
-#ifndef NO_EXIT_PROG
-static void
-do_PyThread_exit_prog(int status, int no_cleanup)
-{
-        dprintf(("PyThread_exit_prog(%d) called\n", status));
-        if (!initialized)
-                if (no_cleanup)
-                        _exit(status);
-                else
-                        exit(status);
-}
-
-void
-PyThread_exit_prog(int status)
-{
-        do_PyThread_exit_prog(status, 0);
-}
-
-void
-PyThread__exit_prog(int status)
-{
-        do_PyThread_exit_prog(status, 1);
-}
-#endif /* NO_EXIT_PROG */
+    dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
+#if defined(MS_WINCE)
+    ExitThread(0);
+#else
+    _endthreadex(0);
+#endif
+}
 
 /*
@@ -234 +212 @@
 PyThread_allocate_lock(void)
 {
-        PNRMUTEX aLock;
-
-        dprintf(("PyThread_allocate_lock called\n"));
-        if (!initialized)
-                PyThread_init_thread();
-
-        aLock = AllocNonRecursiveMutex() ;
-
-        dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
-
-        return (PyThread_type_lock) aLock;
+    PNRMUTEX aLock;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    aLock = AllocNonRecursiveMutex() ;
+
+    dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
+
+    return (PyThread_type_lock) aLock;
 }
 
@@ -250 +228 @@
 PyThread_free_lock(PyThread_type_lock aLock)
 {
-        dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
-
-        FreeNonRecursiveMutex(aLock) ;
+    dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+
+    FreeNonRecursiveMutex(aLock) ;
 }
 
@@ -264 +242 @@
 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 ;
-
-        dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
-
-        return success;
+    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 ;
+
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
+
+    return success;
 }
 
@@ -278 +256 @@
 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)))
-                dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
+    dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+
+    if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) 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 */
+#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
+#define THREAD_MAX_STACKSIZE    0x10000000      /* 256MB */
 
 /* set the thread stack size.
@@ -294 +272 @@
 _pythread_nt_set_stacksize(size_t size)
 {
-        /* set to default */
-        if (size == 0) {
-                _pythread_stacksize = 0;
-                return 0;
-        }
-
-        /* valid range? */
-        if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
-                _pythread_stacksize = size;
-                return 0;
-        }
-
-        return -1;
-}
-
-#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
+
+    /* valid range? */
+    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+        _pythread_stacksize = size;
+        return 0;
+    }
+
+    return -1;
+}
+
+#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)
+
+
+/* use native Windows TLS functions */
+#define Py_HAVE_NATIVE_TLS
+
+#ifdef Py_HAVE_NATIVE_TLS
+int
+PyThread_create_key(void)
+{
+    return (int) TlsAlloc();
+}
+
+void
+PyThread_delete_key(int key)
+{
+    TlsFree(key);
+}
+
+/* We must be careful to emulate the strange semantics implemented in thread.c,
+ * where the value is only set if it hasn't been set before.
+ */
+int
+PyThread_set_key_value(int key, void *value)
+{
+    BOOL ok;
+    void *oldvalue;
+
+    assert(value != NULL);
+    oldvalue = TlsGetValue(key);
+    if (oldvalue != NULL)
+        /* ignore value if already set */
+        return 0;
+    ok = TlsSetValue(key, value);
+    if (!ok)
+        return -1;
+    return 0;
+}
+
+void *
+PyThread_get_key_value(int key)
+{
+    /* because TLS is used in the Py_END_ALLOW_THREAD macro,
+     * it is necessary to preserve the windows error state, because
+     * it is assumed to be preserved across the call to the macro.
+     * Ideally, the macro should be fixed, but it is simpler to
+     * do it here.
+     */
+    DWORD error = GetLastError();
+    void *result = TlsGetValue(key);
+    SetLastError(error);
+    return result;
+}
+
+void
+PyThread_delete_key_value(int key)
+{
+    /* NULL is used as "key missing", and it is also the default
+     * given by TlsGetValue() if nothing has been set yet.
+     */
+    TlsSetValue(key, NULL);
+}
+
+/* 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