Align call-init frame flow and spec cache atomic ordering

youknowone · youknowone · commit c487b6d3e0d6 · 2026-03-10T13:08:11.000+09:00
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
@@ -914,7 +914,9 @@ impl PyType {
         if self.tp_version_tag.load(Ordering::Acquire) != tp_version {
             return None;
         }
-        ext.specialization_cache.init.to_owned()
+        ext.specialization_cache
+            .init
+            .to_owned_ordering(Ordering::Acquire)
     }
 
     /// Cache __getitem__ for BINARY_OP_SUBSCR_GETITEM specialization.
@@ -940,7 +942,7 @@ impl PyType {
         ext.specialization_cache.swap_getitem(Some(getitem));
         ext.specialization_cache
             .getitem_version
-            .store(func_version, Ordering::Release);
+            .store(func_version, Ordering::Relaxed);
         true
     }
 
@@ -950,16 +952,13 @@ impl PyType {
         let cached_version = ext
             .specialization_cache
             .getitem_version
-            .load(Ordering::Acquire);
+            .load(Ordering::Relaxed);
         if cached_version == 0 {
             return None;
         }
-        if self.tp_version_tag.load(Ordering::Acquire) == 0 {
-            return None;
-        }
         ext.specialization_cache
             .getitem
-            .to_owned()
+            .to_owned_ordering(Ordering::Acquire)
             .map(|getitem| (getitem, cached_version))
     }
 
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -4723,6 +4723,12 @@ impl ExecutingFrame<'_> {
                     ) {
                         return self.execute_call_vectorcall(nargs, vm);
                     }
+                    // CPython creates two frames for this opcode:
+                    // `_Py_InitCleanup` trampoline + `__init__` frame.
+                    // Guard recursion limit accordingly and fall back.
+                    if self.specialization_call_recursion_guard_with_extra_frames(vm, 1) {
+                        return self.execute_call_vectorcall(nargs, vm);
+                    }
                     // Allocate object directly (tp_new == object.__new__, tp_alloc == generic).
                     let cls_ref = cls.to_owned();
                     let new_obj = cls_alloc(cls_ref, 0, vm)?;
@@ -4736,10 +4742,9 @@ impl ExecutingFrame<'_> {
                     all_args.push(new_obj.clone());
                     all_args.extend(pos_args);
 
-                    let init_callable: PyObjectRef = init_func.into();
-                    let effective_nargs = all_args.len();
-                    let init_result =
-                        vectorcall_function(&init_callable, all_args, effective_nargs, None, vm)?;
+                    // Match CPython's _CREATE_INIT_FRAME path shape: run init
+                    // as exact-args Python function call.
+                    let init_result = init_func.invoke_exact_args(all_args, vm)?;
 
                     // EXIT_INIT_CHECK: __init__ must return None
                     if !vm.is_none(&init_result) {
@@ -8690,7 +8695,19 @@ impl ExecutingFrame<'_> {
 
     #[inline]
     fn specialization_call_recursion_guard(&self, vm: &VirtualMachine) -> bool {
-        vm.current_recursion_depth().saturating_add(1) >= vm.recursion_limit.get()
+        self.specialization_call_recursion_guard_with_extra_frames(vm, 0)
+    }
+
+    #[inline]
+    fn specialization_call_recursion_guard_with_extra_frames(
+        &self,
+        vm: &VirtualMachine,
+        extra_frames: usize,
+    ) -> bool {
+        vm.current_recursion_depth()
+            .saturating_add(1)
+            .saturating_add(extra_frames)
+            >= vm.recursion_limit.get()
     }
 
     #[inline]
diff --git a/crates/vm/src/object/ext.rs b/crates/vm/src/object/ext.rs
@@ -355,11 +355,19 @@ impl<T: PyPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
 
 impl<T: PyPayload> PyAtomicRef<Option<T>> {
     pub fn deref(&self) -> Option<&Py<T>> {
-        unsafe { self.inner.load(Ordering::Relaxed).cast::<Py<T>>().as_ref() }
+        self.deref_ordering(Ordering::Relaxed)
+    }
+
+    pub fn deref_ordering(&self, ordering: Ordering) -> Option<&Py<T>> {
+        unsafe { self.inner.load(ordering).cast::<Py<T>>().as_ref() }
     }
 
     pub fn to_owned(&self) -> Option<PyRef<T>> {
-        self.deref().map(|x| x.to_owned())
+        self.to_owned_ordering(Ordering::Relaxed)
+    }
+
+    pub fn to_owned_ordering(&self, ordering: Ordering) -> Option<PyRef<T>> {
+        self.deref_ordering(ordering).map(|x| x.to_owned())
     }
 
     /// # Safety
@@ -441,16 +449,19 @@ impl From<Option<PyObjectRef>> for PyAtomicRef<Option<PyObject>> {
 
 impl PyAtomicRef<Option<PyObject>> {
     pub fn deref(&self) -> Option<&PyObject> {
-        unsafe {
-            self.inner
-                .load(Ordering::Relaxed)
-                .cast::<PyObject>()
-                .as_ref()
-        }
+        self.deref_ordering(Ordering::Relaxed)
+    }
+
+    pub fn deref_ordering(&self, ordering: Ordering) -> Option<&PyObject> {
+        unsafe { self.inner.load(ordering).cast::<PyObject>().as_ref() }
     }
 
     pub fn to_owned(&self) -> Option<PyObjectRef> {
-        self.deref().map(|x| x.to_owned())
+        self.to_owned_ordering(Ordering::Relaxed)
+    }
+
+    pub fn to_owned_ordering(&self, ordering: Ordering) -> Option<PyObjectRef> {
+        self.deref_ordering(ordering).map(|x| x.to_owned())
     }
 
     /// # Safety
