changeset:   87620:c75f7c760069
tag:         tip
user:        Victor Stinner <victor.stinner@gmail.com>
date:        Thu Nov 28 02:13:28 2013 +0100
files:       Include/pythread.h Modules/_tracemalloc.c Python/thread.c Python/thread_nt.h Python/thread_pthread.h
description:
Add _PyThread_set_key_value() function which does always set the value, whereas
PyThread_set_key_value() only sets the value if it was set before


diff -r acabd3f035fe -r c75f7c760069 Include/pythread.h
--- a/Include/pythread.h	Wed Nov 27 14:42:55 2013 -0800
+++ b/Include/pythread.h	Thu Nov 28 02:13:28 2013 +0100
@@ -79,6 +79,7 @@ PyAPI_FUNC(PyObject*) PyThread_GetInfo(v
 /* Thread Local Storage (TLS) API */
 PyAPI_FUNC(int) PyThread_create_key(void);
 PyAPI_FUNC(void) PyThread_delete_key(int);
+PyAPI_FUNC(int) _PyThread_set_key_value(int, void *);
 PyAPI_FUNC(int) PyThread_set_key_value(int, void *);
 PyAPI_FUNC(void *) PyThread_get_key_value(int);
 PyAPI_FUNC(void) PyThread_delete_key_value(int key);
diff -r acabd3f035fe -r c75f7c760069 Modules/_tracemalloc.c
--- a/Modules/_tracemalloc.c	Wed Nov 27 14:42:55 2013 -0800
+++ b/Modules/_tracemalloc.c	Thu Nov 28 02:13:28 2013 +0100
@@ -172,14 +172,11 @@ set_reentrant(int reentrant)
     assert(reentrant == 0 || reentrant == 1);
     if (reentrant) {
         assert(PyThread_get_key_value(tracemalloc_reentrant_key) == NULL);
-        PyThread_set_key_value(tracemalloc_reentrant_key,
-                               REENTRANT);
+        _PyThread_set_key_value(tracemalloc_reentrant_key, REENTRANT);
     }
     else {
-        /* FIXME: PyThread_set_key_value() cannot be used to set the flag
-           to zero, because it does nothing if the variable has already
-           a value set. */
-        PyThread_delete_key_value(tracemalloc_reentrant_key);
+        assert(PyThread_get_key_value(tracemalloc_reentrant_key) == REENTRANT);
+        _PyThread_set_key_value(tracemalloc_reentrant_key, NULL);
     }
 }
 
diff -r acabd3f035fe -r c75f7c760069 Python/thread.c
--- a/Python/thread.c	Wed Nov 27 14:42:55 2013 -0800
+++ b/Python/thread.c	Thu Nov 28 02:13:28 2013 +0100
@@ -205,7 +205,7 @@ static int nkeys = 0;  /* PyThread_creat
  * segfaults.  Now we lock the whole routine.
  */
 static struct key *
-find_key(int key, void *value)
+find_key(int key, int update, void *value)
 {
     struct key *p, *prev_p;
     long id = PyThread_get_thread_ident();
@@ -215,8 +215,11 @@ find_key(int key, void *value)
     PyThread_acquire_lock(keymutex, 1);
     prev_p = NULL;
     for (p = keyhead; p != NULL; p = p->next) {
-        if (p->id == id && p->key == key)
+        if (p->id == id && p->key == key) {
+            if (update)
+                p->value = value;
             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
@@ -227,7 +230,7 @@ find_key(int key, void *value)
         if (p->next == keyhead)
             Py_FatalError("tls find_key: circular list(!)");
     }
-    if (value == NULL) {
+    if (!update && value == NULL) {
         assert(p == NULL);
         goto Done;
     }
@@ -279,6 +282,18 @@ PyThread_delete_key(int key)
     PyThread_release_lock(keymutex);
 }
 
+int
+_PyThread_set_key_value(int key, void *value)
+{
+    struct key *p;
+
+    p = find_key(key, 1, value);
+    if (p == NULL)
+        return -1;
+    else
+        return 0;
+}
+
 /* Confusing:  If the current thread has an association for key,
  * value is ignored, and 0 is returned.  Else an attempt is made to create
  * an association of key to value for the current thread.  0 is returned
@@ -291,7 +306,7 @@ PyThread_set_key_value(int key, void *va
     struct key *p;
 
     assert(value != NULL);
-    p = find_key(key, value);
+    p = find_key(key, 0, value);
     if (p == NULL)
         return -1;
     else
@@ -304,7 +319,7 @@ PyThread_set_key_value(int key, void *va
 void *
 PyThread_get_key_value(int key)
 {
-    struct key *p = find_key(key, NULL);
+    struct key *p = find_key(key, 0, NULL);
 
     if (p == NULL)
         return NULL;
diff -r acabd3f035fe -r c75f7c760069 Python/thread_nt.h
--- a/Python/thread_nt.h	Wed Nov 27 14:42:55 2013 -0800
+++ b/Python/thread_nt.h	Thu Nov 28 02:13:28 2013 +0100
@@ -389,13 +389,23 @@ PyThread_delete_key(int key)
     TlsFree(key);
 }
 
+int
+_PyThread_set_key_value(int key, void *value)
+{
+    BOOL ok;
+
+    ok = TlsSetValue(key, value);
+    if (!ok)
+        return -1;
+    return 0;
+}
+
 /* 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);
@@ -403,10 +413,8 @@ PyThread_set_key_value(int key, void *va
     if (oldvalue != NULL)
         /* ignore value if already set */
         return 0;
-    ok = TlsSetValue(key, value);
-    if (!ok)
-        return -1;
-    return 0;
+
+    return _PyThread_set_key_value(key, value);
 }
 
 void *
diff -r acabd3f035fe -r c75f7c760069 Python/thread_pthread.h
--- a/Python/thread_pthread.h	Wed Nov 27 14:42:55 2013 -0800
+++ b/Python/thread_pthread.h	Thu Nov 28 02:13:28 2013 +0100
@@ -624,14 +624,20 @@ PyThread_delete_key_value(int key)
 }
 
 int
+_PyThread_set_key_value(int key, void *value)
+{
+    int fail;
+    fail = pthread_setspecific(key, value);
+    return fail ? -1 : 0;
+}
+
+int
 PyThread_set_key_value(int key, void *value)
 {
-    int fail;
     void *oldValue = pthread_getspecific(key);
     if (oldValue != NULL)
         return 0;
-    fail = pthread_setspecific(key, value);
-    return fail ? -1 : 0;
+    return _PyThread_set_key_value(key, value);
 }
 
 void *