rtx-fsi: stall acceptance as a knob (STALLX) — the floor must stay tight; only the rare-event window widens

FSI3's developed cycle stalls (bistable mask flips at max-velocity
crossings) sit at 3.5e-4 against the measured floor 6e-5: run 3 died
16% over the 5x window at t = 7.70. Riding the FLOOR up instead was
measured to make it worse — run 4 at floor 1e-4 died EARLIER (t = 6.30)
at a HIGHER stall (1.2e-3, 2.4x its window), because the accepted-step
scatter IS the wall-velocity noise (tol/dt_c): a looser floor feeds the
flip noise it is trying to pass. Keep the floor tight and widen only
the counted, bounded stall window: `stall_accept` (RTX_<CASE>_STALLX,
default 5 — both committed defaults bit-identical). Precedent: FSI2's
s = 1 benchmark run accepted a worst stall of 5.4e-4 the same way and
measured 0.1% in amplitude.

Co-Authored-By: Claude Fable 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01Lnyrw33Lu6rUhW42E9KHwq

crates/specialized/rtx-fsi/tests/fsi2_harness/march.rs

@@ -37,6 +37,18 @@ pub struct MarchConfig {
     /// reachable) floor.
     pub tol_floor: f64,
     pub rtol: f64,
+    /// Stall acceptance in multiples of the step tolerance (window =
+    /// max(stall_accept x tol_step, 0.1 x increment)). Default 5. The
+    /// FSI3 developed cycle needs more: its rare bistable-mask stalls
+    /// sit at 3.5e-4 against floor 6e-5 (measured, run 3 died 16% over
+    /// the 5x window at a max-velocity crossing), and RAISING THE FLOOR
+    /// INSTEAD MAKES IT WORSE — floor 1e-4 died EARLIER (t = 6.3 vs
+    /// 7.7) at a HIGHER stall (1.2e-3): the accepted-step scatter is
+    /// the wall-velocity noise (tol/dt_c), so a looser floor feeds the
+    /// flip noise it is trying to pass. Keep the floor tight; widen
+    /// only the rare-event window (FSI2's s = 1 benchmark run accepted
+    /// a worst stall of 5.4e-4 the same way and measured 0.1%).
+    pub stall_accept: f64,
     pub max_subiterations: usize,
     /// `"aitken"` (per-step scalar Aitken) or `"iqn"` (a persistent
     /// IQN-ILS whose secant history carries across steps).
@@ -94,6 +106,7 @@ impl MarchConfig {
             subcycle: num("SUBCYCLE", defaults.subcycle as f64) as usize,
             tol_floor: num("TOL", defaults.tol_floor),
             rtol: num("RTOL", defaults.rtol),
+            stall_accept: num("STALLX", defaults.stall_accept),
             max_subiterations: num("MAXSUB", defaults.max_subiterations as f64) as usize,
             coupler: std::env::var(key("COUPLER")).unwrap_or(defaults.coupler),
             reuse: num("REUSE", defaults.reuse as f64) as usize,
@@ -220,6 +233,7 @@ pub fn run_march(case: BenchmarkCase, config: &MarchConfig) -> MarchResult {
         subcycle,
         tol_floor,
         rtol,
+        stall_accept,
         max_subiterations: max_subiterations_budget,
         ref coupler,
         reuse,
@@ -437,12 +451,14 @@ pub fn run_march(case: BenchmarkCase, config: &MarchConfig) -> MarchResult {
             .sum::<f64>()
             .sqrt();
         let tol_step = tol_floor.max(rtol * increment);
-        // Acceptance beyond the tolerance: 5x the tolerance (noise
-        // bouncing over a well-predicted step) or an order below the
-        // step's own increment (the rare violent step near peak motion —
-        // the s = 1 FSI2 run died at residual = 9% of its increment).
-        // Counted as stalls and bounded by the caller.
-        let acceptable = (5.0 * tol_step).max(0.1 * increment);
+        // Acceptance beyond the tolerance: `stall_accept` x the
+        // tolerance (noise bouncing over a well-predicted step; see the
+        // config field for why FSI3's cycle needs a wider multiple than
+        // the default 5) or an order below the step's own increment
+        // (the rare violent step near peak motion — the s = 1 FSI2 run
+        // died at residual = 9% of its increment). Counted as stalls
+        // and bounded by the caller.
+        let acceptable = (stall_accept * tol_step).max(0.1 * increment);
         let mut outcome = if let Some(iqn) = iqn.as_mut() {
             iqn.set_tolerance(tol_step).unwrap();
             iqn.solve(&d_predicted, pass)