Changeset 388 for python/vendor/current/Python/thread.c

Timestamp:

Mar 19, 2014, 11:11:30 AM (11 years ago)

Author:

dmik

Message:

python: Update vendor to 2.7.6.

File:

• python/vendor/current/Python/thread.c (modified) (15 diffs)

python/vendor/current/Python/thread.c

@@ -25 +25 @@
 
 #ifdef __sgi
-#ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.in */
+#ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.ac */
 #undef _POSIX_THREADS
 #endif
@@ -47 +47 @@
 
 /* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
-   enough of the Posix threads package is implimented to support python 
+   enough of the Posix threads package is implemented to support python
    threads.
 
@@ -65 +65 @@
 #ifdef Py_DEBUG
 static int thread_debug = 0;
-#define dprintf(args)   (void)((thread_debug & 1) && printf args)
-#define d2printf(args)  ((thread_debug & 8) && printf args)
+#define dprintf(args)   (void)((thread_debug & 1) && printf args)
+#define d2printf(args)  ((thread_debug & 8) && printf args)
 #else
 #define dprintf(args)
@@ -80 +80 @@
 {
 #ifdef Py_DEBUG
-        char *p = Py_GETENV("PYTHONTHREADDEBUG");
-
-        if (p) {
-                if (*p)
-                        thread_debug = atoi(p);
-                else
-                        thread_debug = 1;
-        }
+    char *p = Py_GETENV("PYTHONTHREADDEBUG");
+
+    if (p) {
+        if (*p)
+            thread_debug = atoi(p);
+        else
+            thread_debug = 1;
+    }
 #endif /* Py_DEBUG */
-        if (initialized)
-                return;
-        initialized = 1;
-        dprintf(("PyThread_init_thread called\n"));
-        PyThread__init_thread();
+    if (initialized)
+        return;
+    initialized = 1;
+    dprintf(("PyThread_init_thread called\n"));
+    PyThread__init_thread();
 }
 
@@ -138 +138 @@
 #endif
 
-#ifdef WINCE_THREADS
-#include "thread_wince.h"
-#endif
-
 #ifdef PLAN9_THREADS
 #include "thread_plan9.h"
@@ -160 +156 @@
 PyThread_get_stacksize(void)
 {
-        return _pythread_stacksize;
+    return _pythread_stacksize;
 }
 
@@ -166 +162 @@
    in thread_<platform>.h support changing the stack size.
    Return 0 if stack size is valid,
-          -1 if stack size value is invalid,
-          -2 if setting stack size is not supported. */
+      -1 if stack size value is invalid,
+      -2 if setting stack size is not supported. */
 int
 PyThread_set_stacksize(size_t size)
 {
 #if defined(THREAD_SET_STACKSIZE)
-        return THREAD_SET_STACKSIZE(size);
+    return THREAD_SET_STACKSIZE(size);
 #else
-        return -2;
+    return -2;
 #endif
 }
@@ -226 +222 @@
  */
 struct key {
-        /* Next record in the list, or NULL if this is the last record. */
-        struct key *next;
-
-        /* The thread id, according to PyThread_get_thread_ident(). */
-        long id;
-
-        /* The key and its associated value. */
-        int key;
-        void *value;
+    /* Next record in the list, or NULL if this is the last record. */
+    struct key *next;
+
+    /* The thread id, according to PyThread_get_thread_ident(). */
+    long id;
+
+    /* The key and its associated value. */
+    int key;
+    void *value;
 };
 
@@ -265 +261 @@
 find_key(int key, void *value)
 {
-        struct key *p, *prev_p;
-        long id = PyThread_get_thread_ident();
-
-        if (!keymutex)
-                return NULL;
-        PyThread_acquire_lock(keymutex, 1);
-        prev_p = NULL;
-        for (p = keyhead; p != NULL; p = p->next) {
-                if (p->id == id && p->key == key)
-                        goto Done;
-                /* Sanity check.  These states should never happen but if
-                 * they do we must abort.  Otherwise we'll end up spinning in
-                 * in a tight loop with the lock held.  A similar check is done
-                 * in pystate.c tstate_delete_common().  */
-                if (p == prev_p)
-                        Py_FatalError("tls find_key: small circular list(!)");
-                prev_p = p;
-                if (p->next == keyhead)
-                        Py_FatalError("tls find_key: circular list(!)");
-        }
-        if (value == NULL) {
-                assert(p == NULL);
-                goto Done;
-        }
-        p = (struct key *)malloc(sizeof(struct key));
-        if (p != NULL) {
-                p->id = id;
-                p->key = key;
-                p->value = value;
-                p->next = keyhead;
-                keyhead = p;
-        }
+    struct key *p, *prev_p;
+    long id = PyThread_get_thread_ident();
+
+    if (!keymutex)
+        return NULL;
+    PyThread_acquire_lock(keymutex, 1);
+    prev_p = NULL;
+    for (p = keyhead; p != NULL; p = p->next) {
+        if (p->id == id && p->key == key)
+            goto Done;
+        /* Sanity check.  These states should never happen but if
+         * they do we must abort.  Otherwise we'll end up spinning in
+         * in a tight loop with the lock held.  A similar check is done
+         * in pystate.c tstate_delete_common().  */
+        if (p == prev_p)
+            Py_FatalError("tls find_key: small circular list(!)");
+        prev_p = p;
+        if (p->next == keyhead)
+            Py_FatalError("tls find_key: circular list(!)");
+    }
+    if (value == NULL) {
+        assert(p == NULL);
+        goto Done;
+    }
+    p = (struct key *)malloc(sizeof(struct key));
+    if (p != NULL) {
+        p->id = id;
+        p->key = key;
+        p->value = value;
+        p->next = keyhead;
+        keyhead = p;
+    }
  Done:
-        PyThread_release_lock(keymutex);
-        return p;
+    PyThread_release_lock(keymutex);
+    return p;
 }
 
@@ -309 +305 @@
 PyThread_create_key(void)
 {
-        /* All parts of this function are wrong if it's called by multiple
-         * threads simultaneously.
-         */
-        if (keymutex == NULL)
-                keymutex = PyThread_allocate_lock();
-        return ++nkeys;
+    /* All parts of this function are wrong if it's called by multiple
+     * threads simultaneously.
+     */
+    if (keymutex == NULL)
+        keymutex = PyThread_allocate_lock();
+    return ++nkeys;
 }
 
@@ -321 +317 @@
 PyThread_delete_key(int key)
 {
-        struct key *p, **q;
-
-        PyThread_acquire_lock(keymutex, 1);
-        q = &keyhead;
-        while ((p = *q) != NULL) {
-                if (p->key == key) {
-                        *q = p->next;
-                        free((void *)p);
-                        /* NB This does *not* free p->value! */
-                }
-                else
-                        q = &p->next;
-        }
-        PyThread_release_lock(keymutex);
+    struct key *p, **q;
+
+    PyThread_acquire_lock(keymutex, 1);
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->key == key) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+        }
+        else
+            q = &p->next;
+    }
+    PyThread_release_lock(keymutex);
 }
 
@@ -346 +342 @@
 PyThread_set_key_value(int key, void *value)
 {
-        struct key *p;
-
-        assert(value != NULL);
-        p = find_key(key, value);
-        if (p == NULL)
-                return -1;
-        else
-                return 0;
+    struct key *p;
+
+    assert(value != NULL);
+    p = find_key(key, value);
+    if (p == NULL)
+        return -1;
+    else
+        return 0;
 }
 
@@ -362 +358 @@
 PyThread_get_key_value(int key)
 {
-        struct key *p = find_key(key, NULL);
-
-        if (p == NULL)
-                return NULL;
-        else
-                return p->value;
+    struct key *p = find_key(key, NULL);
+
+    if (p == NULL)
+        return NULL;
+    else
+        return p->value;
 }
 
@@ -374 +370 @@
 PyThread_delete_key_value(int key)
 {
-        long id = PyThread_get_thread_ident();
-        struct key *p, **q;
-
-        PyThread_acquire_lock(keymutex, 1);
-        q = &keyhead;
-        while ((p = *q) != NULL) {
-                if (p->key == key && p->id == id) {
-                        *q = p->next;
-                        free((void *)p);
-                        /* NB This does *not* free p->value! */
-                        break;
-                }
-                else
-                        q = &p->next;
-        }
-        PyThread_release_lock(keymutex);
+    long id = PyThread_get_thread_ident();
+    struct key *p, **q;
+
+    PyThread_acquire_lock(keymutex, 1);
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->key == key && p->id == id) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+            break;
+        }
+        else
+            q = &p->next;
+    }
+    PyThread_release_lock(keymutex);
 }
 
@@ -400 +396 @@
 PyThread_ReInitTLS(void)
 {
-        long id = PyThread_get_thread_ident();
-        struct key *p, **q;
-
-        if (!keymutex)
-                return;
-        
-        /* As with interpreter_lock in PyEval_ReInitThreads()
-           we just create a new lock without freeing the old one */
-        keymutex = PyThread_allocate_lock();
-
-        /* Delete all keys which do not match the current thread id */
-        q = &keyhead;
-        while ((p = *q) != NULL) {
-                if (p->id != id) {
-                        *q = p->next;
-                        free((void *)p);
-                        /* NB This does *not* free p->value! */
-                }
-                else
-                        q = &p->next;
-        }
+    long id = PyThread_get_thread_ident();
+    struct key *p, **q;
+
+    if (!keymutex)
+        return;
+
+    /* As with interpreter_lock in PyEval_ReInitThreads()
+       we just create a new lock without freeing the old one */
+    keymutex = PyThread_allocate_lock();
+
+    /* Delete all keys which do not match the current thread id */
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->id != id) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+        }
+        else
+            q = &p->next;
+    }
 }