gh-87729: specialize LOAD_SUPER_ATTR_METHOD (#103809)

Author: carljm

Include/internal/pycore_code.h

@@ -51,6 +51,15 @@ typedef struct {
 
 #define INLINE_CACHE_ENTRIES_BINARY_SUBSCR CACHE_ENTRIES(_PyBinarySubscrCache)
 
+typedef struct {
+    uint16_t counter;
+    uint16_t class_version[2];
+    uint16_t self_type_version[2];
+    uint16_t method[4];
+} _PySuperAttrCache;
+
+#define INLINE_CACHE_ENTRIES_LOAD_SUPER_ATTR CACHE_ENTRIES(_PySuperAttrCache)
+
 typedef struct {
     uint16_t counter;
     uint16_t version[2];
@@ -217,6 +226,8 @@ extern int _PyLineTable_PreviousAddressRange(PyCodeAddressRange *range);
 
 /* Specialization functions */
 
+extern void _Py_Specialize_LoadSuperAttr(PyObject *global_super, PyObject *class, PyObject *self,
+                                         _Py_CODEUNIT *instr, PyObject *name, int load_method);
 extern void _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr,
                                     PyObject *name);
 extern void _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr,

Include/internal/pycore_opcode.h

@@ -119,6 +119,8 @@ PyObject *_Py_slot_tp_getattr_hook(PyObject *self, PyObject *name);
 
 PyObject *
 _PySuper_Lookup(PyTypeObject *su_type, PyObject *su_obj, PyObject *name, int *meth_found);
+PyObject *
+_PySuper_LookupDescr(PyTypeObject *su_type, PyObject *su_obj, PyObject *name);
 
 #ifdef __cplusplus
 }

Include/internal/pycore_typeobject.h

@@ -440,7 +440,8 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.12a7 3524 (Shrink the BINARY_SUBSCR caches)
 #     Python 3.12b1 3525 (Shrink the CALL caches)
 #     Python 3.12b1 3526 (Add instrumentation support)
-#     Python 3.12b1 3527 (Optimize super() calls)
+#     Python 3.12b1 3527 (Add LOAD_SUPER_ATTR)
+#     Python 3.12b1 3528 (Add LOAD_SUPER_ATTR_METHOD specialization)
 
 #     Python 3.13 will start with 3550
 
@@ -457,7 +458,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3527).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3528).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 

Include/opcode.h

@@ -353,6 +353,9 @@ def pseudo_op(name, op, real_ops):
         "FOR_ITER_RANGE",
         "FOR_ITER_GEN",
     ],
+    "LOAD_SUPER_ATTR": [
+        "LOAD_SUPER_ATTR_METHOD",
+    ],
     "LOAD_ATTR": [
         # These potentially push [NULL, bound method] onto the stack.
         "LOAD_ATTR_CLASS",
@@ -426,6 +429,12 @@ def pseudo_op(name, op, real_ops):
     "FOR_ITER": {
         "counter": 1,
     },
+    "LOAD_SUPER_ATTR": {
+        "counter": 1,
+        "class_version": 2,
+        "self_type_version": 2,
+        "method": 4,
+    },
     "LOAD_ATTR": {
         "counter": 1,
         "version": 2,

Lib/importlib/_bootstrap_external.py

@@ -1,6 +1,29 @@
 import unittest
 
 
+class TestLoadSuperAttrCache(unittest.TestCase):
+    def test_descriptor_not_double_executed_on_spec_fail(self):
+        calls = []
+        class Descriptor:
+            def __get__(self, instance, owner):
+                calls.append((instance, owner))
+                return lambda: 1
+
+        class C:
+            d = Descriptor()
+
+        class D(C):
+            def f(self):
+                return super().d()
+
+        d = D()
+
+        self.assertEqual(d.f(), 1)  # warmup
+        calls.clear()
+        self.assertEqual(d.f(), 1)  # try to specialize
+        self.assertEqual(calls, [(d, D)])
+
+
 class TestLoadAttrCache(unittest.TestCase):
     def test_descriptor_added_after_optimization(self):
         class Descriptor:

Lib/opcode.py

@@ -1 +1,4 @@
-Add :opcode:`LOAD_SUPER_ATTR` to speed up ``super().meth()`` and ``super().attr`` calls.
+Add :opcode:`LOAD_SUPER_ATTR` (and a specialization for ``super().method()``) to
+speed up ``super().method()`` and ``super().attr``. This makes
+``super().method()`` roughly 2.3x faster and brings it within 20% of the
+performance of a simple method call. Patch by Vladimir Matveev and Carl Meyer.