jit: split portals and skip tracing per cell

majit/majit-metainterp/src/blackhole.rs

@@ -7346,13 +7346,9 @@ fn portal_jd_for(bh: &BlackholeInterpreter) -> Option<usize> {
 /// crate, and the split is what let a substituted runner be validated against
 /// the owning driver's declared kind.
 ///
-/// ★ The substitution is the common case, not a fault. `codewriter.rs` stamps a
-/// driver index on every portal jitcode (`jitdriver_sd_from_portal_graph`
-/// matches `jd.portal_graph == code`, and `setup_jitdriver` appends one entry
-/// per portal graph), while `eval.rs` registers exactly one
-/// `handle_jitexc_from_bh` — index 0's. So most portal frames name a driver
-/// that has no runner of its own, and refusing to substitute would withdraw
-/// portal re-entry from paths that have it today.
+/// ★ A miss still falls back to any registered runner so a test fixture
+/// that stamps a driver index without installing a hook keeps working.
+/// Production registers one hook per driver (`eval.rs` jd0 and jd1).
 ///
 /// What is withheld instead is the *kind*: a substituted runner's outcome is
 /// not validated against the owning driver's `result_type`, because that pair

majit/majit-metainterp/src/lib.rs

@@ -249,8 +249,8 @@ pub use pyjitpl::{
     CompiledTraceLayout, DeadFrameArtifacts, DetailedDriverRunOutcome, InlineDecision,
     JitCodeMachine, JitCodeRuntime, JitCodeSym, JitHooks, JitStats, MIFrame, MIFrameStack,
     MetaInterp, MetaInterpGlobalData, MetaInterpStaticData, PortalGreenKey, RawCompileResult,
-    StandaloneFrameStack, SymbolicFnaddrPathResolver, build_state_field_snapshot,
-    call_int_function, call_ref_function, call_void_function, counters,
+    StandaloneFrameStack, SwitchToBlackhole, SymbolicFnaddrPathResolver,
+    build_state_field_snapshot, call_int_function, call_ref_function, call_void_function, counters,
     record_application_traceback_for_recording, record_application_traceback_hook_address,
     record_discarded_level_traceback_for_recording, record_discarded_level_traceback_hook_address,
     record_inline_application_traceback_for_recording,
@@ -1293,6 +1293,10 @@ pub enum TraceAction {
     SegmentedBridge { exception_box: OpRef },
     /// Abort the current trace (recoverable — may retry later).
     Abort,
+    /// pyjitpl.py `raise SwitchToBlackhole(reason)`: carry the decision to
+    /// the cancel-tracing catch without running another interpreter step or
+    /// another trace-length check while unwinding.
+    SwitchToBlackhole(pyjitpl::SwitchToBlackhole),
     /// Decline the current trace before compilation and return to residual
     /// execution without charging a trace abort.
     Decline,

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

@@ -1060,6 +1060,13 @@ pub trait JitCodeRuntime {
         None
     }
 
+    /// pyjitpl.py `is_main_jitcode` for a recursive portal this runtime
+    /// is about to inline. Default false so fixture runtimes that never
+    /// overflow keep an empty log.
+    fn is_main_portal(&self, _jd_index: usize) -> bool {
+        false
+    }
+
     /// Resolve the CALL_ASSEMBLER target for a `BC_RECURSIVE_CALL_*`
     /// opcode whose inline decision came back `CallAssembler`
     /// (pyjitpl.py → `do_recursive_call(assembler_call=True)`).  The
@@ -1388,6 +1395,10 @@ where
     ) -> Option<()> {
         (self.recursive_exec_void)(token, reds)
     }
+
+    fn is_main_portal(&self, _jd_index: usize) -> bool {
+        true
+    }
 }
 
 /// JitCode bytecode interpreter for tracing.
@@ -2764,6 +2775,9 @@ where
             if frame.portal_entered {
                 let jd_box = ctx.const_int(frame.portal_jd as i64);
                 ctx.record_op(OpCode::LeavePortalFrame, &[jd_box]);
+                if frame.portal_trace_logged {
+                    ctx.push_portal_trace_event(frame.portal_jd, None, ctx.get_trace_position());
+                }
             }
             let portal_scalar_state = frame.portal_scalar_state.take();
             self.frames.recycle_frame(frame);
@@ -3398,34 +3412,18 @@ where
             let jd_box = ctx.const_int(jd_index as i64);
             let uid_box = ctx.const_int(green_pc as i64);
             ctx.record_op(OpCode::EnterPortalFrame, &[jd_box, uid_box]);
-            // `newframe` records ENTER_PORTAL_FRAME and appends a
-            // `portal_trace_positions` entry on adjacent lines; this arm does
-            // only the first half.  `push_portal_trace_position` lives on
-            // `MetaInterp`, and a `JitCodeMachine` reaches its host only
-            // through the `Runtime` trait, which carries no channel to it.
-            // Both LEAVE pops (`pop_exception_frame` and the finished-frame
-            // pop in `run_one_step`) omit the closing entry symmetrically, so
-            // the log stays BALANCED — `find_biggest_function` pairs entries
-            // off a stack, and dropping one half alone would mis-size every
-            // frame after it.  What the omission costs is that a
-            // `TraceTooLong` taken inside an inlined portal finds no candidate
-            // to disable and falls to `prepare_trace_segmenting`.
-            //
-            // A defaulted `Runtime` hook would not close this: the trait's
-            // `begin_portal_op` / `commit_portal_op` / `abort_portal_op` seams
-            // already have no implementor anywhere in the workspace, so a
-            // fourth would leave every runtime's log as empty as it is now.
-            // The entry has to come from a host that owns the `MetaInterp`,
-            // and pyre's walker is such a host: `note_inline_subwalk_start`
-            // (`pyre-jit-trace/src/state.rs`, called from `inline_call.rs`)
-            // reaches the driver through `try_driver_pair()` and calls
-            // `push_portal_trace_position`, while the too-long handler beside
-            // it reads the result back through `find_biggest_function` before
-            // retiring the log.  So the omission does NOT mean the log is
-            // empty wherever a recursive portal overflows — on the walker path
-            // it is filled and consumed.  What this arm leaves out is confined
-            // to runtimes that inline through HERE, which in this workspace is
-            // the `dispatch.rs` fixtures alone.
+            // pyjitpl.py `newframe`: ENTER_PORTAL_FRAME and the
+            // `portal_trace_positions` append sit on adjacent lines.
+            // The machine cannot reach MetaInterp, so the log half
+            // lives on TraceCtx and `find_biggest_function` reads both.
+            if runtime.is_main_portal(jd_index) {
+                ctx.push_portal_trace_event(
+                    jd_index,
+                    Some((green_pc as u64, None)),
+                    ctx.get_trace_position(),
+                );
+                portal_frame.portal_trace_logged = true;
+            }
             portal_frame.inline_frame = true;
             // pyjitpl.py:2461-2492 pairing: this push recorded ENTER_PORTAL_FRAME,
             // so the frame's normal-return / exception-return pop records the
@@ -3815,6 +3813,13 @@ where
             if finished_frame.portal_entered {
                 let jd_box = ctx.const_int(finished_frame.portal_jd as i64);
                 ctx.record_op(OpCode::LeavePortalFrame, &[jd_box]);
+                if finished_frame.portal_trace_logged {
+                    ctx.push_portal_trace_event(
+                        finished_frame.portal_jd,
+                        None,
+                        ctx.get_trace_position(),
+                    );
+                }
             }
             // [FR] Restore the caller's sym scalar/fixed-array state that this
             // inline recursive-portal frame overwrote.
@@ -6660,6 +6665,15 @@ where
                         if popped.inline_frame {
                             ctx.pop_inline_frame();
                         }
+                        // popframe still appends the log close when greenkey
+                        // is set, even with leave_portal_frame=False.
+                        if popped.portal_trace_logged {
+                            ctx.push_portal_trace_event(
+                                popped.portal_jd,
+                                None,
+                                ctx.get_trace_position(),
+                            );
+                        }
                         if let Some(snapshot) = popped.portal_scalar_state.take() {
                             sym.restore_inline_scalar_state(snapshot);
                         }
@@ -12157,6 +12171,10 @@ mod tests {
         fn portal_jitcode(&self, _jd_index: usize) -> Option<std::sync::Arc<JitCode>> {
             Some(self.portal.clone())
         }
+
+        fn is_main_portal(&self, _jd_index: usize) -> bool {
+            true
+        }
     }
 
     /// recursive-call SLICE 0 — a `BC_RECURSIVE_CALL_INT` whose runtime inlines the
@@ -12832,6 +12850,10 @@ mod tests {
             Some(self.portal.clone())
         }
 
+        fn is_main_portal(&self, _jd_index: usize) -> bool {
+            true
+        }
+
         fn recursive_call_assembler_target(
             &self,
             _jd_index: usize,

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

@@ -102,6 +102,10 @@ pub struct MIFrame {
     /// that record no ENTER and must record no LEAVE. The merge-point cut is the
     /// sole `leave_portal_frame=False` site and re-emits LEAVE itself.
     pub portal_entered: bool,
+    /// True when the matching `portal_trace_positions` open entry was
+    /// recorded. Leave must push a close only then, or find_biggest_function
+    /// sees an unmatched close.
+    pub portal_trace_logged: bool,
     /// \[FR\] The jd_index carried in this frame's `LEAVE_PORTAL_FRAME` op, set at
     /// the same push that set `portal_entered`. Unused when `portal_entered` is
     /// false.
@@ -185,6 +189,7 @@ impl MIFrame {
             inline_frame: false,
             portal_scalar_state: None,
             portal_entered: false,
+            portal_trace_logged: false,
             portal_jd: 0,
             return_i: None,
             return_r: None,
@@ -293,6 +298,7 @@ impl MIFrame {
         self.inline_frame = false;
         self.portal_scalar_state = None;
         self.portal_entered = false;
+        self.portal_trace_logged = false;
         self.portal_jd = 0;
         self.return_i = None;
         self.return_r = None;

majit/majit-metainterp/src/trace_ctx.rs

@@ -270,6 +270,15 @@ pub struct TraceCtx {
     /// doing tuple-equality comparisons in [`recursive_depth`] and
     /// [`is_tracing_key`].
     pub(crate) inline_frames: Vec<(usize, usize)>,
+    /// `portal_trace_positions` entries recorded by `JitCodeMachine`
+    /// while it cannot reach `MetaInterp`. `find_biggest_function`
+    /// walks these after the MetaInterp log. Retired together with
+    /// `MetaInterp.portal_trace_positions`.
+    pub(crate) portal_trace_events: Vec<(
+        usize,
+        Option<crate::pyjitpl::PortalGreenKey>,
+        crate::recorder::TracePosition,
+    )>,
     /// Structured green key values (if provided by the interpreter).
     green_key_values: Option<GreenKey>,
     /// Declarative driver layout metadata, if provided by the interpreter.
@@ -885,6 +894,21 @@ impl TraceCtx {
         &mut self.heap_cache
     }
 
+    /// pyjitpl.py `newframe` / `popframe` log half for a JitCodeMachine
+    /// that cannot reach `MetaInterp.portal_trace_positions`.
+    pub fn push_portal_trace_event(
+        &mut self,
+        jd_no: usize,
+        green_key: Option<crate::pyjitpl::PortalGreenKey>,
+        pos: crate::recorder::TracePosition,
+    ) {
+        self.portal_trace_events.push((jd_no, green_key, pos));
+    }
+
+    pub fn clear_portal_trace_events(&mut self) {
+        self.portal_trace_events.clear();
+    }
+
     /// Install the `self.metainterp.cpu` analog for the cache-hit
     /// sanity-check load.
     ///
@@ -1766,6 +1790,7 @@ impl TraceCtx {
             green_key_raw: (0, 0),
             root_green_key_raw: (0, 0),
             inline_frames: Vec::new(),
+            portal_trace_events: Vec::new(),
             green_key_values: None,
             driver_descriptor: None,
             virtualizable_boxes: None,
@@ -1865,6 +1890,7 @@ impl TraceCtx {
             green_key_raw: (0, 0),
             root_green_key_raw: (0, 0),
             inline_frames: Vec::new(),
+            portal_trace_events: Vec::new(),
             green_key_values: Some(green_key_values),
             driver_descriptor: None,
             virtualizable_boxes: None,
@@ -2528,6 +2554,13 @@ impl TraceCtx {
         self.driver_descriptor = Some(descriptor);
     }
 
+    /// pyjitpl.py `initialize_withgreenfields`: the single red that owns
+    /// the green fields is the whole virtualizable box list.
+    pub fn set_greenfield_virtualizable_box(&mut self, box_ref: OpRef, value: Value) {
+        self.virtualizable_boxes = Some(vec![box_ref]);
+        self.virtualizable_values = Some(vec![value]);
+    }
+
     /// Initialize standard virtualizable boxes from input args.
     /// Called at trace start when a virtualizable is registered.
     ///

majit/majit-metainterp/src/warmspot.rs

@@ -5,6 +5,22 @@
 //! jitdriver metadata, warmstate, compile helpers, and the `pyre-jit` portal
 //! boundary. This module is the parity namespace that re-exports those pieces
 //! under the upstream module name without introducing a second implementation.
+//!
+//! `WarmRunnerDesc.apply_jit` graph rewrites have no mutable interpreter-graph
+//! stage here (design.md §3.7 A1). Their source-level ports:
+//! - `split_graph_and_record_jitdriver` — `register_configured_jitdrivers`
+//!   (autoreds run `autodetect_jit_markers_redvars` first)
+//! - `rewrite_jit_merge_point` — `_unpackiterable_unknown_length` returns
+//!   `unpack_portal_runner`; jd0 is `eval_loop_jit` / `ll_portal_runner_shim`
+//! - `rewrite_can_enter_jits` — `can_enter_jit` / `unpack_merge_point` bodies
+//! - `rewrite_set_param_and_get_stats` — `set_jit_param` hook
+//! - `rewrite_force_virtual` — `force_pyframe_vref`
+//! - `rewrite_force_quasi_immutable` — `jtransform` + `do_force_quasi_immutable`
+//! - `rewrite_jitcell_accesses` — `WarmEnterState` methods
+//! - `make_driverhook_graphs` — `get_unique_id` / `get_printable_location`
+//! - `inline_inlineable_portals` / `prejit_optimizations` / `add_finish` /
+//!   `create_jit_entry_points` — no `@jitdriver.inline` sites, no backendopt
+//!   pass over interpreter graphs, no translated finish callback
 
 pub use crate::jitdriver::{
     DeclarativeJitDriver, JitDriver, JitDriverStaticData, TraceContinuationSuspendGuard,

majit/majit-translate/src/codewriter/jtransform.rs

@@ -799,7 +799,7 @@ fn reversed_comparison_binop(name: &str) -> &str {
     clippy::mutable_key_type,
     reason = "Eq and Hash use immutable identity/value data; interior mutation is excluded, matching RPython identity-keyed dict semantics"
 )]
-fn autodetect_jit_markers_redvars(
+pub(crate) fn autodetect_jit_markers_redvars(
     graph: &FunctionGraph,
     greens: &[crate::flowspace::model::Variable],
     driver_roots: &[String],