gh-92810: Reduce memory usage by ABCMeta.__subclasscheck__

Doc/whatsnew/3.15.rst

@@ -816,6 +816,18 @@ xml.parsers.expat
 
   .. _billion laughs: https://en.wikipedia.org/wiki/Billion_laughs_attack
 
+abc
+---
+
+* Reduce memory usage of :func:`issubclass` checks for classes inheriting abstract classes.
+
+  :class:`abc.ABCMeta` hook ``__subclasscheck__`` now includes
+  a guard which is triggered then the hook is called from a parent class
+  (``issubclass(cls, RootClass)`` -> ``issubclass(cls, NestedClass)`` -> ...).
+  This guard prevents adding ``cls`` to ``NestedClass`` positive and negative caches,
+  preventing memory bloat in some cases (thousands of classes inherited from ABC).
+
+  (Contributed by Maxim Martynov in :gh:`92810`.)
 
 zlib
 ----

Include/internal/pycore_pyatomic_ft_wrappers.h

@@ -45,6 +45,8 @@ extern "C" {
     _Py_atomic_load_uint16_relaxed(&value)
 #define FT_ATOMIC_LOAD_UINT32_RELAXED(value) \
     _Py_atomic_load_uint32_relaxed(&value)
+#define FT_ATOMIC_LOAD_UINT64_RELAXED(value) \
+    _Py_atomic_load_uint64_relaxed(&value)
 #define FT_ATOMIC_LOAD_ULONG_RELAXED(value) \
     _Py_atomic_load_ulong_relaxed(&value)
 #define FT_ATOMIC_STORE_PTR_RELAXED(value, new_value) \
@@ -61,6 +63,8 @@ extern "C" {
     _Py_atomic_store_uint16_relaxed(&value, new_value)
 #define FT_ATOMIC_STORE_UINT32_RELAXED(value, new_value) \
     _Py_atomic_store_uint32_relaxed(&value, new_value)
+#define FT_ATOMIC_STORE_UINT64_RELAXED(value, new_value) \
+    _Py_atomic_store_uint64_relaxed(&value, new_value)
 #define FT_ATOMIC_STORE_CHAR_RELAXED(value, new_value) \
     _Py_atomic_store_char_relaxed(&value, new_value)
 #define FT_ATOMIC_LOAD_CHAR_RELAXED(value) \
@@ -111,6 +115,8 @@ extern "C" {
     _Py_atomic_load_ullong_relaxed(&value)
 #define FT_ATOMIC_ADD_SSIZE(value, new_value) \
     (void)_Py_atomic_add_ssize(&value, new_value)
+#define FT_ATOMIC_ADD_UINT64(value, new_value) \
+    (void)_Py_atomic_add_uint64(&value, new_value)
 #define FT_MUTEX_LOCK(lock) PyMutex_Lock(lock)
 #define FT_MUTEX_UNLOCK(lock) PyMutex_Unlock(lock)
 
@@ -128,6 +134,7 @@ extern "C" {
 #define FT_ATOMIC_LOAD_UINT8_RELAXED(value) value
 #define FT_ATOMIC_LOAD_UINT16_RELAXED(value) value
 #define FT_ATOMIC_LOAD_UINT32_RELAXED(value) value
+#define FT_ATOMIC_LOAD_UINT64_RELAXED(value) value
 #define FT_ATOMIC_LOAD_ULONG_RELAXED(value) value
 #define FT_ATOMIC_STORE_PTR_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_PTR_RELEASE(value, new_value) value = new_value
@@ -136,6 +143,7 @@ extern "C" {
 #define FT_ATOMIC_STORE_UINT8_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINT16_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_STORE_UINT32_RELAXED(value, new_value) value = new_value
+#define FT_ATOMIC_STORE_UINT64_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_LOAD_CHAR_RELAXED(value) value
 #define FT_ATOMIC_STORE_CHAR_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_LOAD_UCHAR_RELAXED(value) value
@@ -161,6 +169,7 @@ extern "C" {
 #define FT_ATOMIC_LOAD_ULLONG_RELAXED(value) value
 #define FT_ATOMIC_STORE_ULLONG_RELAXED(value, new_value) value = new_value
 #define FT_ATOMIC_ADD_SSIZE(value, new_value) (void)(value += new_value)
+#define FT_ATOMIC_ADD_UINT64(value, new_value) (void)(value += new_value)
 #define FT_MUTEX_LOCK(lock) do {} while (0)
 #define FT_MUTEX_UNLOCK(lock) do {} while (0)
 

Lib/_py_abc.py

@@ -49,6 +49,7 @@ def __new__(mcls, name, bases, namespace, /, **kwargs):
         cls._abc_cache = WeakSet()
         cls._abc_negative_cache = WeakSet()
         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
+        cls._abc_issubclasscheck_recursive = False
         return cls
 
     def register(cls, subclass):
@@ -65,7 +66,10 @@ def register(cls, subclass):
         if issubclass(cls, subclass):
             # This would create a cycle, which is bad for the algorithm below
             raise RuntimeError("Refusing to create an inheritance cycle")
+        # Add registry entry
         cls._abc_registry.add(subclass)
+        # Automatically include cache entry
+        cls._abc_cache.add(subclass)
         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache
         return subclass
 
@@ -139,9 +143,25 @@ def __subclasscheck__(cls, subclass):
                 return True
         # Check if it's a subclass of a subclass (recursive)
         for scls in cls.__subclasses__():
-            if issubclass(subclass, scls):
-                cls._abc_cache.add(subclass)
+            # If inside recursive issubclass check, avoid adding classes
+            # to any cache because this may drastically increase memory usage.
+            # Unfortunately, issubclass/__subclasscheck__ don't accept third
+            # argument with context, so using global context within ABCMeta.
+            # This is done only on first method call, next will use cache anyway.
+            scls_is_abc = hasattr(scls, "_abc_issubclasscheck_recursive")
+            if scls_is_abc:
+                scls._abc_issubclasscheck_recursive = True
+            try:
+                # Perform recursive check
+                result = issubclass(subclass, scls)
+            finally:
+                if scls_is_abc:
+                    scls._abc_issubclasscheck_recursive = False
+            if result:
+                if not cls._abc_issubclasscheck_recursive:
+                    cls._abc_cache.add(subclass)
                 return True
         # No dice; update negative cache
-        cls._abc_negative_cache.add(subclass)
+        if not cls._abc_issubclasscheck_recursive:
+            cls._abc_negative_cache.add(subclass)
         return False