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) {
+                Py_DECREF(localdict);
                 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;
                 }
                 
-        }
-
-        /* The call to tp_init above may have caused another thread to run.
-           Install our ldict again. */
-        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);
+        PyObject *ldict = _ldict(self);
         if (ldict == NULL) 
                 return -1;
 
-        return PyObject_GenericSetAttr((PyObject *)self, name, v);
+        if (v != NULL) {
+                return PyDict_SetItem(ldict, name, v);
+        } else {
+                int res;
+                res = PyDict_DelItem(ldict, name);
+                if ((res < 0) && PyErr_ExceptionMatches(PyExc_KeyError)) {
+                        PyErr_SetObject(PyExc_AttributeError, name);
+                }
+                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)
 {
         PyObject *ldict, *value;
 
         ldict = _ldict(self);
         if (ldict == NULL) 
                 return NULL;
-
-        if (Py_TYPE(self) != &localtype)
-                /* use generic lookup for subtypes */
-                return PyObject_GenericGetAttr((PyObject *)self, name);
 
         /* Optimization: just look in dict ourselves */
         value = PyDict_GetItem(ldict, name);
         if (value == NULL) 
                 /* Fall back on generic to get __class__ and __dict__ */
                 return PyObject_GenericGetAttr((PyObject *)self, name);
 
         Py_INCREF(value);
         return value;
 }
@@ skipping 307 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();
 }