jit: the five gates between a stdlib dunder and the inline that already handles the leaf shape

majit/gate-triage.md

@@ -226,6 +226,27 @@ cover the condition they diagnose.
 - What it does: Whether the blackhole-object probe is enabled.
 - Retirement condition: **UNRECORDED** — owed by this gate's owner.
 
+### `MAJIT_GC_BH_PROBE_CLASSES`
+
+- Read sites: 1 — `majit/majit-gc/src/collector.rs`
+- Accessor: `read_uint_from_env("MAJIT_GC_BH_PROBE_CLASSES")`, default 10
+- What it does: How many distinct classes the probe above reports. Reached through a name-taking helper rather than a literal `env::var`, which is why the completeness brake in `pyre/pyrex/tests/gate_triage_complete.rs` does not see it — it is listed here because this document, not the brake, is what claims to hold every live gate.
+- Retirement condition: with `MAJIT_GC_BH_PROBE`, whose report it shapes.
+
+### `MAJIT_GC_BH_PROBE_MINOR`
+
+- Read sites: 1 — `majit/majit-gc/src/collector.rs`
+- Accessor: `read_uint_from_env("MAJIT_GC_BH_PROBE_MINOR")`, default 120
+- What it does: Which minor collection the probe reports at. The interpreter fills the old generation long before the JIT compiles anything, so reporting at minor #1 can only show pre-JIT allocations.
+- Retirement condition: with `MAJIT_GC_BH_PROBE`.
+
+### `MAJIT_GC_BH_PROBE_FROM`
+
+- Read sites: 2 — `majit/majit-gc/src/collector.rs`
+- Accessor: `read_uint_from_env("MAJIT_GC_BH_PROBE_FROM")`, default 0
+- What it does: Skips the minors before the one being investigated. The probe's reachability walk is a whole-heap traversal per minor, too slow to leave on for a whole run.
+- Retirement condition: with `MAJIT_GC_BH_PROBE`.
+
 ### `MAJIT_GC_DRAIN_CENSUS`
 
 - Read sites: 1 — `majit/majit-gc/src/lib.rs`
@@ -410,13 +431,6 @@ cover the condition they diagnose.
 - What it does: Prints the control-flow decisions a walk makes: the interpreter pc every `jit_merge_point` visit carries, and every `switch`, `goto_if_not` and `loop_header`, each tagged with the jitcode that owns it and its frame depth (`d=`). A walk that records without ever closing gives the same reading at the top (`seen_loop_header_for_jdindex` stays -1 at every merge point) whether the `loop_header` op was never reached or was reached and declined, and the two call for opposite fixes; the branch lines name which edge diverted the walk, at whatever depth it happened.
 - Retirement condition: **UNRECORDED** — owed by this gate's owner.
 
-### `MAJIT_PORTAL_INLINE`
-
-- Read sites: 1 — `majit/majit-metainterp/src/pyjitpl/dispatch.rs`
-- Accessor: `portal_inline_experiment_enabled()`
-- What it does: Enables the experimental recursive-portal inline re-entry path. Unset keeps the clean-abort fallback when `portal_jitcode` is absent.
-- Retirement condition: **UNRECORDED** — owed by this gate's owner.
-
 ### `MAJIT_PROBE_LIVENESS`
 
 - Read sites: 1 — `pyre/pyre-jit/src/call_jit.rs`

majit/majit-metainterp/src/jitdriver.rs

@@ -161,21 +161,15 @@ fn build_bh_jitdrivers_sd(
 /// Pick the `bh.virtualizable_info` pointer to seed at a guard-failure deopt, or
 /// null to leave it unset. A non-null vinfo lets the blackhole run a mid-body
 /// vable-array op (e.g. the `int_*_jump_if_ovf` overflow guard on a `[int; virt]`
-/// state field). Seed when either the portal-inline experiment is on, or the
-/// machine is a state-field one (no `vable_token` field) whose
-/// `bh_clear_vable_token` is inert so a non-null vinfo cannot corrupt its non-GC
-/// `state` struct. A real heap virtualizable (e.g. PyFrame) is left with null
-/// vinfo to preserve its existing resume contract.
+/// state field). Seed when the machine is a state-field one (no `vable_token`
+/// field) whose `bh_clear_vable_token` is inert so a non-null vinfo cannot
+/// corrupt its non-GC `state` struct. A real heap virtualizable (e.g. PyFrame)
+/// is left with null vinfo to preserve its existing resume contract.
 fn seed_deopt_vinfo_ptr(
     vinfo: Option<&std::sync::Arc<crate::virtualizable::VirtualizableInfo>>,
 ) -> *const crate::virtualizable::VirtualizableInfo {
     match vinfo {
-        Some(info)
-            if crate::pyjitpl::dispatch::portal_inline_experiment_enabled()
-                || !info.has_vable_token() =>
-        {
-            std::sync::Arc::as_ptr(info)
-        }
+        Some(info) if !info.has_vable_token() => std::sync::Arc::as_ptr(info),
         _ => std::ptr::null(),
     }
 }
@@ -9396,17 +9390,13 @@ mod tests {
         // No vinfo available → null.
         assert!(seed_deopt_vinfo_ptr(None).is_null());
 
-        // token_offset > 0 → null while the portal-inline experiment is off, so a
-        // real heap virtualizable keeps its existing null-vinfo resume contract.
-        // (The experiment flag is a process-wide latch; guard the assertion on it
-        // rather than assuming the env is unset.)
-        if !crate::pyjitpl::dispatch::portal_inline_experiment_enabled() {
-            let heap_vable = std::sync::Arc::new(VirtualizableInfo::new(8));
-            assert!(
-                seed_deopt_vinfo_ptr(Some(&heap_vable)).is_null(),
-                "a token_offset>0 heap virtualizable must keep the null-vinfo contract",
-            );
-        }
+        // token_offset > 0 → null, so a real heap virtualizable keeps its
+        // existing null-vinfo resume contract.
+        let heap_vable = std::sync::Arc::new(VirtualizableInfo::new(8));
+        assert!(
+            seed_deopt_vinfo_ptr(Some(&heap_vable)).is_null(),
+            "a token_offset>0 heap virtualizable must keep the null-vinfo contract",
+        );
     }
 
     #[derive(Default)]

majit/majit-metainterp/src/optimizeopt/unroll.rs

@@ -1327,7 +1327,17 @@ impl UnrollOptimizer {
         // Phase 2 namespace; production probes (nbody / fannkuch /
         // fib_loop / fib_recursive / spectral_norm) show zero misses,
         // so promote to a strict panic matching RPython's _get assert.
-        let translate_opref = |opref: OpRef| -> OpRef {
+        // A miss has two shapes and they call for different fixes, so name
+        // which one fired instead of leaving it to be inferred from
+        // `cache_len`.  `TraceIterator::new` sizes the cache from the highest
+        // raw position appearing as an op result, an argument or a failarg in
+        // the range it walks -- snapshot feeds are not consulted -- so a
+        // position ABOVE that is one no operation in the trace mentions at
+        // all, while a position INSIDE it with an empty slot is one the range
+        // covers and no operation produced.  The feed and the frame the entry
+        // sits in are printed for the same reason: the three feeds are
+        // remapped by one closure and the message otherwise cannot say which.
+        let translate_opref = |feed: &str, frame: usize, opref: OpRef| -> OpRef {
             if opref.is_none() || opref.is_constant() {
                 return opref;
             }
@@ -1336,28 +1346,46 @@ impl UnrollOptimizer {
                 .and_then(|slot| slot.as_ref())
                 .map(|b| b.to_opref())
                 .unwrap_or_else(|| {
+                    let shape = if opref.raw() as usize >= p2_cache.len() {
+                        "above every position the trace mentions"
+                    } else {
+                        "inside the range, no operation produced it"
+                    };
+                    // Counted here rather than beside the closure: the happy
+                    // path walks every snapshot entry and must not pay two
+                    // scans of the cache for a message it never prints.
+                    let cache_filled = p2_cache.iter().filter(|slot| slot.is_some()).count();
+                    let cache_high = p2_cache
+                        .iter()
+                        .rposition(std::option::Option::is_some)
+                        .map_or(-1i64, |i| i as i64);
                     panic!(
                         "phase2 snapshot remap cache miss for {opref:?} \
-                         (cache_len={} body_ni={} phase2_inputarg_base={})",
+                         in {feed}[{frame}] ({shape}) \
+                         (cache_len={} filled={} highest_filled={} \
+                          ops={} body_ni={} phase2_inputarg_base={})",
                         p2_cache.len(),
+                        cache_filled,
+                        cache_high,
+                        ops.len(),
                         body_num_inputs,
                         phase2_inputarg_base,
                     )
                 })
         };
-        for boxes in opt_p2.snapshot_boxes.iter_mut().flatten() {
-            for r in boxes.iter_mut() {
-                *r = r.map_opref(translate_opref);
+        for (frame, boxes) in opt_p2.snapshot_boxes.iter_mut().enumerate() {
+            for r in boxes.iter_mut().flatten() {
+                *r = r.map_opref(|opref| translate_opref("snapshot_boxes", frame, opref));
             }
         }
-        for boxes in opt_p2.snapshot_vable_boxes.iter_mut().flatten() {
-            for r in boxes.iter_mut() {
-                *r = r.map_opref(translate_opref);
+        for (frame, boxes) in opt_p2.snapshot_vable_boxes.iter_mut().enumerate() {
+            for r in boxes.iter_mut().flatten() {
+                *r = r.map_opref(|opref| translate_opref("snapshot_vable_boxes", frame, opref));
             }
         }
-        for boxes in opt_p2.snapshot_vref_boxes.iter_mut().flatten() {
-            for r in boxes.iter_mut() {
-                *r = r.map_opref(translate_opref);
+        for (frame, boxes) in opt_p2.snapshot_vref_boxes.iter_mut().enumerate() {
+            for r in boxes.iter_mut().flatten() {
+                *r = r.map_opref(|opref| translate_opref("snapshot_vref_boxes", frame, opref));
             }
         }
         self.replace_compile_snapshot_roots(Self::collect_snapshot_const_ptr_slots(&mut [

majit/majit-metainterp/src/pyjitpl/dispatch.rs

@@ -1135,16 +1135,6 @@ pub trait JitCodeRuntime {
     }
 }
 
-/// [FR] WIP gate for the state-field recursive-portal Inline re-entry rework.
-/// OFF by default: the state-field `portal_jitcode`-None path keeps its
-/// clean-abort fallback so existing consumers are unaffected. Set
-/// `MAJIT_PORTAL_INLINE=1` to exercise the experimental inline path.
-pub(crate) fn portal_inline_experiment_enabled() -> bool {
-    static ENABLED: std::sync::LazyLock<bool> =
-        std::sync::LazyLock::new(|| std::env::var_os("MAJIT_PORTAL_INLINE").is_some());
-    *ENABLED
-}
-
 pub struct ClosureRuntime<FLabel> {
     label_at: FLabel,
 }

majit/majit-translate/src/annotator/binaryop.rs

@@ -3286,6 +3286,37 @@ mod tests {
         }
     }
 
+    #[test]
+    fn consider_string_char_add_uses_somechar_string_mro() {
+        for char_first in [false, true] {
+            let ann = mk_ann();
+            let mut string_var = Variable::named("s");
+            let mut char_var = Variable::named("c");
+            let mut string = SomeString::new(false, true);
+            string.inner.base.const_box = Some(Constant::new(ConstValue::byte_str("left")));
+            let mut character = SomeChar::new(true);
+            character.inner.base.const_box = Some(Constant::new(ConstValue::byte_str(" ")));
+            ann.setbinding(&mut string_var, SomeValue::String(string));
+            ann.setbinding(&mut char_var, SomeValue::Char(character));
+            let args = if char_first {
+                vec![Hlvalue::Variable(char_var), Hlvalue::Variable(string_var)]
+            } else {
+                vec![Hlvalue::Variable(string_var), Hlvalue::Variable(char_var)]
+            };
+            let result = HLOperation::new(OpKind::Add, args)
+                .consider(&ann)
+                .unwrap()
+                .unwrap();
+            let SomeValue::String(result) = result else {
+                panic!("string/char add must widen to SomeString")
+            };
+            assert_eq!(
+                result.inner.base.const_box.expect("constant add").value,
+                ConstValue::byte_str(if char_first { " left" } else { "left " })
+            );
+        }
+    }
+
     #[test]
     fn consider_bytearray_add_returns_bytearray() {
         let ann = mk_ann();