gh-132042: Remove resolve_slotdups to speedup class creation #132156

sergey-miryanov · 2025-04-06T12:09:19Z

Removes resolve_slotdups.

Issue: Optimize class creation #132042

python-cla-bot · 2025-04-06T13:55:19Z

All commit authors signed the Contributor License Agreement.

StanFromIreland · 2025-04-06T17:08:31Z

Maybe take a look at this comment and have it in mind.

sergey-miryanov · 2025-04-06T17:17:11Z

@StanFromIreland Yeah, thanks! I just checked both scripts - and timing closely same. But I not finished main task, so results can changed.

Objects/typeobject.c

sergey-miryanov · 2025-04-09T08:05:08Z

Intermediate results:

Running Release|x64 interpreter...
Python 3.14.0a6+ (heads/gh-132042-optimize-class-creation:b0ad8754b45, Apr  9 2025, 11:38:25) [MSC v.1943 64 bit (AMD64)]

+----------------------------------------------------------------------------+---------+-----------------------+
| Benchmark                                                                  | ref     | new                   |
+============================================================================+=========+=======================+
| empty_cls-1000                                                             | 4.32 ms | 3.50 ms: 1.24x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_dunders-1000                                                      | 5.03 ms | 4.32 ms: 1.16x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-1000-A, B                                             | 5.62 ms | 3.89 ms: 1.45x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-1000-A, B                                                   | 6.18 ms | 4.62 ms: 1.34x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-1000-A, B, D                                          | 6.37 ms | 4.18 ms: 1.52x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-1000-A, B, D                                                | 6.81 ms | 4.92 ms: 1.39x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-1000-A_with_dunders, B_with_dunders                   | 5.40 ms | 3.89 ms: 1.39x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-1000-A_with_dunders, B_with_dunders                         | 6.08 ms | 4.66 ms: 1.31x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-1000-A_with_dunders, B_with_dunders, D_with_dunders   | 6.08 ms | 4.24 ms: 1.44x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-1000-A_with_dunders, B_with_dunders, D_with_dunders         | 6.79 ms | 5.01 ms: 1.36x faster |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls-100000                                                           | 436 ms  | 356 ms: 1.23x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_dunders-100000                                                    | 500 ms  | 434 ms: 1.15x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-100000-A, B                                           | 563 ms  | 387 ms: 1.46x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-100000-A, B                                                 | 612 ms  | 463 ms: 1.32x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-100000-A, B, D                                        | 631 ms  | 418 ms: 1.51x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-100000-A, B, D                                              | 683 ms  | 493 ms: 1.39x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-100000-A_with_dunders, B_with_dunders                 | 545 ms  | 389 ms: 1.40x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-100000-A_with_dunders, B_with_dunders                       | 607 ms  | 467 ms: 1.30x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| empty_cls_with_bases-100000-A_with_dunders, B_with_dunders, D_with_dunders | 609 ms  | 423 ms: 1.44x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| cls_with_bases-100000-A_with_dunders, B_with_dunders, D_with_dunders       | 679 ms  | 502 ms: 1.35x faster  |
+----------------------------------------------------------------------------+---------+-----------------------+
| Geometric mean                                                             | (ref)   | 1.35x faster          |
+----------------------------------------------------------------------------+---------+-----------------------+

b.txt

sergey-miryanov · 2025-04-09T18:49:31Z

I added tests from gh-76527 (script for testing with pyperf b.txt):

empty_cls - tests for classes without any methods
cls - tests for classes with few dunder methods
bases - with suffix _dun - base classes with few dunder methods

+---------------------------------------------------------------+----------+-----------------------+
| Benchmark                                                     | ref      | new                   |
+===============================================================+==========+=======================+
| 1000-empty_cls                                                | 4.42 ms  | 3.50 ms: 1.26x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_dunders                                         | 5.25 ms  | 4.45 ms: 1.18x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B']                    | 5.70 ms  | 3.84 ms: 1.48x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B']                          | 6.26 ms  | 4.62 ms: 1.35x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B', 'D']               | 6.49 ms  | 4.16 ms: 1.56x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B', 'D']                     | 6.97 ms  | 4.94 ms: 1.41x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun']            | 5.52 ms  | 3.89 ms: 1.42x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun']                  | 6.21 ms  | 4.67 ms: 1.33x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']   | 6.20 ms  | 4.20 ms: 1.47x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']         | 7.10 ms  | 5.02 ms: 1.42x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Logger']                    | 5.42 ms  | 4.22 ms: 1.28x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['Logger']                          | 6.05 ms  | 5.08 ms: 1.19x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['DatagramHandler']           | 6.63 ms  | 4.42 ms: 1.50x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['DatagramHandler']                 | 7.23 ms  | 5.24 ms: 1.38x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['MagicMock']                 | 7.66 ms  | 4.95 ms: 1.55x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['MagicMock']                       | 8.26 ms  | 5.74 ms: 1.44x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Shelf']                     | 9.46 ms  | 6.86 ms: 1.38x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['Shelf']                           | 10.2 ms  | 7.84 ms: 1.30x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['tuple']                     | 5.62 ms  | 4.18 ms: 1.35x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['tuple']                           | 6.33 ms  | 5.53 ms: 1.14x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['dict']                      | 5.60 ms  | 4.90 ms: 1.14x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['dict']                            | 6.30 ms  | 5.56 ms: 1.13x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-empty_cls_with_bases-bases=['list']                      | 5.99 ms  | 4.74 ms: 1.26x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 1000-cls_with_bases-bases=['list']                            | 6.68 ms  | 5.64 ms: 1.19x faster |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls                                              | 447 ms   | 354 ms: 1.26x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_dunders                                       | 510 ms   | 436 ms: 1.17x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A', 'B']                  | 569 ms   | 392 ms: 1.45x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['A', 'B']                        | 631 ms   | 470 ms: 1.34x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A', 'B', 'D']             | 644 ms   | 416 ms: 1.55x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['A', 'B', 'D']                   | 702 ms   | 499 ms: 1.41x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A_dun', 'B_dun']          | 550 ms   | 387 ms: 1.42x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['A_dun', 'B_dun']                | 627 ms   | 474 ms: 1.32x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun'] | 621 ms   | 422 ms: 1.47x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']       | 694 ms   | 509 ms: 1.36x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['Logger']                  | 540 ms   | 418 ms: 1.29x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['Logger']                        | 612 ms   | 508 ms: 1.20x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['DatagramHandler']         | 657 ms   | 441 ms: 1.49x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['DatagramHandler']               | 726 ms   | 530 ms: 1.37x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['MagicMock']               | 764 ms   | 492 ms: 1.55x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['MagicMock']                     | 828 ms   | 580 ms: 1.43x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['Shelf']                   | 954 ms   | 689 ms: 1.39x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['Shelf']                         | 1.04 sec | 784 ms: 1.33x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['tuple']                   | 558 ms   | 417 ms: 1.34x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['tuple']                         | 649 ms   | 502 ms: 1.29x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['dict']                    | 579 ms   | 464 ms: 1.25x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['dict']                          | 648 ms   | 547 ms: 1.19x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-empty_cls_with_bases-bases=['list']                    | 630 ms   | 476 ms: 1.32x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| 100000-cls_with_bases-bases=['list']                          | 686 ms   | 563 ms: 1.22x faster  |
+---------------------------------------------------------------+----------+-----------------------+
| Geometric mean                                                | (ref)    | 1.34x faster          |
+---------------------------------------------------------------+----------+-----------------------+

Also benchgcclasses2.py output:
ref:

➜ .\python.bat ..\cpython-issues\gh-132042-optimize-class-creation\benchgcclasses2.py
Running Release|x64 interpreter...
GC time: 93.8 ms
gc: collecting generation 2...
gc: objects in each generation: 0 0 905261
gc: objects in permanent generation: 0

➜ .\python.bat ..\cpython-issues\gh-132042-optimize-class-creation\benchgcclasses2.py
Running Release|x64 interpreter...
GC time: 125.0 ms
gc: collecting generation 2...
gc: objects in each generation: 0 0 905261
gc: objects in permanent generation: 0
RSS:

new:

➜ .\python.bat ..\cpython-issues\gh-132042-optimize-class-creation\benchgcclasses2.py
Running Release|x64 interpreter...
GC time: 109.4 ms
gc: collecting generation 2...
gc: objects in each generation: 0 0 905262
gc: objects in permanent generation: 0
RSS:

➜ .\python.bat ..\cpython-issues\gh-132042-optimize-class-creation\benchgcclasses2.py
Running Release|x64 interpreter...
GC time: 125.0 ms
gc: collecting generation 2...
gc: objects in each generation: 0 0 905262
gc: objects in permanent generation: 0
RSS:

Time varies, I'm not sure it is statistically significant. Count of objects closely the same.

Async import time (➜ .\python.bat -X importtime -c 'import asyncio'):
ref:

import time:      1116 |      86283 | asyncio

new:

import time:      1014 |      82194 | asyncio

…solve_slotdups

sergey-miryanov · 2025-04-09T20:33:37Z

Remove resolve_slotdups (new2):

+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| Benchmark                                                   | ref     | new                   | new2                  |
+=============================================================+=========+=======================+=======================+
| 1000-empty_cls                                              | 4.42 ms | 3.50 ms: 1.26x faster | 3.37 ms: 1.31x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_dunders                                       | 5.25 ms | 4.45 ms: 1.18x faster | 4.38 ms: 1.20x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B']                  | 5.70 ms | 3.84 ms: 1.48x faster | 3.68 ms: 1.55x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B']                        | 6.26 ms | 4.62 ms: 1.35x faster | 4.51 ms: 1.39x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B', 'D']             | 6.49 ms | 4.16 ms: 1.56x faster | 4.00 ms: 1.62x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B', 'D']                   | 6.97 ms | 4.94 ms: 1.41x faster | 4.80 ms: 1.45x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun']          | 5.52 ms | 3.89 ms: 1.42x faster | 3.74 ms: 1.48x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun']                | 6.21 ms | 4.67 ms: 1.33x faster | 4.55 ms: 1.36x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun'] | 6.20 ms | 4.20 ms: 1.47x faster | 4.08 ms: 1.52x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']       | 7.10 ms | 5.02 ms: 1.42x faster | 4.89 ms: 1.45x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Logger']                  | 5.42 ms | 4.22 ms: 1.28x faster | 4.06 ms: 1.33x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['Logger']                        | 6.05 ms | 5.08 ms: 1.19x faster | 4.97 ms: 1.22x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['DatagramHandler']         | 6.63 ms | 4.42 ms: 1.50x faster | 4.26 ms: 1.56x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['DatagramHandler']               | 7.23 ms | 5.24 ms: 1.38x faster | 5.09 ms: 1.42x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['MagicMock']               | 7.66 ms | 4.95 ms: 1.55x faster | 4.83 ms: 1.59x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['MagicMock']                     | 8.26 ms | 5.74 ms: 1.44x faster | 5.64 ms: 1.46x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Shelf']                   | 9.46 ms | 6.86 ms: 1.38x faster | 6.67 ms: 1.42x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['Shelf']                         | 10.2 ms | 7.84 ms: 1.30x faster | 7.62 ms: 1.34x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['tuple']                   | 5.62 ms | 4.18 ms: 1.35x faster | 3.82 ms: 1.47x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['tuple']                         | 6.33 ms | 5.53 ms: 1.14x faster | 4.57 ms: 1.39x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['dict']                    | 5.60 ms | 4.90 ms: 1.14x faster | 4.32 ms: 1.30x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['dict']                          | 6.30 ms | 5.56 ms: 1.13x faster | 5.15 ms: 1.22x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-empty_cls_with_bases-bases=['list']                    | 5.99 ms | 4.74 ms: 1.26x faster | 4.39 ms: 1.36x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| 1000-cls_with_bases-bases=['list']                          | 6.68 ms | 5.64 ms: 1.19x faster | 5.18 ms: 1.29x faster |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+
| Geometric mean                                              | (ref)   | 1.34x faster          | 1.40x faster          |
+-------------------------------------------------------------+---------+-----------------------+-----------------------+

…d_objects

sergey-miryanov · 2025-04-09T20:55:11Z

It is ready to review. Please take a look.

Objects/typeobject.c

vstinner · 2025-04-15T14:45:56Z

Objects/typeobject.c

@@ -4432,30 +4425,33 @@ type_new_set_attrs(const type_new_ctx *ctx, PyTypeObject *type)
        return -1;
    }

-    if (type_new_set_module(type) < 0) {
+    PyObject *dict = lookup_tp_dict(type);


Would it be possible to extract this change into a separated PR? It seems to be a perfectly reasonable change, but it's not directly renamed to "name_count".

There are three optimizations - I will move each of them to own PR.

I moved other two optimizations to separate PRs. Please take a look. Also, I think that news entry is not actual anymore and it is better to add it after all this PRs will be merged/rejected. WDYT?

vstinner · 2025-04-15T14:46:17Z

Include/cpython/descrobject.h

@@ -16,6 +16,7 @@ struct wrapperbase {
    const char *doc;
    int flags;
    PyObject *name_strobj;
+    uint8_t name_count;


Please add a comment explaining the purpose of this member and how it's computed. You can mention _PyType_InitSlotDefsNameCounts().

Added a comment. Please take a look is this clear enough.

Co-authored-by: Victor Stinner <vstinner@python.org>

This reverts commit 1eed75d.

This reverts commit 56d13fc.

sergey-miryanov · 2025-04-20T10:01:52Z

Updated results - only for remove resolve_slotdups (ran windows 11 x64 desktop, cpu- 11th Gen Intel(R) Core(TM) i5-11600K @ 3.90GHz):

+---------------------------------------------------------------+---------+-----------------------+
| Benchmark                                                     | ref     | dups                  |
+===============================================================+=========+=======================+
| 1000-empty_cls                                                | 4.41 ms | 3.67 ms: 1.20x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_dunders                                         | 5.03 ms | 4.41 ms: 1.14x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B']                    | 5.49 ms | 4.77 ms: 1.15x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B']                          | 6.00 ms | 5.50 ms: 1.09x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A', 'B', 'D']               | 6.17 ms | 5.47 ms: 1.13x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['A', 'B', 'D']                     | 6.71 ms | 6.18 ms: 1.09x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun']            | 5.29 ms | 4.72 ms: 1.12x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun']                  | 5.99 ms | 5.47 ms: 1.09x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']   | 5.95 ms | 5.39 ms: 1.10x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']         | 6.86 ms | 6.15 ms: 1.12x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Logger']                    | 5.16 ms | 4.57 ms: 1.13x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['Logger']                          | 5.86 ms | 5.30 ms: 1.11x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['DatagramHandler']           | 6.32 ms | 5.65 ms: 1.12x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['DatagramHandler']                 | 6.93 ms | 6.42 ms: 1.08x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['MagicMock']                 | 7.24 ms | 6.79 ms: 1.07x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['MagicMock']                       | 7.87 ms | 7.70 ms: 1.02x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['Shelf']                     | 9.16 ms | 8.58 ms: 1.07x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['Shelf']                           | 9.84 ms | 9.37 ms: 1.05x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['tuple']                     | 5.53 ms | 4.19 ms: 1.32x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['tuple']                           | 6.17 ms | 4.99 ms: 1.24x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['dict']                      | 5.48 ms | 4.35 ms: 1.26x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['dict']                            | 6.14 ms | 5.10 ms: 1.20x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-empty_cls_with_bases-bases=['list']                      | 5.88 ms | 4.30 ms: 1.37x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 1000-cls_with_bases-bases=['list']                            | 6.55 ms | 5.10 ms: 1.28x faster |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls                                              | 443 ms  | 368 ms: 1.20x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_dunders                                       | 504 ms  | 440 ms: 1.14x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A', 'B']                  | 547 ms  | 476 ms: 1.15x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['A', 'B']                        | 606 ms  | 555 ms: 1.09x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A', 'B', 'D']             | 615 ms  | 545 ms: 1.13x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['A', 'B', 'D']                   | 673 ms  | 624 ms: 1.08x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A_dun', 'B_dun']          | 531 ms  | 469 ms: 1.13x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['A_dun', 'B_dun']                | 605 ms  | 552 ms: 1.10x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun'] | 598 ms  | 536 ms: 1.12x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['A_dun', 'B_dun', 'D_dun']       | 671 ms  | 621 ms: 1.08x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['Logger']                  | 520 ms  | 457 ms: 1.14x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['Logger']                        | 588 ms  | 538 ms: 1.09x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['DatagramHandler']         | 630 ms  | 567 ms: 1.11x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['DatagramHandler']               | 693 ms  | 644 ms: 1.08x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['MagicMock']               | 721 ms  | 673 ms: 1.07x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['MagicMock']                     | 783 ms  | 751 ms: 1.04x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['Shelf']                   | 918 ms  | 865 ms: 1.06x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['Shelf']                         | 998 ms  | 950 ms: 1.05x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['tuple']                   | 552 ms  | 420 ms: 1.31x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['tuple']                         | 622 ms  | 503 ms: 1.24x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['dict']                    | 550 ms  | 434 ms: 1.27x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['dict']                          | 616 ms  | 513 ms: 1.20x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-empty_cls_with_bases-bases=['list']                    | 595 ms  | 431 ms: 1.38x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| 100000-cls_with_bases-bases=['list']                          | 656 ms  | 511 ms: 1.28x faster  |
+---------------------------------------------------------------+---------+-----------------------+
| Geometric mean                                                | (ref)   | 1.14x faster          |
+---------------------------------------------------------------+---------+-----------------------+

sergey-miryanov added 2 commits April 6, 2025 17:08

Prebuild mro_dict for find_name_in_mro

56d13fc

Preget tp_dict

1eed75d

bedevere-app bot mentioned this pull request Apr 6, 2025

Optimize class creation #132042

Open

Slotdefs cache

bba66d6

sergey-miryanov commented Apr 7, 2025

View reviewed changes

Objects/typeobject.c Outdated Show resolved Hide resolved

AA-Turner added the interpreter-core (Objects, Python, Grammar, and Parser dirs) label Apr 7, 2025

sergey-miryanov added 4 commits April 9, 2025 00:43

Move slotdefs_cache to interp

bac95a5

Use bytes for slotdefs_cache

8d1f5be

Use type_slots_ptrs cache

8cf19e8

Move slotdefs_cache init to pycore_init_builtins

b0ad875

sergey-miryanov added 3 commits April 10, 2025 00:22

Create slotdefs_cache only for main interpreter

79a165d

Do not iterate slotdefs_cache just check dups count

a853294

Add name_count to pytype_slotdef and get rid of slotdefs_cache and re…

75c17fb

…solve_slotdups

sergey-miryanov added 3 commits April 10, 2025 01:36

Rename _PyType_InitSlotDefsCache to _PyType_InitSlotDefsNameCounts

fc17a68

Get rid of type_slots_ptrs and type_slots_pname from _Py_interp_cache…

736bca4

…d_objects

Add news entry

1341ed9

sergey-miryanov marked this pull request as ready for review April 9, 2025 20:54

sergey-miryanov requested review from ericsnowcurrently and markshannon as code owners April 9, 2025 20:54

bedevere-app bot added the awaiting review label Apr 9, 2025

sergey-miryanov mentioned this pull request Apr 10, 2025

gh-127266: avoid data races when updating type slots #131174

Open

vstinner reviewed Apr 15, 2025

View reviewed changes

Rename _PyType_InitSlotDefsNameCounts

3efb9ca

Co-authored-by: Victor Stinner <vstinner@python.org>

sergey-miryanov added 3 commits April 17, 2025 00:52

Use

a792e9d

Revert "Preget tp_dict"

b6fafa9

This reverts commit 1eed75d.

Revert "Prebuild mro_dict for find_name_in_mro"

1459c16

This reverts commit 56d13fc.

sergey-miryanov changed the title ~~gh-132042: Try to optimize class creation~~ gh-132042: Remove resolve_slotdups to speedup class creation Apr 16, 2025

Update _PyType_InitSlotDefs and add comment for wrapperbase.name_count

08740af

This was referenced Apr 16, 2025

gh-132042: Prebuild mro_dict for find_name_in_mro to speedup class creation #132618

Open

gh-132042: Do not lookup tp_dict each time to speedup class creation #132619

Merged

sergey-miryanov added 2 commits April 17, 2025 02:40

Fix error message if _PyType_InitSlotDefs fails

0370d59

Merge branch 'main' into pythongh-132042-optimize-class-creation

c2372f1

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

gh-132042: Remove resolve_slotdups to speedup class creation #132156

gh-132042: Remove resolve_slotdups to speedup class creation #132156

sergey-miryanov commented Apr 6, 2025 •

edited

Loading

python-cla-bot bot commented Apr 6, 2025

StanFromIreland commented Apr 6, 2025

sergey-miryanov commented Apr 6, 2025

sergey-miryanov commented Apr 9, 2025 •

edited

Loading

sergey-miryanov commented Apr 9, 2025 •

edited

Loading

sergey-miryanov commented Apr 9, 2025

sergey-miryanov commented Apr 9, 2025

vstinner Apr 15, 2025

sergey-miryanov Apr 16, 2025

sergey-miryanov Apr 16, 2025

vstinner Apr 15, 2025

sergey-miryanov Apr 16, 2025

sergey-miryanov commented Apr 20, 2025

gh-132042: Remove resolve_slotdups to speedup class creation #132156

Are you sure you want to change the base?

gh-132042: Remove resolve_slotdups to speedup class creation #132156

Conversation

sergey-miryanov commented Apr 6, 2025 • edited Loading

python-cla-bot bot commented Apr 6, 2025

StanFromIreland commented Apr 6, 2025

sergey-miryanov commented Apr 6, 2025

sergey-miryanov commented Apr 9, 2025 • edited Loading

sergey-miryanov commented Apr 9, 2025 • edited Loading

sergey-miryanov commented Apr 9, 2025

sergey-miryanov commented Apr 9, 2025

vstinner Apr 15, 2025

Choose a reason for hiding this comment

sergey-miryanov Apr 16, 2025

Choose a reason for hiding this comment

sergey-miryanov Apr 16, 2025

Choose a reason for hiding this comment

vstinner Apr 15, 2025

Choose a reason for hiding this comment

sergey-miryanov Apr 16, 2025

Choose a reason for hiding this comment

sergey-miryanov commented Apr 20, 2025

sergey-miryanov commented Apr 6, 2025 •

edited

Loading

sergey-miryanov commented Apr 9, 2025 •

edited

Loading

sergey-miryanov commented Apr 9, 2025 •

edited

Loading