Merge 'origin/main' into gh-127266-type-slots-ts

nascheme · Apr 28, 2025 · Mar 12, 2025 · Mar 13, 2025 · Mar 13, 2025 · Mar 14, 2025
commit b97a4b4271069a4d5d53f1fd2c09e60612311fe4
diff --git a/Include/internal/pycore_interp_structs.h b/Include/internal/pycore_interp_structs.h
@@ -565,6 +565,8 @@ struct types_state {
         managed_static_type_state initialized[_Py_MAX_MANAGED_STATIC_EXT_TYPES];
     } for_extensions;
     PyMutex mutex;
+    // used to check correct usage of the above mutex
+    unsigned long long mutex_tid;
 
     // Borrowed references to type objects whose
     // tp_version_tag % TYPE_VERSION_CACHE_SIZE

diff --git a/Include/internal/pycore_typeobject.h b/Include/internal/pycore_typeobject.h
@@ -32,129 +32,6 @@ extern "C" {
 #define _Py_TYPE_BASE_VERSION_TAG (2<<16)
 #define _Py_MAX_GLOBAL_TYPE_VERSION_TAG (_Py_TYPE_BASE_VERSION_TAG - 1)
 
-/* For now we hard-code this to a value for which we are confident
-   all the static builtin types will fit (for all builds). */
-#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES 200
-#define _Py_MAX_MANAGED_STATIC_EXT_TYPES 10
-#define _Py_MAX_MANAGED_STATIC_TYPES \
-    (_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES + _Py_MAX_MANAGED_STATIC_EXT_TYPES)
-
-struct _types_runtime_state {
-    /* Used to set PyTypeObject.tp_version_tag for core static types. */
-    // bpo-42745: next_version_tag remains shared by all interpreters
-    // because of static types.
-    unsigned int next_version_tag;
-
-    struct {
-        struct {
-            PyTypeObject *type;
-            int64_t interp_count;
-        } types[_Py_MAX_MANAGED_STATIC_TYPES];
-    } managed_static;
-};
-
-
-// Type attribute lookup cache: speed up attribute and method lookups,
-// see _PyType_Lookup().
-struct type_cache_entry {
-    unsigned int version;  // initialized from type->tp_version_tag
-#ifdef Py_GIL_DISABLED
-   _PySeqLock sequence;
-#endif
-    PyObject *name;        // reference to exactly a str or None
-    PyObject *value;       // borrowed reference or NULL
-};
-
-#define MCACHE_SIZE_EXP 12
-
-struct type_cache {
-    struct type_cache_entry hashtable[1 << MCACHE_SIZE_EXP];
-};
-
-typedef struct {
-    PyTypeObject *type;
-    int isbuiltin;
-    int readying;
-    int ready;
-    // XXX tp_dict can probably be statically allocated,
-    // instead of dynamically and stored on the interpreter.
-    PyObject *tp_dict;
-    PyObject *tp_subclasses;
-    /* We never clean up weakrefs for static builtin types since
-       they will effectively never get triggered.  However, there
-       are also some diagnostic uses for the list of weakrefs,
-       so we still keep it. */
-    PyObject *tp_weaklist;
-} managed_static_type_state;
-
-#define TYPE_VERSION_CACHE_SIZE (1<<12)  /* Must be a power of 2 */
-
-struct types_state {
-    /* Used to set PyTypeObject.tp_version_tag.
-       It starts at _Py_MAX_GLOBAL_TYPE_VERSION_TAG + 1,
-       where all those lower numbers are used for core static types. */
-    unsigned int next_version_tag;
-
-    struct type_cache type_cache;
-
-    /* Every static builtin type is initialized for each interpreter
-       during its own initialization, including for the main interpreter
-       during global runtime initialization.  This is done by calling
-       _PyStaticType_InitBuiltin().
-
-       The first time a static builtin type is initialized, all the
-       normal PyType_Ready() stuff happens.  The only difference from
-       normal is that there are three PyTypeObject fields holding
-       objects which are stored here (on PyInterpreterState) rather
-       than in the corresponding PyTypeObject fields.  Those are:
-       tp_dict (cls.__dict__), tp_subclasses (cls.__subclasses__),
-       and tp_weaklist.
-
-       When a subinterpreter is initialized, each static builtin type
-       is still initialized, but only the interpreter-specific portion,
-       namely those three objects.
-
-       Those objects are stored in the PyInterpreterState.types.builtins
-       array, at the index corresponding to each specific static builtin
-       type.  That index (a size_t value) is stored in the tp_subclasses
-       field.  For static builtin types, we re-purposed the now-unused
-       tp_subclasses to avoid adding another field to PyTypeObject.
-       In all other cases tp_subclasses holds a dict like before.
-       (The field was previously defined as PyObject*, but is now void*
-       to reflect its dual use.)
-
-       The index for each static builtin type isn't statically assigned.
-       Instead it is calculated the first time a type is initialized
-       (by the main interpreter).  The index matches the order in which
-       the type was initialized relative to the others.  The actual
-       value comes from the current value of num_builtins_initialized,
-       as each type is initialized for the main interpreter.
-
-       num_builtins_initialized is incremented once for each static
-       builtin type.  Once initialization is over for a subinterpreter,
-       the value will be the same as for all other interpreters.  */
-    struct {
-        size_t num_initialized;
-        managed_static_type_state initialized[_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES];
-    } builtins;
-    /* We apply a similar strategy for managed extension modules. */
-    struct {
-        size_t num_initialized;
-        size_t next_index;
-        managed_static_type_state initialized[_Py_MAX_MANAGED_STATIC_EXT_TYPES];
-    } for_extensions;
-    PyMutex mutex;
-    // used to check correct usage of the above mutex
-    unsigned long long mutex_tid;
-
-    // Borrowed references to type objects whose
-    // tp_version_tag % TYPE_VERSION_CACHE_SIZE
-    // once was equal to the index in the table.
-    // They are cleared when the type object is deallocated.
-    PyTypeObject *type_version_cache[TYPE_VERSION_CACHE_SIZE];
-};
-
-
 /* runtime lifecycle */
 
 extern PyStatus _PyTypes_InitTypes(PyInterpreterState *);

@@ -634,14 +634,16 @@ static inline void
 set_tp_mro(PyTypeObject *self, PyObject *mro, int initial)
 {
     ASSERT_NEW_OR_STOPPED(self);
-    assert(PyTuple_CheckExact(mro));
-    if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
-        // XXX tp_mro can probably be statically allocated for each
-        // static builtin type.
-        assert(initial);
-        assert(self->tp_mro == NULL);
-        /* Other checks are done via set_tp_bases. */
-        _Py_SetImmortal(mro);
+    if (mro != NULL) {
+        assert(PyTuple_CheckExact(mro));
+        if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
+            // XXX tp_mro can probably be statically allocated for each
+            // static builtin type.
+            assert(initial);
+            assert(self->tp_mro == NULL);
+            /* Other checks are done via set_tp_bases. */
+            _Py_SetImmortal(mro);
+        }
     }
     self->tp_mro = mro;
 }