changeset: 87924:46393019b650 tag: tip user: Victor Stinner date: Fri Dec 13 03:22:00 2013 +0100 files: Doc/whatsnew/3.4.rst Misc/NEWS Modules/_testcapimodule.c Modules/_tracemalloc.c Python/thread.c Python/thread_nt.h Python/thread_pthread.h description: Close #19787: PyThread_set_key_value() now always set the value. In Python 3.3, the function did nothing if the key already exists (if the current value is a non-NULL pointer). _testcapi.run_in_subinterp() now correctly sets the new Python thread state of the current thread when a subinterpreter is created. diff -r a35b2d652449 -r 46393019b650 Doc/whatsnew/3.4.rst --- a/Doc/whatsnew/3.4.rst Fri Dec 13 02:45:18 2013 +0100 +++ b/Doc/whatsnew/3.4.rst Fri Dec 13 03:22:00 2013 +0100 @@ -1068,3 +1068,8 @@ that may require changes to your code. working directory will also now have an absolute path, including when using ``-m`` with the interpreter (this does not influence when the path to a file is specified on the command-line). + +* (C API) :c:func:`PyThread_set_key_value` now always set the value. In Python + 3.3, the function did nothing if the key already exists (if the current + value is a non-NULL pointer). + diff -r a35b2d652449 -r 46393019b650 Misc/NEWS --- a/Misc/NEWS Fri Dec 13 02:45:18 2013 +0100 +++ b/Misc/NEWS Fri Dec 13 03:22:00 2013 +0100 @@ -10,6 +10,10 @@ Release date: 2014-01-05 Core and Builtins ----------------- +- Issue #19787: PyThread_set_key_value() now always set the value. In Python + 3.3, the function did nothing if the key already exists (if the current value + is a non-NULL pointer). + - Issue #14432: Remove the thread state field from the frame structure. Fix a crash when a generator is created in a C thread that is destroyed while the generator is still used. The issue was that a generator contains a frame, and diff -r a35b2d652449 -r 46393019b650 Modules/_testcapimodule.c --- a/Modules/_testcapimodule.c Fri Dec 13 02:45:18 2013 +0100 +++ b/Modules/_testcapimodule.c Fri Dec 13 03:22:00 2013 +0100 @@ -2511,6 +2511,10 @@ run_in_subinterp(PyObject *self, PyObjec r = PyRun_SimpleString(code); Py_EndInterpreter(substate); + /* restore previous thread safe. It was replaced by Py_NewInterpreter() + which creates a new thread state. */ + _PyThreadState_Init(mainstate); + PyThreadState_Swap(mainstate); return PyLong_FromLong(r); diff -r a35b2d652449 -r 46393019b650 Modules/_tracemalloc.c --- a/Modules/_tracemalloc.c Fri Dec 13 02:45:18 2013 +0100 +++ b/Modules/_tracemalloc.c Fri Dec 13 03:22:00 2013 +0100 @@ -168,14 +168,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 a35b2d652449 -r 46393019b650 Python/thread.c --- a/Python/thread.c Fri Dec 13 02:45:18 2013 +0100 +++ b/Python/thread.c Fri Dec 13 03:22:00 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,19 +282,12 @@ PyThread_delete_key(int key) PyThread_release_lock(keymutex); } -/* 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 - * if that succeeds, but -1 is returned if there's not enough memory - * to create the association. value must not be NULL. - */ int PyThread_set_key_value(int key, void *value) { struct key *p; - assert(value != NULL); - p = find_key(key, value); + p = find_key(key, 1, value); if (p == NULL) return -1; else @@ -304,7 +300,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 a35b2d652449 -r 46393019b650 Python/thread_nt.h --- a/Python/thread_nt.h Fri Dec 13 02:45:18 2013 +0100 +++ b/Python/thread_nt.h Fri Dec 13 03:22:00 2013 +0100 @@ -389,20 +389,11 @@ 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; diff -r a35b2d652449 -r 46393019b650 Python/thread_pthread.h --- a/Python/thread_pthread.h Fri Dec 13 02:45:18 2013 +0100 +++ b/Python/thread_pthread.h Fri Dec 13 03:22:00 2013 +0100 @@ -627,9 +627,6 @@ 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; }