wip: update type slots, stop-the-world

Author: nascheme

Include/internal/pycore_interp.h

@@ -57,6 +57,7 @@ struct _stoptheworld_state {
     bool requested;      // Set when a pause is requested.
     bool world_stopped;  // Set when the world is stopped.
     bool is_global;      // Set when contained in PyRuntime struct.
+    Py_ssize_t world_stops; // Number of times the world was stopped.
 
     PyEvent stop_event;  // Set when thread_countdown reaches zero.
     Py_ssize_t thread_countdown;  // Number of threads that must pause.

Objects/typeobject.c

@@ -3490,6 +3490,9 @@ static int update_slot(PyTypeObject *, PyObject *);
 static void fixup_slot_dispatchers(PyTypeObject *);
 static int type_new_set_names(PyTypeObject *);
 static int type_new_init_subclass(PyTypeObject *, PyObject *);
+#ifdef Py_GIL_DISABLED
+static bool has_slotdef(PyObject *);
+#endif
 
 /*
  * Helpers for  __dict__ descriptor.  We don't want to expose the dicts
@@ -5943,6 +5946,23 @@ _Py_type_getattro(PyObject *tp, PyObject *name)
     return _Py_type_getattro_impl(type, name, NULL);
 }
 
+#ifdef Py_GIL_DISABLED
+static int
+update_slot_world_stopped(PyTypeObject *type, PyObject *name)
+{
+    // Modification of type slots is protected by the global type
+    // lock. However, type slots are read non-atomically without holding the
+    // type lock.  So, we need to stop-the-world while modifying slots, in
+    // order to avoid data races.  This is unfortunately quite expensive.
+    int ret;
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    _PyEval_StopTheWorld(interp);
+    ret = update_slot(type, name);
+    _PyEval_StartTheWorld(interp);
+    return ret;
+}
+#endif
+
 static int
 type_update_dict(PyTypeObject *type, PyDictObject *dict, PyObject *name,
                  PyObject *value, PyObject **old_value)
@@ -5972,9 +5992,15 @@ type_update_dict(PyTypeObject *type, PyDictObject *dict, PyObject *name,
         return -1;
     }
 
+#if Py_GIL_DISABLED
+    if (is_dunder_name(name) && has_slotdef(name)) {
+        return update_slot_world_stopped(type, name);
+    }
+#else
     if (is_dunder_name(name)) {
         return update_slot(type, name);
     }
+#endif
 
     return 0;
 }
@@ -11002,6 +11028,21 @@ resolve_slotdups(PyTypeObject *type, PyObject *name)
 #undef ptrs
 }
 
+#ifdef Py_GIL_DISABLED
+// Return true if "name" corresponds to at least one slot definition.  This is
+// used to avoid calling update_slot() if is_dunder_name() is true but it's
+// not actually a slot.
+static bool
+has_slotdef(PyObject *name)
+{
+    for (pytype_slotdef *p = slotdefs; p->name_strobj; p++) {
+        if (p->name_strobj == name) {
+            return true;
+        }
+    }
+    return false;
+}
+#endif
 
 /* Common code for update_slots_callback() and fixup_slot_dispatchers().
  *
@@ -11241,20 +11282,32 @@ fixup_slot_dispatchers(PyTypeObject *type)
     END_TYPE_LOCK();
 }
 
+// Called when __bases__ is re-assigned.
 static void
 update_all_slots(PyTypeObject* type)
 {
     pytype_slotdef *p;
 
     ASSERT_TYPE_LOCK_HELD();
 
+    // Similar to update_slot_world_stopped(), this is required to
+    // avoid races.  We do it once here rather than once per-slot.
+#ifdef Py_GIL_DISABLED
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    _PyEval_StopTheWorld(interp);
+#endif
+
     /* Clear the VALID_VERSION flag of 'type' and all its subclasses. */
     type_modified_unlocked(type);
 
     for (p = slotdefs; p->name; p++) {
         /* update_slot returns int but can't actually fail */
         update_slot(type, p->name_strobj);
     }
+
+#ifdef Py_GIL_DISABLED
+    _PyEval_StartTheWorld(interp);
+#endif
 }
 
 

Python/clinic/sysmodule.c.h

@@ -2355,6 +2355,7 @@ start_the_world(struct _stoptheworld_state *stw)
     assert(PyMutex_IsLocked(&stw->mutex));
 
     HEAD_LOCK(runtime);
+    stw->world_stops++;
     stw->requested = 0;
     stw->world_stopped = 0;
     // Switch threads back to the detached state.
@@ -2730,6 +2731,7 @@ _PyGILState_Fini(PyInterpreterState *interp)
         return;
     }
     interp->runtime->gilstate.autoInterpreterState = NULL;
+    //fprintf(stderr, "world stops %zd\n", interp->stoptheworld.world_stops);
 }
 
 

Python/pystate.c

@@ -2527,6 +2527,27 @@ sys__is_gil_enabled_impl(PyObject *module)
 #endif
 }
 
+/*[clinic input]
+sys._get_world_stops
+
+Return the number of times the "stop-the-world" condition was true.
+[clinic start generated code]*/
+
+static PyObject *
+sys__get_world_stops_impl(PyObject *module)
+/*[clinic end generated code: output=7886d32b71a94e72 input=44a9bde7e07b30e3]*/
+{
+    Py_ssize_t stops;
+#ifdef Py_GIL_DISABLED
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    stops = interp->stoptheworld.world_stops;
+#else
+    stops = 0;
+#endif
+    return PyLong_FromLong(stops);
+}
+
+
 
 static PerfMapState perf_map_state;
 
@@ -2703,6 +2724,7 @@ static PyMethodDef sys_methods[] = {
 #endif
     SYS__GET_CPU_COUNT_CONFIG_METHODDEF
     SYS__IS_GIL_ENABLED_METHODDEF
+    SYS__GET_WORLD_STOPS_METHODDEF
     SYS__DUMP_TRACELETS_METHODDEF
     {NULL, NULL}  // sentinel
 };

Python/sysmodule.c

@@ -14,15 +14,15 @@
 
 race_top:assign_version_tag
 race_top:_multiprocessing_SemLock_acquire_impl
-race_top:_Py_slot_tp_getattr_hook
+#race_top:_Py_slot_tp_getattr_hook
 race_top:dump_traceback
 race_top:fatal_error
 race_top:_multiprocessing_SemLock_release_impl
 race_top:_PyFrame_GetCode
 race_top:_PyFrame_Initialize
 race_top:_PyObject_TryGetInstanceAttribute
 race_top:PyUnstable_InterpreterFrame_GetLine
-race_top:type_modified_unlocked
+#race_top:type_modified_unlocked
 race_top:write_thread_id
 
 # gh-129068: race on shared range iterators (test_free_threading.test_zip.ZipThreading.test_threading)
@@ -32,7 +32,7 @@ race_top:rangeiter_next
 race_top:mi_block_set_nextx
 
 # gh-127266: type slot updates are not thread-safe (test_opcache.test_load_attr_method_lazy_dict)
-race_top:update_one_slot
+#race_top:update_one_slot
 
 # https://gist.github.com/mpage/6962e8870606cfc960e159b407a0cb40
 thread:pthread_create