gh-92810: Reduce memory usage by ABCMeta.subclasscheck #131914

dolfinus · 2025-03-30T17:13:58Z

Issue: _abc._abc_subclasscheck has very poor performance and (I think) a memory leak #92810

test_performance_abc.py

from abc import ABCMeta
#from _py_abc import ABCMeta
import time
import psutil
import os

class Root(metaclass=ABCMeta):
    pass

class Class1(Root):
    pass

class Class2(Root):
    pass

class Class3(Root):
    pass

class Class4(Root):
    subclasses = []
    @classmethod
    def __subclasses__(cls):
        return cls.subclasses


def _create_subclass1():
    class NestedClass1(Class1):
        pass

    return NestedClass1


def _create_subclass2():
    class NestedClass2(Class2):
        pass

    return NestedClass2


def _create_subclass3():
    class NestedClass3:
        pass

    Class3.register(NestedClass3)

    return NestedClass3


def _create_subclass4():
    class NestedClass4:
        pass

    Class4.subclasses.append(NestedClass4)

    return NestedClass4


def test_performance():
    iters = 2000
    print("Creating new classes to check")
    objects_subclass1 = []
    for i in range(iters):
        subclass1 = _create_subclass1()
        objects_subclass1.append(subclass1())
    objects_subclass2 = []
    for i in range(iters):
        subclass2 = _create_subclass2()
        objects_subclass2.append(subclass2())

    objects_subclass3 = []
    for i in range(iters):
        subclass3 = _create_subclass3()
        objects_subclass3.append(subclass3())

    objects_subclass4 = []
    for i in range(iters):
        subclass4 = _create_subclass4()
        objects_subclass4.append(subclass4())

    # create one more subclass for sibling check
    another_subclass1 = _create_subclass1()
    another_subclass2 = _create_subclass2()
    another_subclass3 = _create_subclass3()
    another_subclass4 = _create_subclass4()

    print("Created subclasses =", len(objects_subclass1) + len(objects_subclass2) + len(objects_subclass3) + len(objects_subclass4))
    print("Consumed memory, Mb:", psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)
    print("Started compairing objects")

    # New subclass against parent, sibling, grantparent and cousin
    new_subclass1_vs_class1_ns = 0
    new_subclass1_vs_another_subclass1_ns = 0
    new_subclass1_vs_root_ns = 0
    new_subclass1_vs_class2_ns = 0
    for obj1 in objects_subclass1:
        start = time.perf_counter_ns()
        assert isinstance(obj1, Class1)
        new_subclass1_vs_class1_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj1, another_subclass1)
        new_subclass1_vs_another_subclass1_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj1, Root)
        new_subclass1_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj1, Class2)
        new_subclass1_vs_class2_ns += time.perf_counter_ns() - start

    # Same subclass against parent, sibling, grantparent and cousin
    cached_subclass1_vs_root_ns = 0
    cached_subclass1_vs_another_subclass1_ns = 0
    cached_subclass1_vs_class1_ns = 0
    cached_subclass1_vs_class2_ns = 0
    for _ in range(iters):
        start = time.perf_counter_ns()
        assert isinstance(obj1, Class1)
        cached_subclass1_vs_class1_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj1, another_subclass1)
        cached_subclass1_vs_another_subclass1_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj1, Root)
        cached_subclass1_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj1, Class2)
        cached_subclass1_vs_class2_ns += time.perf_counter_ns() - start

    # new class (via .register) against parent, sibling, grantparent and cousin
    new_subclass3_vs_class3_ns = 0
    new_subclass3_vs_another_subclass3_ns = 0
    new_subclass3_vs_root_ns = 0
    new_subclass3_vs_class1_ns = 0
    for obj3 in objects_subclass3:
        start = time.perf_counter_ns()
        assert isinstance(obj3, Class3)
        new_subclass3_vs_class3_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj3, another_subclass3)
        new_subclass3_vs_another_subclass3_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj3, Root)
        new_subclass3_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj3, Class1)
        new_subclass3_vs_class1_ns += time.perf_counter_ns() - start

    # same class (via .register) against parent, sibling, grantparent and cousin
    cached_subclass3_vs_class3_ns = 0
    cached_subclass3_vs_another_subclass3_ns = 0
    cached_subclass3_vs_root_ns = 0
    cached_subclass3_vs_class1_ns = 0
    for _ in range(iters):
        start = time.perf_counter_ns()
        assert isinstance(obj3, Class3)
        cached_subclass3_vs_class3_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj3, another_subclass3)
        cached_subclass3_vs_another_subclass3_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj3, Root)
        cached_subclass3_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj3, Class1)
        cached_subclass3_vs_class1_ns += time.perf_counter_ns() - start

    # new class (via __subclasses__) against parent, sibling, grantparent and cousin
    new_subclass4_vs_class4_ns = 0
    new_subclass4_vs_another_subclass4_ns = 0
    new_subclass4_vs_root_ns = 0
    new_subclass4_vs_class1_ns = 0
    for obj4 in objects_subclass4:
        start = time.perf_counter_ns()
        assert isinstance(obj4, Class4)
        new_subclass4_vs_class4_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj4, another_subclass4)
        new_subclass4_vs_another_subclass4_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj4, Root)
        new_subclass4_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj4, Class1)
        new_subclass4_vs_class1_ns += time.perf_counter_ns() - start

    # same class (via __subclasses__) against parent, sibling, grantparent and cousin
    cached_subclass4_vs_class4_ns = 0
    cached_subclass4_vs_another_subclass4_ns = 0
    cached_subclass4_vs_root_ns = 0
    cached_subclass4_vs_class1_ns = 0
    for _ in range(iters):
        start = time.perf_counter_ns()
        assert isinstance(obj4, Class4)
        cached_subclass4_vs_class4_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj4, another_subclass4)
        cached_subclass4_vs_another_subclass4_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert isinstance(obj4, Root)
        cached_subclass4_vs_root_ns += time.perf_counter_ns() - start

        start = time.perf_counter_ns()
        assert not isinstance(obj4, Class1)
        cached_subclass4_vs_class1_ns += time.perf_counter_ns() - start

    print("Completed compairing classes.")
    print("Consumed memory, Mb:", psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)

    total_ns = sum([
        cached_subclass1_vs_root_ns,
        cached_subclass1_vs_another_subclass1_ns,
        cached_subclass1_vs_class1_ns,
        cached_subclass1_vs_class2_ns,
        cached_subclass3_vs_class3_ns,
        cached_subclass3_vs_another_subclass3_ns,
        cached_subclass3_vs_root_ns,
        cached_subclass3_vs_class1_ns,
        cached_subclass4_vs_class4_ns,
        cached_subclass4_vs_another_subclass4_ns,
        cached_subclass4_vs_root_ns,
        cached_subclass4_vs_class1_ns,
        new_subclass1_vs_class1_ns,
        new_subclass1_vs_another_subclass1_ns,
        new_subclass1_vs_root_ns,
        new_subclass1_vs_class2_ns,
        new_subclass3_vs_class3_ns,
        new_subclass3_vs_another_subclass3_ns,
        new_subclass3_vs_root_ns,
        new_subclass3_vs_class1_ns,
        new_subclass4_vs_class4_ns,
        new_subclass4_vs_another_subclass4_ns,
        new_subclass4_vs_root_ns,
        new_subclass4_vs_class1_ns,
    ])
    print("Total, sec:", total_ns / 10**9)

    print("isinstance(cached class, parent), us:", cached_subclass1_vs_root_ns / iters / 1000)
    print("isinstance(cached class, sibling), us:", cached_subclass1_vs_another_subclass1_ns / iters / 1000)
    print("isinstance(cached class, grandparent), us:", cached_subclass1_vs_class1_ns / iters / 1000)
    print("isinstance(cached class, cousin), us:", cached_subclass1_vs_class2_ns / iters / 1000)

    print("isinstance(cached class, parent via .register()), us:", cached_subclass3_vs_class3_ns / iters / 1000)
    print("isinstance(cached class, sibling via .register()), us:", cached_subclass3_vs_another_subclass3_ns / iters / 1000)
    print("isinstance(cached class, grandparent via .register()), us:", cached_subclass3_vs_root_ns / iters / 1000)
    print("isinstance(cached class, cousin via .register()), us:", cached_subclass3_vs_class1_ns / iters / 1000)

    print("isinstance(cached class, parent via __subclasses__), us:", cached_subclass4_vs_class4_ns / iters / 1000)
    print("isinstance(cached class, sibling via __subclasses__), us:", cached_subclass4_vs_another_subclass4_ns / iters / 1000)
    print("isinstance(cached class, grandparent via __subclasses__), us:", cached_subclass4_vs_root_ns / iters / 1000)
    print("isinstance(cached class, cousin via __subclasses__), us:", cached_subclass4_vs_class1_ns / iters / 1000)

    print("isinstance(new class, parent), us:", new_subclass1_vs_class1_ns / len(objects_subclass1) / 1000)
    print("isinstance(new class, sibling), us:", new_subclass1_vs_another_subclass1_ns / len(objects_subclass1) / 1000)
    print("isinstance(new class, grandparent), us:", new_subclass1_vs_root_ns / len(objects_subclass1) / 1000)
    print("isinstance(new class, cousin), us:", new_subclass1_vs_class2_ns / len(objects_subclass1) / 1000)

    print("isinstance(new class, parent via .register()), us:", new_subclass3_vs_class3_ns / len(objects_subclass3) / 1000)
    print("isinstance(new class, sibling via .register()), us:", new_subclass3_vs_another_subclass3_ns / len(objects_subclass3) / 1000)
    print("isinstance(new class, grandparent via .register()), us:", new_subclass3_vs_root_ns / len(objects_subclass3) / 1000)
    print("isinstance(new class, cousin via .register()), us:", new_subclass3_vs_class1_ns / len(objects_subclass3) / 1000)

    print("isinstance(new class, parent via __subclasses__), us:", new_subclass4_vs_class4_ns / len(objects_subclass4) / 1000)
    print("isinstance(new class, sibling via __subclasses__), us:", new_subclass4_vs_another_subclass4_ns / len(objects_subclass4) / 1000)
    print("isinstance(new class, grandparent via __subclasses__), us:", new_subclass4_vs_root_ns / len(objects_subclass4) / 1000)
    print("isinstance(new class, cousin via __subclasses__), us:", new_subclass4_vs_class1_ns / len(objects_subclass4) / 1000)


if __name__ == "__main__":
    test_performance()

For 8k nested subclasses:

Impl	Memory before, MB	Memory after, MB
_abc	5304.320	47.453
_py_abc	3469.648	53.980

Impl	Total time before, seconds	Total time after, seconds
_abc	512.120	66.352
_py_abc	323.217	260.137

Check	Impl	us per check, before	us per check, after	Impl	us per check, before	us per check, after
`isinstance(cached class, parent)`	_abc	2.061	1.515	_py_abc	2.411	2.185
`isinstance(cached class, sibling)`	_abc	2.027	1.470	_py_abc	3.900	3.614
`isinstance(cached class, grandparent)`	_abc	2.073	1.514	_py_abc	2.395	2.173
`isinstance(cached class, cousin)`	_abc	2.058	1.482	_py_abc	3.903	3.608
`isinstance(cached class, parent via .register())`	_abc	1.901	2.071	_py_abc	2.555	2.243
`isinstance(cached class, sibling via .register())`	_abc	0.417	0.467	_py_abc	0.522	0.455
`isinstance(cached class, grandparent via .register())`	_abc	1.133	1.213	_py_abc	2.500	2.233
`isinstance(cached class, cousin via .register())`	_abc	1.152	1.251	_py_abc	4.087	3.805
`isinstance(cached class, parent via __subclasses__)`	_abc	1.619	1.317	_py_abc	2.032	2.349
`isinstance(cached class, sibling via __subclasses__)`	_abc	0.607	0.430	_py_abc	0.422	0.484
`isinstance(cached class, grandparent via __subclasses__)`	_abc	1.642	1.188	_py_abc	2.039	2.313
`isinstance(cached class, cousin via __subclasses__)`	_abc	1.678	1.217	_py_abc	3.351	3.956
`isinstance(new class, parent)`	_abc	7.125	7.546	_py_abc	12.892	14.153
`isinstance(new class, sibling)`	_abc	6.337	6.069	_py_abc	13.839	15.672
`isinstance(new class, grandparent)`	_abc	3.606	4.028	_py_abc	9.841	10.264
`isinstance(new class, cousin)`	_abc	15_164.291	4_489.091	_py_abc	20_130.58	17_344.474
`isinstance(new class, parent via .register())`	_abc	4.005	7.557	_py_abc	707.748	739.004
`isinstance(new class, sibling via .register())`	_abc	0.967	1.144	_py_abc	1.475	1.624
`isinstance(new class, grandparent via .register())`	_abc	80_945.567	9_185.747	_py_abc	59_578.90	37_271.663
`isinstance(new class, cousin via .register())`	_abc	4.026	4_630.594	_py_abc	7.661	18_586.478
`isinstance(new class, parent via __subclasses__)`	_abc	83.738	350.901	_py_abc	223.813	496.861
`isinstance(new class, sibling via __subclasses__)`	_abc	1.323	1.464	_py_abc	1.136	1.348
`isinstance(new class, grandparent via __subclasses__)`	_abc	159_816.392	9_749.391	_py_abc	80_883.07	37_469.294
`isinstance(new class, cousin via __subclasses__)`	_abc	4.323	4_727.533	_py_abc	7.663	18_088.251

bedevere-app · 2025-03-30T17:14:02Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

Lib/_py_abc.py

Modules/_abc.c

picnixz · 2025-03-30T17:42:23Z

Modules/_abc.c

+          if (scls == NULL) {
+              goto end;
+          }
+          int r = PyObject_IsSubclass(subclass, scls);


I think we have a UAF here. PyObject_IsSubclass can call __subclasscheck__ which can itseslf call arbitrary code so you might mutate subclasses. The issue already exists with the existing code but can you confirm that we can indeed produce a UAF? (if you don't know how to do it, I'll try to investigate this separately tomorrow)

can you confirm that we can indeed produce a UAF?

Sorry, my C knowledge is very minimal, I don't know anything about this yet

Lib/test/test_abstract_numbers.py

Lib/test/test_abc.py

bedevere-app · 2025-03-31T11:24:02Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-03-31T11:25:30Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-03-31T11:26:44Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-03-31T11:29:01Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

Lib/test/test_abc.py

Lib/_py_abc.py

Lib/test/test_isinstance.py

python-cla-bot · 2025-04-06T13:56:20Z

All commit authors signed the Contributor License Agreement.

bedevere-app · 2025-04-21T10:57:37Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

Signed-off-by: Martynov Maxim <[email protected]>

bedevere-app · 2025-04-21T11:04:00Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-04-21T11:05:29Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-04-21T11:18:13Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-06-13T14:09:23Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

bedevere-app · 2025-06-13T14:14:44Z

Most changes to Python require a NEWS entry. Add one using the blurb_it web app or the blurb command-line tool.

If this change has little impact on Python users, wait for a maintainer to apply the skip news label instead.

dolfinus · 2025-06-13T14:24:08Z

I've added a simple recursion check to cls.__subclasses__() clause, both to _py_abc and _abc. This avoids adding the same class to all ABC children class caches, reducing both memory usage and time for very large class trees. Microbenchmark & results are in the description.

picnixz · 2025-06-22T08:46:50Z

Lib/_py_abc.py

+        # Invalidate negative cache
+        ABCMeta._abc_invalidation_counter += 1


This change is not needed

picnixz · 2025-06-22T08:47:13Z

Lib/_py_abc.py

@@ -137,11 +139,29 @@ def __subclasscheck__(cls, subclass):
            if issubclass(subclass, rcls):
                cls._abc_cache.add(subclass)
                return True
+


Suggested change

The comment after serves as the separation.

picnixz · 2025-06-22T08:47:30Z

Lib/_py_abc.py

        # 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


Reflow it under 80 chars.

picnixz · 2025-06-22T08:47:44Z

Lib/_py_abc.py

+            if scls_is_abc:
+                scls._abc_issubclasscheck_recursive = True
+
+            try:
+                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


Suggested change

if scls_is_abc:

scls._abc_issubclasscheck_recursive = True

try:

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

if scls_is_abc:

scls._abc_issubclasscheck_recursive = True

try:

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

picnixz · 2025-06-22T08:48:09Z

Lib/_py_abc.py

+
+        if not cls._abc_issubclasscheck_recursive:
+            cls._abc_negative_cache.add(subclass)


Suggested change

if not cls._abc_issubclasscheck_recursive:

cls._abc_negative_cache.add(subclass)

# No dice; update negative cache

if not cls._abc_issubclasscheck_recursive:

cls._abc_negative_cache.add(subclass)

picnixz · 2025-06-22T08:48:35Z

Lib/test/test_abc.py

+                pass
+            a = A()


Suggested change

pass

a = A()

pass

a = A()

picnixz · 2025-06-22T08:50:13Z

Misc/NEWS.d/next/Core_and_Builtins/2025-06-13-17-22-34.gh-issue-92810.Tb6x6C.rst

+Reduce memory usage by :meth:`~type.__subclasscheck__`
+for :class:`abc.ABCMeta` and large class trees


Suggested change

Reduce memory usage by :meth:`~type.__subclasscheck__`

for :class:`abc.ABCMeta` and large class trees

Reduce memory usage by :meth:`~type.__subclasscheck__`

for :class:`abc.ABCMeta` and large class trees.

picnixz · 2025-06-22T08:53:11Z

Modules/_abc.c

+static inline bool
+is_issubclasscheck_recursive(_abc_data *impl)
+{
+    return impl->_abc_issubclasscheck_recursive;


This won't be safe on free-threaded builds. Atomic store/load are needed. And since we don't have atomic store/loads for bools, use an uint8/int here for the flag (and due to alignment constraints, using bool won't save memory)

picnixz · 2025-06-22T08:54:48Z

Modules/_abc.c

@@ -814,23 +852,46 @@ _abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
        if (scls == NULL) {
            goto end;
        }
+
+        _abc_data *scls_impl = _get_impl_optional(module, scls);


This may raise so you need to check this.

picnixz · 2025-06-22T09:00:19Z

Modules/_abc.c

@@ -177,6 +197,23 @@ _get_impl(PyObject *module, PyObject *self)
    return (_abc_data *)impl;
 }

+static _abc_data *
+_get_impl_optional(PyObject *module, PyObject *self)


Since this can return NULL with or without an exception, I suggest changing it to:

static int _get_impl_optional(_abc_data **res, PyObject *module, PyObject *self);

and return 0 if the attribute doesn't exist, -1 if there is an error and 1 if it succeeds. In the first two cases, set *res = NULL.

bedevere-app bot mentioned this pull request Mar 30, 2025

_abc._abc_subclasscheck has very poor performance and (I think) a memory leak #92810

Open

picnixz reviewed Mar 30, 2025

View reviewed changes

picnixz reviewed Apr 1, 2025

View reviewed changes

Lib/test/test_abc.py Outdated Show resolved Hide resolved

Lib/test/test_abc.py Outdated Show resolved Hide resolved

Lib/_py_abc.py Outdated Show resolved Hide resolved

picnixz reviewed Apr 1, 2025

View reviewed changes

Lib/test/test_isinstance.py Outdated Show resolved Hide resolved

Lib/test/test_isinstance.py Outdated Show resolved Hide resolved

Viicos mentioned this pull request Apr 1, 2025

Warn if registering virtual subclasses on Pydantic models pydantic/pydantic#11669

Draft

5 tasks

dolfinus added 6 commits April 21, 2025 14:03

pythongh-92810: Avoid O(n^2) complexity in ABCMeta.__subclasscheck__

675bec5

Signed-off-by: Martynov Maxim <[email protected]>

pythongh-92810: Apply fixes

701ecc9

Signed-off-by: Martynov Maxim <[email protected]>

pythongh-92810: Apply fixes

041f109

Signed-off-by: Martynov Maxim <[email protected]>

pythongh-92810: Apply fixes

9bc4385

Signed-off-by: Martynov Maxim <[email protected]>

pythongh-92810: Apply fixes

3d80b1e

Signed-off-by: Martynov Maxim <[email protected]>

pythongh-92810: Return __subclasses__clause back

b7603e0

dolfinus force-pushed the improvement/ABCMeta_subclasscheck branch from abf4bfe to b7603e0 Compare April 21, 2025 11:03

pythongh-92810: Revert _abc.c changes

dd0d18c

pythongh-92810: Fix linter errors

8d695fd

dolfinus changed the title ~~gh-92810: Avoid O(n^2) complexity in ABCMeta.__subclasscheck__~~ gh-92810: Reduce memory usage by ABCMeta.__subclasscheck__ Apr 23, 2025

Viicos mentioned this pull request Apr 29, 2025

pydantic using abc which can have memory and performance issues pydantic/pydantic#11605

Open

1 task

pythongh-92810: Add recursive issubclass check to _abc.c

a2650b6

pythongh-92810: Remove WeakKeyDictionary from _py_abc

7afa5ea

dolfinus marked this pull request as ready for review June 13, 2025 14:15

bedevere-app bot added the awaiting review label Jun 13, 2025

dolfinus requested a review from picnixz June 13, 2025 14:16

pythongh-92810: Add news entry

57980d3

pythongh-92810: Fix news entry

bbaf38a

picnixz reviewed Jun 22, 2025

View reviewed changes

		# Invalidate negative cache
		ABCMeta._abc_invalidation_counter += 1


		if not cls._abc_issubclasscheck_recursive:
		cls._abc_negative_cache.add(subclass)

-                pass
-            a = A()
+                pass
+            a = A()

		Reduce memory usage by :meth:`~type.__subclasscheck__`
		for :class:`abc.ABCMeta` and large class trees

Uh oh!

gh-92810: Reduce memory usage by ABCMeta.__subclasscheck__ #131914

Are you sure you want to change the base?

gh-92810: Reduce memory usage by ABCMeta.__subclasscheck__ #131914

Conversation

dolfinus commented Mar 30, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

bedevere-app bot commented Mar 30, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

bedevere-app bot commented Mar 31, 2025

Uh oh!

bedevere-app bot commented Mar 31, 2025

Uh oh!

bedevere-app bot commented Mar 31, 2025

Uh oh!

bedevere-app bot commented Mar 31, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

python-cla-bot bot commented Apr 6, 2025

Uh oh!

bedevere-app bot commented Apr 21, 2025

Uh oh!

bedevere-app bot commented Apr 21, 2025

Uh oh!

bedevere-app bot commented Apr 21, 2025

Uh oh!

bedevere-app bot commented Apr 21, 2025

Uh oh!

bedevere-app bot commented Jun 13, 2025

Uh oh!

bedevere-app bot commented Jun 13, 2025

Uh oh!

dolfinus commented Jun 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

gh-92810: Reduce memory usage by ABCMeta.subclasscheck #131914

gh-92810: Reduce memory usage by ABCMeta.subclasscheck #131914

dolfinus commented Mar 30, 2025 •

edited

Loading

dolfinus commented Jun 13, 2025 •

edited

Loading