jit: widen the walker CALL_ASSEMBLER fold past four pyre-local declines

majit/majit-metainterp/src/pyjitpl.rs

@@ -14069,6 +14069,15 @@ impl<M: Clone> MetaInterp<M> {
     /// Pyre's `has_inline_frame_for` therefore walks `inline_frames`
     /// only, which counts the same population: already-inlined portal
     /// frames.
+    ///
+    /// Caller-free since the MIFrame value-op layer was retired (#686); the FBW
+    /// walker implements this gate independently
+    /// (`pyre-jit-trace/src/jitcode_dispatch/inline_call.rs`).  Kept as the
+    /// metainterp-side home of the whole `_opimpl_recursive_call` decision —
+    /// including the `dont_trace_here` side effect that the `recursive_decision`
+    /// closure defers until its producer slice is wired, and the not-tracing arm
+    /// no other caller of `decide_recursive_inline` models.  A census that finds
+    /// no callers here has found a retention decision, not dead weight.
     pub fn should_inline(&mut self, callee_key: u64, callee_raw: (usize, usize)) -> InlineDecision {
         // Extract inline-relevant info from ctx before calling impl
         // (avoids borrow conflict between self.tracing and &mut self).
@@ -17252,12 +17261,18 @@ pub(crate) fn decide_recursive_inline(
     // compiled it routes to CALL_ASSEMBLER against the resolvable token; when
     // it is not compiled, pyjitpl.py:1417 still takes `assembler_call = True`
     // and `get_assembler_token` synthesises the token on demand via
-    // `compile_tmp_callback` (warmstate.py:714-722).  There is no
-    // `compile_tmp_callback` here, so the not-compiled case is labelled
-    // `ResidualCall` — a stand-in meaning "no token yet, cannot emit
-    // CALL_ASSEMBLER" — which the dispatcher turns into abort/retry.  It is
-    // NOT pyjitpl.py's `inlining`-false residual (`assembler_call = False`)
-    // path.
+    // `compile_tmp_callback` (warmstate.py:714-722).
+    //
+    // `compile_tmp_callback` is ported (`compile.rs`) and two seams synthesise
+    // through it — `direct_assembler_call` and
+    // `get_or_make_portal_assembler_token_arc` — but neither is reachable from
+    // this predicate: it is pure in the five scalars, and token synthesis
+    // belongs to the emitter.  So the not-compiled case is labelled
+    // `ResidualCall` — a stand-in meaning "no token proven yet, do not commit
+    // to CALL_ASSEMBLER from here" — which the dispatcher turns into
+    // abort/retry when its own seam (`Runtime::recursive_call_assembler_target`)
+    // also comes back empty.  It is NOT pyjitpl.py's `inlining`-false residual
+    // (`assembler_call = False`) path.
     let non_inline = if callee_compiled {
         InlineDecision::CallAssembler
     } else {

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

@@ -3003,12 +3003,16 @@ where
             // `assembler_call = True` (pyjitpl.py:1417) →
             // `direct_assembler_call` → `get_assembler_token`, which
             // synthesises the callee token on demand via `compile_tmp_callback`
-            // (warmstate.py:714-722); it is NOT a residual call.  There is no
-            // `compile_tmp_callback` here (pyjitpl.rs `should_inline_core`),
-            // so the on-demand token cannot be built at this point: abort and
-            // retry until the callee compiles on its own, after which a later
-            // attempt takes the wired `CallAssembler` leg
-            // (`exec_recursive_call_assembler`).  pyjitpl.py's true residual
+            // (warmstate.py:714-722); it is NOT a residual call.
+            // `compile_tmp_callback` is ported (`compile.rs`), but reaching it
+            // here needs a `Runtime::recursive_call_assembler_target` that
+            // synthesises rather than reporting the tokens it already holds, and
+            // the decision itself arrives from a predicate with no synthesiser
+            // in reach (`decide_recursive_inline`).  So the on-demand token
+            // cannot be built at this point: abort and retry until the callee
+            // compiles on its own, after which a later attempt takes the wired
+            // `CallAssembler` leg (`exec_recursive_call_assembler`).
+            // pyjitpl.py's true residual
             // path (`assembler_call = False`, do_residual_call) is reachable
             // only when `inlining` is false, which is never the case here, so
             // it is intentionally unmodelled.

pyre/bench/synth/ca_bridge_multiframe_resume_double_call.cranelift.jitstats

@@ -8,7 +8,8 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3437
+guard_failures=3369
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3
+retraces_compiled=0

pyre/bench/synth/ca_bridge_multiframe_resume_double_call.dynasm.jitstats

@@ -8,7 +8,8 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3437
+guard_failures=3369
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3
+retraces_compiled=0

pyre/bench/synth/ca_bridge_multiframe_resume_double_call.wasm.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3437
+guard_failures=3369
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3

pyre/bench/synth/recursion_memo_branch.cranelift.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3554
+guard_failures=3491
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3

pyre/bench/synth/recursion_memo_branch.dynasm.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3554
+guard_failures=3491
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3

pyre/bench/synth/recursion_memo_branch.wasm.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=0
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=3554
+guard_failures=3491
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=3

pyre/bench/synth/recursion_past_unroll_bound_from_loop.cranelift.jitstats

@@ -0,0 +1,15 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=651
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=2
+retraces_compiled=0

pyre/bench/synth/recursion_past_unroll_bound_from_loop.dynasm.jitstats

@@ -0,0 +1,15 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=651
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=2
+retraces_compiled=0

pyre/bench/synth/recursion_past_unroll_bound_from_loop.py

@@ -0,0 +1,41 @@
+# pyre-check: max-pypy-ratio=6
+# A recursion deeper than the inline unroll bound, driven from a loop body.
+#
+# `step` recurses nine frames deep, two past `FBW_MAX_INLINE_RECURSION`, so the
+# walker stops unrolling it and the call has to leave the inline route. What
+# makes this shape distinct from every other recursion fixture is where the
+# call sits: the driver is a `while` body that keeps `total` — a loop-carried
+# operand — on the value stack underneath it.
+#
+# `fib_recursive` and `selfrec_bridge_nontail_promote` do not cover this. There
+# the recursion is itself the hot thing, so the callee owns a compiled loop
+# before any non-inline decision is taken. Here the hot thing is the caller's
+# loop, and the recursion is a callee it reaches; that ordering is what used to
+# leave the call as an interpreter residual for the rest of the run, one frame
+# build and one entry bridge per recursive call. `recursive_call_frame_relocation`
+# holds the neighbouring case, a recursion under a `FOR_ITER` iterator, which
+# stays on the residual path deliberately.
+#
+# `step` carries the accumulator down rather than returning into an addition, so
+# the recursion is a tail call and the caller's stack under it holds only
+# `total`. Arguments stay exact machine integers and the modulus keeps the
+# result in range, so nothing here promotes to a long.
+MOD = 1000003
+
+
+def step(n, acc):
+    if n <= 0:
+        return acc
+    return step(n - 1, acc + n)
+
+
+def main():
+    total = 0
+    i = 0
+    while i < 300000:
+        total = (total + step(8, i)) % MOD
+        i += 1
+    print("recursion_from_loop", total)
+
+
+main()

pyre/bench/synth/recursion_past_unroll_bound_from_loop.wasm.jitstats

@@ -0,0 +1,15 @@
+bridges_compiled=4
+descr_set_absent=0
+descr_set_ambiguous=0
+descr_set_stale_absent=0
+fbw_blackhole_adopted_multi_frame=0
+fbw_blackhole_adopted_single_frame=0
+fbw_rolled_back_with_effects=0
+fbw_store_journal_rollback_failed=0
+field_pos_attached_misplaced=0
+field_pos_spec_misplaced=0
+guard_failures=651
+internal_compile_panics=0
+loops_aborted=0
+loops_compiled=2
+retraces_compiled=0

pyre/bench/synth/recursive_forced_frame_kept_stack.cranelift.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=1
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=800
+guard_failures=600
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=2

pyre/bench/synth/recursive_forced_frame_kept_stack.dynasm.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=1
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=800
+guard_failures=600
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=2

pyre/bench/synth/recursive_forced_frame_kept_stack.wasm.jitstats

@@ -8,7 +8,7 @@ fbw_rolled_back_with_effects=1
 fbw_store_journal_rollback_failed=0
 field_pos_attached_misplaced=0
 field_pos_spec_misplaced=0
-guard_failures=800
+guard_failures=678
 internal_compile_panics=0
 loops_aborted=0
 loops_compiled=2

pyre/pyre-jit-trace/src/jitcode_dispatch/fbw_state.rs

@@ -242,6 +242,12 @@ pub(crate) fn fbw_executed_body_residual_reset() {
     FBW_EXECUTED_BODY_RESIDUAL.with(|c| c.set(false));
 }
 
+/// Whether the `CALL_ASSEMBLER` fold's own concrete-stamp executor is on the
+/// stack (see [`SELFREC_CA_FOLD_ACTIVE`]).
+pub(crate) fn selfrec_ca_fold_active() -> bool {
+    SELFREC_CA_FOLD_ACTIVE.with(|c| c.get())
+}
+
 /// Whether `PYRE_FBW_DEBUG_ABORT` is set.  When on, `full_body_walk_trace`
 /// prints the structured reason (the `DispatchError` variant or the
 /// non-loop-closing `DispatchOutcome`) for every walk that maps to
@@ -1650,7 +1656,7 @@ pub(crate) fn fbw_abort_nested_unjournaled_residual<Sym: WalkSym>(
     // depth (`pyjitpl.py`). Exempt only the self-recursive
     // `CALL_ASSEMBLER` fold's concrete-stamp executor from this pyre-local
     // nested-decline guard, which is for FOREIGN unjournaled residuals.
-    let in_selfrec_fold = SELFREC_CA_FOLD_ACTIVE.with(|c| c.get());
+    let in_selfrec_fold = selfrec_ca_fold_active();
     let in_exception_string_inline = EXCEPTION_STRING_INLINE_ACTIVE.with(|c| c.get());
     // A FOR_ITER-body inline admitted under `CalleeReplaySafety::DeferredCall`
     // stands on the promise that the sub-walk commits nothing: the static scan