python
diff --git a/‎Lib/test/test_free_threading/test_dict.py‎
Lines changed: 141 additions & 0 deletions b/‎Lib/test/test_free_threading/test_dict.py‎
Lines changed: 141 additions & 0 deletions
diff --git a/‎Objects/dictobject.c‎
Lines changed: 61 additions & 51 deletions b/‎Objects/dictobject.c‎
Lines changed: 61 additions & 51 deletions
diff --git a/‎Objects/object.c‎
Lines changed: 4 additions & 0 deletions b/‎Objects/object.c‎
Lines changed: 4 additions & 0 deletions
@@ -0,0 +1,141 @@
+import gc
+import time
+import unittest
+import weakref
+
+from ast import Or
+from functools import partial
+from threading import Thread
+from unittest import TestCase
+
+from test.support import is_wasi
+
+
+@unittest.skipIf(is_wasi, "WASI has no threads.")
+class TestDict(TestCase):
+    def test_racing_creation_shared_keys(self):
+        """Verify that creating dictionaries is thread safe when we
+        have a type with shared keys"""
+        class C(int):
+            pass
+
+        self.racing_creation(C)
+
+    def test_racing_creation_no_shared_keys(self):
+        """Verify that creating dictionaries is thread safe when we
+        have a type with an ordinary dict"""
+        self.racing_creation(Or)
+
+    def test_racing_creation_inline_values_invalid(self):
+        """Verify that re-creating a dict after we have invalid inline values
+        is thread safe"""
+        class C:
+            pass
+
+        def make_obj():
+            a = C()
+            # Make object, make inline values invalid, and then delete dict
+            a.__dict__ = {}
+            del a.__dict__
+            return a
+
+        self.racing_creation(make_obj)
+
+    def test_racing_creation_nonmanaged_dict(self):
+        """Verify that explicit creation of an unmanaged dict is thread safe
+        outside of the normal attribute setting code path"""
+        def make_obj():
+            def f(): pass
+            return f
+
+        def set(func, name, val):
+            # Force creation of the dict via PyObject_GenericGetDict
+            func.__dict__[name] = val
+
+        self.racing_creation(make_obj, set)
+
+    def racing_creation(self, cls, set=setattr):
+        objects = []
+        processed = []
+
+        OBJECT_COUNT = 100
+        THREAD_COUNT = 10
+        CUR = 0
+
+        for i in range(OBJECT_COUNT):
+            objects.append(cls())
+
+        def writer_func(name):
+            last = -1
+            while True:
+                if CUR == last:
+                    continue
+                elif CUR == OBJECT_COUNT:
+                    break
+
+                obj = objects[CUR]
+                set(obj, name, name)
+                last = CUR
+                processed.append(name)
+
+        writers = []
+        for x in range(THREAD_COUNT):
+            writer = Thread(target=partial(writer_func, f"a{x:02}"))
+            writers.append(writer)
+            writer.start()
+
+        for i in range(OBJECT_COUNT):
+            CUR = i
+            while len(processed) != THREAD_COUNT:
+                time.sleep(0.001)
+            processed.clear()
+
+        CUR = OBJECT_COUNT
+
+        for writer in writers:
+            writer.join()
+
+        for obj_idx, obj in enumerate(objects):
+            assert (
+                len(obj.__dict__) == THREAD_COUNT
+            ), f"{len(obj.__dict__)} {obj.__dict__!r} {obj_idx}"
+            for i in range(THREAD_COUNT):
+                assert f"a{i:02}" in obj.__dict__, f"a{i:02} missing at {obj_idx}"
+
+    def test_racing_set_dict(self):
+        """Races assigning to __dict__ should be thread safe"""
+
+        def f(): pass
+        l = []
+        THREAD_COUNT = 10
+        class MyDict(dict): pass
+
+        def writer_func(l):
+            for i in range(1000):
+                d = MyDict()
+                l.append(weakref.ref(d))
+                f.__dict__ = d
+
+        lists = []
+        writers = []
+        for x in range(THREAD_COUNT):
+            thread_list = []
+            lists.append(thread_list)
+            writer = Thread(target=partial(writer_func, thread_list))
+            writers.append(writer)
+
+        for writer in writers:
+            writer.start()
+
+        for writer in writers:
+            writer.join()
+
+        f.__dict__ = {}
+        gc.collect()
+
+        for thread_list in lists:
+            for ref in thread_list:
+                self.assertIsNone(ref())
+
+if __name__ == "__main__":
+    unittest.main()
@@ -7159,70 +7159,47 @@ _PyDict_DetachFromObject(PyDictObject *mp, PyObject *obj)
     return 0;
 }
 
-PyObject *
-PyObject_GenericGetDict(PyObject *obj, void *context)
+static inline PyObject *
+ensure_managed_dict(PyObject *obj)
 {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    PyTypeObject *tp = Py_TYPE(obj);
-    PyDictObject *dict;
-    if (_PyType_HasFeature(tp, Py_TPFLAGS_MANAGED_DICT)) {
-        dict = _PyObject_GetManagedDict(obj);
-        if (dict == NULL &&
-            (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+    PyDictObject *dict = _PyObject_GetManagedDict(obj);
+    if (dict == NULL) {
+        PyTypeObject *tp = Py_TYPE(obj);
+        if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
             FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(obj)->valid)) {
             dict = _PyObject_MaterializeManagedDict(obj);
         }
-        else if (dict == NULL) {
-            Py_BEGIN_CRITICAL_SECTION(obj);
-
+        else {
+#ifdef Py_GIL_DISABLED
             // Check again that we're not racing with someone else creating the dict
+            Py_BEGIN_CRITICAL_SECTION(obj);
             dict = _PyObject_GetManagedDict(obj);
-            if (dict == NULL) {
-                OBJECT_STAT_INC(dict_materialized_on_request);
-                dictkeys_incref(CACHED_KEYS(tp));
-                dict = (PyDictObject *)new_dict_with_shared_keys(interp, CACHED_KEYS(tp));
-                FT_ATOMIC_STORE_PTR_RELEASE(_PyObject_ManagedDictPointer(obj)->dict,
-                                            (PyDictObject *)dict);
+            if (dict != NULL) {
+                goto done;
             }
+#endif
+            OBJECT_STAT_INC(dict_materialized_on_request);
+            dictkeys_incref(CACHED_KEYS(tp));
+            dict = (PyDictObject *)new_dict_with_shared_keys(_PyInterpreterState_GET(),
+                                                             CACHED_KEYS(tp));
+            FT_ATOMIC_STORE_PTR_RELEASE(_PyObject_ManagedDictPointer(obj)->dict,
+                                        (PyDictObject *)dict);
 
+#ifdef Py_GIL_DISABLED
+done:
             Py_END_CRITICAL_SECTION();
+#endif
         }
-        return Py_XNewRef((PyObject *)dict);
-    }
-    else {
-        PyObject **dictptr = _PyObject_ComputedDictPointer(obj);
-        if (dictptr == NULL) {
-            PyErr_SetString(PyExc_AttributeError,
-                            "This object has no __dict__");
-            return NULL;
-        }
-        PyObject *dict = *dictptr;
-        if (dict == NULL) {
-            PyTypeObject *tp = Py_TYPE(obj);
-            if (_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE) && CACHED_KEYS(tp)) {
-                dictkeys_incref(CACHED_KEYS(tp));
-                *dictptr = dict = new_dict_with_shared_keys(
-                        interp, CACHED_KEYS(tp));
-            }
-            else {
-                *dictptr = dict = PyDict_New();
-            }
-        }
-        return Py_XNewRef(dict);
     }
+    return (PyObject *)dict;
 }
 
-int
-_PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr,
-                      PyObject *key, PyObject *value)
+static inline PyObject *
+ensure_nonmanaged_dict(PyObject *obj, PyObject **dictptr)
 {
-    PyObject *dict;
-    int res;
     PyDictKeysObject *cached;
-    PyInterpreterState *interp = _PyInterpreterState_GET();
 
-    assert(dictptr != NULL);
-    dict = *dictptr;
+    PyObject *dict = FT_ATOMIC_LOAD_PTR_RELAXED(*dictptr);
     if (dict == NULL) {
 #ifdef Py_GIL_DISABLED
         Py_BEGIN_CRITICAL_SECTION(obj);
@@ -7231,7 +7208,9 @@ _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr,
             goto done;
         }
 #endif
+        PyTypeObject *tp = Py_TYPE(obj);
         if ((tp->tp_flags & Py_TPFLAGS_HEAPTYPE) && (cached = CACHED_KEYS(tp))) {
+            PyInterpreterState *interp = _PyInterpreterState_GET();
             assert(!_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES));
             dictkeys_incref(cached);
             dict = new_dict_with_shared_keys(interp, cached);
@@ -7242,14 +7221,45 @@ _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr,
         else {
             dict = PyDict_New();
         }
-        *dictptr = dict;
+        FT_ATOMIC_STORE_PTR_RELAXED(*dictptr, dict);
 #ifdef Py_GIL_DISABLED
 done:
         Py_END_CRITICAL_SECTION();
 #endif
-        if (dict == NULL) {
-            return -1;
+    }
+    return dict;
+}
+
+PyObject *
+PyObject_GenericGetDict(PyObject *obj, void *context)
+{
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (_PyType_HasFeature(tp, Py_TPFLAGS_MANAGED_DICT)) {
+        return Py_XNewRef(ensure_managed_dict(obj));
+    }
+    else {
+        PyObject **dictptr = _PyObject_ComputedDictPointer(obj);
+        if (dictptr == NULL) {
+            PyErr_SetString(PyExc_AttributeError,
+                            "This object has no __dict__");
+            return NULL;
         }
+
+        return Py_XNewRef(ensure_nonmanaged_dict(obj, dictptr));
+    }
+}
+
+int
+_PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr,
+                      PyObject *key, PyObject *value)
+{
+    PyObject *dict;
+    int res;
+
+    assert(dictptr != NULL);
+    dict = ensure_nonmanaged_dict(obj, dictptr);
+    if (dict == NULL) {
+        return -1;
     }
 
     Py_BEGIN_CRITICAL_SECTION(dict);
 
@@ -1797,7 +1797,11 @@ PyObject_GenericSetDict(PyObject *obj, PyObject *value, void *context)
                      "not a '%.200s'", Py_TYPE(value)->tp_name);
         return -1;
     }
+#ifdef Py_GIL_DISABLED
+    Py_XDECREF(_Py_atomic_exchange_ptr(dictptr, Py_NewRef(value)));
+#else
     Py_XSETREF(*dictptr, Py_NewRef(value));
+#endif
     return 0;
 }
Original file line number	Diff line number	Diff line change
`@@ -1797,7 +1797,11 @@ PyObject_GenericSetDict(PyObject obj, PyObject value, void *context)`
`1797`	`1797`	`"not a '%.200s'", Py_TYPE(value)->tp_name);`
`1798`	`1798`	`return -1;`
`1799`	`1799`	`}`
	`1800`	`+#ifdef Py_GIL_DISABLED`
	`1801`	`+ Py_XDECREF(_Py_atomic_exchange_ptr(dictptr, Py_NewRef(value)));`
	`1802`	`+#else`
`1800`	`1803`	`Py_XSETREF(*dictptr, Py_NewRef(value));`
	`1804`	`+#endif`
`1801`	`1805`	`return 0;`
`1802`	`1806`	`}`
`1803`	`1807`