thread._local, threading.local Python issue 1868 & 3710

Modules/threadmodule.c

 
 /* Thread module */
 /* Interface to Sjoerd's portable C thread library */
 
 #include "Python.h"
 
 #ifndef WITH_THREAD
 #error "Error!  The rest of Python is not compiled with thread support."
 #error "Rerun configure, adding a --with-threads option."
 #error "Then run `make clean' followed by `make'."
@@ skipping 146 matching lines @@
 
 /* Thread-local objects */
 
 #include "structmember.h"
 
 typedef struct {
         PyObject_HEAD
         PyObject *key;
         PyObject *args;
         PyObject *kw;
-        PyObject *dict;
 } localobject;
 
 static PyObject *
 local_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
         localobject *self;
         PyObject *tdict;
+        PyObject *localdict;
 
         if (type->tp_init == PyBaseObject_Type.tp_init
             && ((args && PyObject_IsTrue(args))
                 || (kw && PyObject_IsTrue(kw)))) {
                 PyErr_SetString(PyExc_TypeError,
                           "Initialization arguments are not supported");
                 return NULL;
         }
 
         self = (localobject *)type->tp_alloc(type, 0);
         if (self == NULL)
                 return NULL;
 
         Py_XINCREF(args);
         self->args = args;
         Py_XINCREF(kw);
         self->kw = kw;
-        self->dict = NULL;      /* making sure */
         self->key = PyString_FromFormat("thread.local.%p", self);
         if (self->key == NULL) 
                 goto err;
 
-        self->dict = PyDict_New();
-        if (self->dict == NULL)
+        localdict = PyDict_New();
+        if (localdict == NULL)
                 goto err;
 
         tdict = PyThreadState_GetDict();
         if (tdict == NULL) {
                 PyErr_SetString(PyExc_SystemError,
                                 "Couldn't get thread-state dictionary");
                 goto err;
         }
 
-        if (PyDict_SetItem(tdict, self->key, self->dict) < 0)
+        if (PyDict_SetItem(tdict, self->key, localdict) < 0)

[Antoine Pitrou, 2008/08/28 09:29:49]

A Py_DECREF(localdict) is needed just before bailing out.

[gregory.p.smith, 2008/09/02 06:43:30]

On 2008/08/28 09:29:49, Antoine Pitrou wrote:
> A Py_DECREF(localdict) is needed just before bailing out.
> 

Done.

                 goto err;
+        Py_DECREF(localdict);
 
         return (PyObject *)self;
 
   err:
         Py_DECREF(self);
         return NULL;
 }
 
 static int
 local_traverse(localobject *self, visitproc visit, void *arg)
 {
         Py_VISIT(self->args);
         Py_VISIT(self->kw);
-        Py_VISIT(self->dict);
         return 0;
 }
 
 static int
 local_clear(localobject *self)
 {
         Py_CLEAR(self->key);
         Py_CLEAR(self->args);
         Py_CLEAR(self->kw);
-        Py_CLEAR(self->dict);
         return 0;
 }
 
 static void
 local_dealloc(localobject *self)
 {
         PyThreadState *tstate;
         if (self->key
             && (tstate = PyThreadState_Get())
             && tstate->interp) {
                 for(tstate = PyInterpreterState_ThreadHead(tstate->interp);
                     tstate;
                     tstate = PyThreadState_Next(tstate)) 
                         if (tstate->dict &&
                             PyDict_GetItem(tstate->dict, self->key))
                                 PyDict_DelItem(tstate->dict, self->key);
         }
 
         local_clear(self);
         Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
+/* Return borrowed reference to the local dict */
 static PyObject *
 _ldict(localobject *self)
 {
         PyObject *tdict, *ldict;
 
         tdict = PyThreadState_GetDict();
         if (tdict == NULL) {
                 PyErr_SetString(PyExc_SystemError,
                                 "Couldn't get thread-state dictionary");
                 return NULL;
         }
 
         ldict = PyDict_GetItem(tdict, self->key);
         if (ldict == NULL) {
                 ldict = PyDict_New(); /* we own ldict */
 
                 if (ldict == NULL)
                         return NULL;
                 else {
                         int i = PyDict_SetItem(tdict, self->key, ldict);
                         Py_DECREF(ldict); /* now ldict is borrowed */
                         if (i < 0) 
                                 return NULL;
                 }
-
-                Py_CLEAR(self->dict);
-                Py_INCREF(ldict);
-                self->dict = ldict; /* still borrowed */
 
                 if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init &&
                     Py_TYPE(self)->tp_init((PyObject*)self, 
                                            self->args, self->kw) < 0) {
                         /* we need to get rid of ldict from thread so
                            we create a new one the next time we do an attr
                            acces */
                         PyDict_DelItem(tdict, self->key);
                         return NULL;
                 }
                 
-        }
-        else if (self->dict != ldict) {
-                Py_CLEAR(self->dict);
-                Py_INCREF(ldict);
-                self->dict = ldict;
         }
 
         return ldict;
 }
 
 static int
 local_setattro(localobject *self, PyObject *name, PyObject *v)
 {
-        PyObject *ldict;
-        
-        ldict = _ldict(self);
-        if (ldict == NULL) 
-                return -1;
+        int res = PyObject_GenericSetAttr((PyObject *)self, name, v);
 
-        return PyObject_GenericSetAttr((PyObject *)self, name, v);
+        if (res < 0 && PyErr_ExceptionMatches(PyExc_AttributeError)) {

[Antoine Pitrou, 2008/08/28 09:29:49]

Why did you add this fallback? Is it really necessary?

[gregory.p.smith, 2008/09/02 06:43:30]

On 2008/08/28 09:29:49, Antoine Pitrou wrote:
> Why did you add this fallback? Is it really necessary?
> 

this has been rewritten so that subclasses work.  please have another look.

+                PyObject *ldict = _ldict(self);
+                if (ldict == NULL) 
+                        return -1;
+
+                PyErr_Clear();
+
+                res = PyDict_SetItem(ldict, name, v);
+        }
+
+        return res;
 }
 
 static PyObject *
 local_getdict(localobject *self, void *closure)
 {
-        if (self->dict == NULL) {
+        PyObject *ldict = _ldict(self);
+        if (ldict == NULL) {
                 PyErr_SetString(PyExc_AttributeError, "__dict__");
                 return NULL;
         }
 
-        Py_INCREF(self->dict);
-        return self->dict;
+        Py_INCREF(ldict);
+        return ldict;
 }
 
 static PyGetSetDef local_getset[] = {
         {"__dict__", (getter)local_getdict, (setter)NULL,
          "Local-data dictionary", NULL},
         {NULL}  /* Sentinel */
 };
 
 static PyObject *local_getattro(localobject *, PyObject *);
 
@@ skipping 25 matching lines @@
         /* tp_weaklistoffset */ 0,
         /* tp_iter           */ 0,
         /* tp_iternext       */ 0,
         /* tp_methods        */ 0,
         /* tp_members        */ 0,
         /* tp_getset         */ local_getset,
         /* tp_base           */ 0,
         /* tp_dict           */ 0, /* internal use */
         /* tp_descr_get      */ 0,
         /* tp_descr_set      */ 0,
-        /* tp_dictoffset     */ offsetof(localobject, dict),
+        /* tp_dictoffset     */ 0,
         /* tp_init           */ 0,
         /* tp_alloc          */ 0,
         /* tp_new            */ local_new,
         /* tp_free           */ 0, /* Low-level free-mem routine */
         /* tp_is_gc          */ 0, /* For PyObject_IS_GC */
 };
 
 static PyObject *
 local_getattro(localobject *self, PyObject *name)
 {
@@ skipping 326 matching lines @@
         Py_INCREF(&Locktype);
         PyDict_SetItemString(d, "LockType", (PyObject *)&Locktype);
 
         Py_INCREF(&localtype);
         if (PyModule_AddObject(m, "_local", (PyObject *)&localtype) < 0)
                 return;
 
         /* Initialize the C thread library */
         PyThread_init_thread();
 }