Do not use reverse-lookup cache, use recorded value instead

Author: Fidget-Spinner

Include/internal/pycore_opcode_metadata.h

@@ -2721,11 +2721,6 @@ dummy_func(
         }
 
         op(_GUARD_TYPE_VERSION_LOCKED, (type_version/2, owner -- owner)) {
-            // Guard that type version matches expected value. Object is assumed to be
-            // locked on entry. If version matches, lock is retained for subsequent
-            // operations. If mismatch, unlock and exit (deopt). This allows the JIT
-            // optimizer to eliminate this guard entirely if type version is proven,
-            // in which case the lock is held for the entire trace duration.
             PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
             assert(type_version != 0);
             PyTypeObject *tp = Py_TYPE(owner_o);
@@ -2999,6 +2994,7 @@ dummy_func(
 
         macro(STORE_ATTR_INSTANCE_VALUE) =
             unused/1 +
+            _RECORD_TOS_TYPE +
             _LOCK_OBJECT +
             _GUARD_TYPE_VERSION_LOCKED +
             _GUARD_DORV_NO_DICT +

Python/bytecodes.c

@@ -139,12 +139,11 @@ dummy_func(void) {
         if (sym_matches_type_version(owner, type_version)) {
             ADD_OP(_NOP, 0, 0);
         } else {
-            PyTypeObject *type = _PyType_LookupByVersion(type_version);
-            if (type) {
-                if (sym_set_type_version(owner, type_version)) {
-                    PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);
-                    _Py_BloomFilter_Add(dependencies, type);
-                }
+            PyTypeObject *probable_type = sym_get_probable_type(owner);
+            if (probable_type->tp_version_tag == type_version && sym_set_type_version(owner, type_version)) {
+                // Promote the probable type version to a known one.
+                PyType_Watch(TYPE_WATCHER_ID, (PyObject *)probable_type);
+                _Py_BloomFilter_Add(dependencies, probable_type);
             }
         }
     }
@@ -1043,20 +1042,22 @@ dummy_func(void) {
 
     op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, self_or_null, args[oparg] -- callable, self_or_null, args[oparg])) {
         (void)args;
-        PyTypeObject *type = _PyType_LookupByVersion(type_version);
-        if (type) {
-            PyHeapTypeObject *cls = (PyHeapTypeObject *)type;
-            PyObject *init = FT_ATOMIC_LOAD_PTR_ACQUIRE(cls->_spec_cache.init);
-            if (init != NULL && PyFunction_Check(init)) {
-                // Propagate the __init__ function so _CREATE_INIT_FRAME can
-                // resolve the code object and continue optimizing.
-                callable = sym_new_const(ctx, init);
-                PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);
-                _Py_BloomFilter_Add(dependencies, type);
-            }
-            else {
-                callable = sym_new_not_null(ctx);
-            }
+        PyObject *probable_callable = sym_get_probable_value(callable);
+        assert(probable_callable != NULL);
+        assert(PyType_Check(probable_callable));
+        PyTypeObject *tp = (PyTypeObject *)probable_callable;
+        if (tp->tp_version_tag == type_version) {
+            // If the type version has not changed since we last saw it,
+            // then we know this __init__ is definitely the same one as in the cache.
+            // We can promote callable to a known constant. This does not need a
+            // type watcher, as we do not remove this _CHECK_AND_ALLOCATE_OBJECT guard.
+            // TODO: split up _CHECK_AND_ALLOCATE_OBJECT to the check then alloate, so we can
+            // eliminate the check.
+            PyHeapTypeObject *cls = (PyHeapTypeObject *)probable_callable;
+            PyObject *init = cls->_spec_cache.init;
+            assert(init != NULL);
+            assert(PyFunction_Check(init));
+            callable = sym_new_const(ctx, init);
         }
         else {
             callable = sym_new_not_null(ctx);