perf(wchar): add 4-byte wcstombs SIMD encode (bd-w7mtzu)

Dicklesworthstone · Dicklesworthstone · commit 5111bc3ac8f7 · 2026-06-13T05:11:05.000-04:00
Same-worker RCH vmi1153651 Criterion wchar_wcstombs/astral_4byte improved from [16.014 us 17.148 us 18.625 us] to [918.85 ns 997.60 ns 1.0930 us] for 1024 astral codepoints, 17.19x faster by middle estimate.

Proof: local and RCH vmi1153651 core scalar-isomorphism, live-glibc conformance_diff_wcstombs_simd, and golden_wchar_conv_reentry passed with unchanged wide SHA e52563fe0c036cc2d97d9b14a28d8d0e3adeec307686eecf8122466ca95dab50 and byte SHA 5f71c2382d1655e56994e4022f3e88be237d22350f6af9bd744680ec108aad6e. Touched-file rustfmt, crate-scoped checks, and git diff --check passed. Focused clippy remains blocked by pre-existing exp/sort/fnmatch/regex lint debt outside this change.
diff --git a/.skill-loop-progress.md b/.skill-loop-progress.md
@@ -781,3 +781,13 @@
 - Same-worker post: `wchar_wcstombs/cjk_3byte` improved to `[966.19 ns 1.0170 us 1.0763 us]`, throughput `[951.44 Melem/s 1.0069 Gelem/s 1.0598 Gelem/s]`. Middle estimate improved `11.849 us -> 1.0170 us` (`11.65x` faster), or `11.571 ns/wc -> 0.993 ns/wc`.
 - Verdict: KEPT, Score `(Impact 5.0 x Confidence 5.0) / Effort 2.0 = 12.5`. Artifact: `tests/artifacts/perf/bd-w7mtzu-wcstombs-3byte-simd.md`.
 - Remaining route on `bd-w7mtzu`: 4-byte astral paths remain open; do not call the bead fully closed until that lane is separately profiled and addressed.
+
+### Pass 85 - Wcstombs 4-byte UTF-8 Packed SIMD Encode - 2026-06-13T09:08:00Z
+- Target: `bd-w7mtzu` / `wcstombs` pure 4-byte astral/RFC2279 encode, selected after adding focused astral Criterion rows and measuring both directions on same-worker RCH.
+- Focused same-worker baseline: RCH `vmi1153651` `wchar_mbstowcs/astral_4byte` `[11.407 us 12.128 us 12.874 us]`; `wchar_wcstombs/astral_4byte` `[16.014 us 17.148 us 18.625 us]` for 1024 codepoints, making encode the larger scalar residual.
+- One retained lever: add a four-wide packed byte-lane SIMD encoder for scalar `wctomb`'s existing RFC 2279 4-byte branch (`0x1_0000..0x20_0000`). It computes lead/continuation lanes, packs them with `simd_swizzle!` into one `u8x16`, and writes a 16-byte window. ASCII, 2/3-byte, 5/6-byte, invalid, NUL, mixed-window, and short-output cases fall back to scalar `wctomb`.
+- Behavior proof: local and RCH `vmi1153651` core scalar-isomorphism passed with new deterministic 4-byte windows; local and RCH `vmi1153651` live-glibc `conformance_diff_wcstombs_simd` passed after extending to 2/3/4-byte-heavy fuzz; local and RCH `vmi1153651` golden `golden_wchar_conv_reentry` passed with unchanged wide SHA `e52563fe0c036cc2d97d9b14a28d8d0e3adeec307686eecf8122466ca95dab50` and round-trip byte SHA `5f71c2382d1655e56994e4022f3e88be237d22350f6af9bd744680ec108aad6e`.
+- Validation notes: touched-file `rustfmt --check`, local crate-scoped checks, and `git diff --check` passed. Focused clippy remains blocked by pre-existing lint debt in `math/exp.rs`, `stdlib/sort.rs`, `string/fnmatch.rs`, and `string/regex.rs`; no reported clippy error is in this pass's touched files.
+- Same-worker post: `wchar_wcstombs/astral_4byte` improved to `[918.85 ns 997.60 ns 1.0930 us]`, throughput `[936.85 Melem/s 1.0265 Gelem/s 1.1144 Gelem/s]`. Middle estimate improved `17.148 us -> 997.60 ns` (`17.19x` faster), or `16.746 ns/wc -> 0.974 ns/wc`.
+- Verdict: KEPT, Score `(Impact 5.0 x Confidence 5.0) / Effort 2.0 = 12.5`. Artifact: `tests/artifacts/perf/bd-w7mtzu-wchar-4byte-simd.md`.
+- Remaining route on `bd-w7mtzu`: 4-byte `mbstowcs` decode remains open and still needs its own profile/proof loop.
diff --git a/crates/frankenlibc-abi/tests/conformance_diff_wcstombs_simd.rs b/crates/frankenlibc-abi/tests/conformance_diff_wcstombs_simd.rs
@@ -1,17 +1,19 @@
 #![cfg(target_os = "linux")]
 #![allow(unsafe_code)] // live host-glibc wcstombs oracle
 
-//! Differential fuzz for the SIMD 2-byte and 3-byte UTF-8 *encode* fast paths in
+//! Differential fuzz for the SIMD 2-byte, 3-byte, and 4-byte UTF-8 *encode* fast paths in
 //! `frankenlibc_core::string::wchar::wcstombs` (bd-w7mtzu).
 //!
 //! The fast path encodes runs of >= 8 wide chars all in 0x80..=0x7FF — each to
 //! exactly two UTF-8 bytes — 8 chars per 16-byte vector. It must be byte-for-byte
 //! identical to scalar `wctomb`. The 3-byte path does the same for clean BMP
 //! non-surrogate runs in 0x0800..=0xFFFF, four wide chars per 12 output bytes.
-//! This fuzzes 2/3-byte-heavy wide-char arrays (interleaved with ASCII, 4-byte
-//! code points, surrogates, out-of-range values, and runs straddling both SIMD
-//! window sizes) against the LIVE host glibc `wcstombs` oracle (C.UTF-8),
-//! comparing the full byte output and the success/error decision on every case.
+//! The 4-byte path covers scalar `wctomb`'s RFC 2279 branch
+//! 0x1_0000..0x20_0000, four wide chars per 16 output bytes. This fuzzes
+//! 2/3/4-byte-heavy wide-char arrays (interleaved with ASCII, 5/6-byte code
+//! points, surrogates, out-of-range values, and runs straddling all SIMD window
+//! sizes) against the LIVE host glibc `wcstombs` oracle (C.UTF-8), comparing the
+//! full byte output and the success/error decision on every case.
 
 use std::ffi::c_char;
 
@@ -36,7 +38,7 @@ impl Lcg {
 
 fn glibc_wcstombs(src: &[i32]) -> Option<Vec<u8>> {
     // src must be NUL-terminated (a 0 wchar) for glibc.
-    let mut dst = vec![0i8; src.len() * 4 + 4];
+    let mut dst = vec![0i8; src.len() * 6 + 6];
     let n = unsafe { wcstombs(dst.as_mut_ptr(), src.as_ptr(), dst.len()) };
     if n == usize::MAX {
         None
@@ -48,7 +50,7 @@ fn glibc_wcstombs(src: &[i32]) -> Option<Vec<u8>> {
 fn fl_wcstombs(src: &[i32]) -> Option<Vec<u8>> {
     let nul = src.iter().position(|&w| w == 0).unwrap_or(src.len());
     let su: Vec<u32> = src[..nul].iter().map(|&w| w as u32).collect();
-    let mut dst = vec![0u8; src.len() * 4 + 4];
+    let mut dst = vec![0u8; src.len() * 6 + 6];
     frankenlibc_core::string::wchar::wcstombs(&mut dst, &su).map(|n| dst[..n].to_vec())
 }
 
@@ -62,8 +64,18 @@ fn valid_3byte_codepoint(r: &mut Lcg) -> i32 {
     }
 }
 
+fn valid_4byte_codepoint(r: &mut Lcg) -> i32 {
+    match r.below(5) {
+        0 => 0x1_0000 + r.below(0x1000) as i32,
+        1 => 0x1F600 + r.below(0x80) as i32,
+        2 => 0x10_FFFF,
+        3 => 0x11_0000 + r.below(0x1000) as i32,
+        _ => 0x1F_FFFF,
+    }
+}
+
 #[test]
-fn wcstombs_simd_2byte_and_3byte_matches_glibc() {
+fn wcstombs_simd_2byte_3byte_and_4byte_matches_glibc() {
     unsafe {
         setlocale(6 /*LC_ALL*/, b"C.UTF-8\0".as_ptr() as *const c_char)
     };
@@ -76,7 +88,7 @@ fn wcstombs_simd_2byte_and_3byte_matches_glibc() {
         let mut s: Vec<i32> = Vec::new();
         let segs = r.below(20);
         for _ in 0..segs {
-            match r.below(10) {
+            match r.below(12) {
                 // Bias toward 2-byte code points (the SIMD path), in runs.
                 0..=3 => {
                     let run = 1 + r.below(12);
@@ -91,17 +103,23 @@ fn wcstombs_simd_2byte_and_3byte_matches_glibc() {
                         s.push(valid_3byte_codepoint(&mut r));
                     }
                 }
-                8 => {
+                // Bias toward valid 4-byte code points, in runs.
+                8..=9 => {
+                    let run = 1 + r.below(12);
+                    for _ in 0..run {
+                        s.push(valid_4byte_codepoint(&mut r));
+                    }
+                }
+                10 => {
                     for _ in 0..(1 + r.below(10)) {
                         s.push((1 + r.below(0x7F)) as i32); // ASCII
                     }
                 }
-                9 if r.below(2) == 0 => s.push((0x1_0000 + r.below(0x10_0000)) as i32), // 4-byte astral
                 _ => {
-                    // Edge values: surrogates / out-of-range (glibc & fl both error).
+                    // Edge values: surrogates / 5-6-byte / out-of-range.
                     match r.below(3) {
                         0 => s.push((0xD800 + r.below(0x800)) as i32), // surrogate
-                        1 => s.push(0x11_0000 + r.below(0x1000) as i32), // > U+10FFFF
+                        1 => s.push(0x20_0000 + r.below(0x1000) as i32), // 5-byte branch
                         _ => s.push((0x80 + r.below(0x780)) as i32),
                     }
                 }
@@ -124,7 +142,7 @@ fn wcstombs_simd_2byte_and_3byte_matches_glibc() {
 
     assert!(
         divs.is_empty(),
-        "wcstombs SIMD 2-byte path diverged from glibc on some of {compared} cases (up to 20):\n{}",
+        "wcstombs SIMD encode paths diverged from glibc on some of {compared} cases (up to 20):\n{}",
         divs.join("\n")
     );
 }
diff --git a/crates/frankenlibc-bench/benches/wchar_bench.rs b/crates/frankenlibc-bench/benches/wchar_bench.rs
@@ -25,8 +25,22 @@ fn bench_mbstowcs(c: &mut Criterion) {
         }
         mixed.push(b' ');
     }
+    // Pure 4-byte astral codepoints. This isolates the remaining scalar
+    // multibyte decode lane after 2-byte and 3-byte SIMD windows landed.
+    let mut astral_4byte: Vec<u8> = Vec::with_capacity(1024 * 4);
+    for i in 0..1024 {
+        let cp = 0x1F600 + (i % 0x80) as u32;
+        astral_4byte.push(0xF0 | (cp >> 18) as u8);
+        astral_4byte.push(0x80 | ((cp >> 12) & 0x3F) as u8);
+        astral_4byte.push(0x80 | ((cp >> 6) & 0x3F) as u8);
+        astral_4byte.push(0x80 | (cp & 0x3F) as u8);
+    }
 
-    let cases: &[(&str, &[u8])] = &[("ascii_1k", &ascii), ("mixed_utf8", &mixed)];
+    let cases: &[(&str, &[u8])] = &[
+        ("ascii_1k", &ascii),
+        ("astral_4byte", &astral_4byte),
+        ("mixed_utf8", &mixed),
+    ];
 
     let mut group = c.benchmark_group("wchar_mbstowcs");
     for &(name, src) in cases {
@@ -48,6 +62,9 @@ fn bench_wcstombs(c: &mut Criterion) {
     // Pure 3-byte BMP codepoints. This is the remaining multibyte encode lane
     // after the 2-byte SIMD path landed.
     let cjk_3byte: Vec<u32> = (0..1024).map(|i| 0x4E00 + (i % 0x100) as u32).collect();
+    // Pure 4-byte astral codepoints. This isolates the remaining scalar
+    // multibyte encode lane after 2-byte and 3-byte SIMD windows landed.
+    let astral_4byte: Vec<u32> = (0..1024).map(|i| 0x1F600 + (i % 0x80) as u32).collect();
     // Mixed: ASCII runs interleaved with 2/3-byte codepoints.
     let mut mixed: Vec<u32> = Vec::new();
     for i in 0..128 {
@@ -58,6 +75,7 @@ fn bench_wcstombs(c: &mut Criterion) {
 
     let cases: &[(&str, &[u32])] = &[
         ("ascii_1k", &ascii),
+        ("astral_4byte", &astral_4byte),
         ("cjk_3byte", &cjk_3byte),
         ("mixed_utf8", &mixed),
     ];
diff --git a/crates/frankenlibc-core/src/string/wchar.rs b/crates/frankenlibc-core/src/string/wchar.rs
@@ -592,6 +592,39 @@ pub fn wcstombs(dest: &mut [u8], src: &[u32]) -> Option<usize> {
             di += 12;
         }
 
+        // SIMD 4-byte encode fast path for scalar wctomb's RFC 2279 4-byte
+        // branch. Each clean window maps four code points in
+        // 0x1_0000..0x20_0000 to exactly sixteen output bytes. ASCII, 2/3-byte,
+        // 5/6-byte, invalid, NUL, mixed-window, and short-output cases fall
+        // through to scalar `wctomb`, preserving glibc-compatible semantics.
+        while si + 4 <= src.len()
+            && di + 16 <= dest.len()
+            && (0x1_0000..0x20_0000).contains(&src[si])
+        {
+            let ws: [u32; 4] = src[si..si + 4].try_into().unwrap();
+            let v = Simd::<u32, 4>::from_array(ws);
+            if !(v.simd_ge(Simd::splat(0x1_0000)) & v.simd_lt(Simd::splat(0x20_0000))).all() {
+                break;
+            }
+
+            let leads = ((v >> Simd::splat(18)) | Simd::splat(0xF0)).cast::<u8>();
+            let cont1 =
+                (((v >> Simd::splat(12)) & Simd::splat(0x3F)) | Simd::splat(0x80)).cast::<u8>();
+            let cont2 =
+                (((v >> Simd::splat(6)) & Simd::splat(0x3F)) | Simd::splat(0x80)).cast::<u8>();
+            let cont3 = ((v & Simd::splat(0x3F)) | Simd::splat(0x80)).cast::<u8>();
+            let lead_cont1 = std::simd::simd_swizzle!(leads, cont1, [0, 4, 1, 5, 2, 6, 3, 7]);
+            let cont2_cont3 = std::simd::simd_swizzle!(cont2, cont3, [0, 4, 1, 5, 2, 6, 3, 7]);
+            let bytes = std::simd::simd_swizzle!(
+                lead_cont1,
+                cont2_cont3,
+                [0, 1, 8, 9, 2, 3, 10, 11, 4, 5, 12, 13, 6, 7, 14, 15]
+            );
+            bytes.copy_to_slice(&mut dest[di..di + 16]);
+            si += 4;
+            di += 16;
+        }
+
         // One scalar step, then re-attempt the SIMD run.
         if si >= src.len() {
             return Some(di);
@@ -819,6 +852,22 @@ mod tests {
             }
             corpus.push(v);
         }
+        // Pure 4-byte runs around the 4-codepoint SIMD window. The upper cases
+        // intentionally cover scalar wctomb's glibc-compatible RFC 2279 range,
+        // not just Unicode scalar values through U+10FFFF.
+        for len in 0..40usize {
+            let mut v = Vec::with_capacity(len);
+            for i in 0..len {
+                v.push(match i % 5 {
+                    0 => 0x1_0000,
+                    1 => 0x1F600 + (i as u32 % 0x80),
+                    2 => 0x10_FFFF,
+                    3 => 0x11_0000 + (i as u32 % 0x100),
+                    _ => 0x1F_FFFF,
+                });
+            }
+            corpus.push(v);
+        }
         // Surrogates / out-of-range values wctomb rejects (must bail to scalar
         // and return None identically).
         corpus.push(vec![0x78, 0x79, 0xD800, 0x7A]);
diff --git a/tests/artifacts/perf/bd-w7mtzu-wchar-4byte-simd.md b/tests/artifacts/perf/bd-w7mtzu-wchar-4byte-simd.md
@@ -0,0 +1,150 @@
+# bd-w7mtzu - wcstombs 4-byte packed SIMD encode keep
+
+Date: 2026-06-13
+Agent: BoldFalcon
+Bead: `bd-w7mtzu`
+Lever: packed four-wide UTF-8 4-byte encode window in `wcstombs`
+Verdict: KEPT
+Score: `(Impact 5.0 x Confidence 5.0) / Effort 2.0 = 12.5`
+
+## Target
+
+After the retained 2-byte, 3-byte decode, and 3-byte encode windows, the
+remaining profiled wchar residual was the astral 4-byte lane. A focused
+Criterion row was added before the production edit for both directions:
+
+- `wchar_mbstowcs/astral_4byte`
+- `wchar_wcstombs/astral_4byte`
+
+The baseline selected encode as the next lever: `wcstombs/astral_4byte`
+was slower than decode and still scalar per codepoint.
+
+## Recommendation Contract
+
+- Change: add a fixed-width packed byte-lane SIMD encoder for scalar
+  `wctomb`'s RFC 2279 4-byte branch.
+- Failure signature evidence: same-worker `vmi1153651` Criterion baseline
+  showed `wchar_wcstombs/astral_4byte` middle `17.148 us` for 1024 codepoints.
+- Mapped primitive: SIMD batching plus explicit UTF-8 state/range automaton.
+- EV score: `(Impact 5 x Confidence 5 x Reuse 2) / (Effort 2 x Friction 1) = 25`.
+- Relevance score: 5.0, directly targets the measured scalar hot lane.
+- Primary risk: accepting or rejecting a different codepoint set than scalar
+  `wctomb`. Countermeasure: SIMD path is gated to `0x1_0000..0x20_0000`, the
+  exact scalar 4-byte branch, with all other values falling back to scalar.
+- Budgeted mode: one fixed 4-codepoint window per iteration; no adaptive state.
+- Fallback trigger: any mixed-width, NUL, short-output, 2/3-byte, 5/6-byte, or
+  invalid window breaks to the scalar `wctomb` step.
+- Baseline comparator: same-worker Criterion baseline on `vmi1153651`.
+- Rollback: revert the single commit that adds the 4-byte encode window.
+- Verification artifacts: core scalar-isomorphism, live-glibc differential,
+  golden SHA reentry, same-worker Criterion before/after, touched-file rustfmt,
+  `git diff --check`.
+
+## Baseline
+
+RCH command:
+
+```text
+env RCH_REQUIRE_REMOTE=1 RCH_WORKER=vmi1153651 RCH_VISIBILITY=summary \
+  RCH_QUEUE_WHEN_BUSY=1 RCH_DAEMON_WAIT_RESPONSE_TIMEOUT_SECS=900 rch exec -- \
+  env AGENT_NAME=BoldFalcon FRANKENLIBC_BENCH_PIN=1 CARGO_BUILD_JOBS=1 \
+  cargo bench -j 1 -p frankenlibc-bench --bench wchar_bench -- \
+  astral_4byte --noplot --sample-size 60 --warm-up-time 1 --measurement-time 3
+```
+
+Baseline on `vmi1153651`:
+
+```text
+wchar_mbstowcs/astral_4byte
+  [11.407 us 12.128 us 12.874 us]
+  [303.43 MiB/s 322.09 MiB/s 342.45 MiB/s]
+
+wchar_wcstombs/astral_4byte
+  [16.014 us 17.148 us 18.625 us]
+  [54.981 Melem/s 59.715 Melem/s 63.942 Melem/s]
+```
+
+## Change
+
+`wcstombs` now has a 4-codepoint SIMD encode window after the 3-byte path:
+
+- Range gate: all four `u32` codepoints must be in `0x1_0000..0x20_0000`.
+- Byte lanes:
+  - `0xF0 | (wc >> 18)`
+  - `0x80 | ((wc >> 12) & 0x3F)`
+  - `0x80 | ((wc >> 6) & 0x3F)`
+  - `0x80 | (wc & 0x3F)`
+- Packing: `simd_swizzle!` interleaves the four byte lanes into one `u8x16`.
+- Store: one `copy_to_slice` writes the 16-byte window.
+
+This is one lever: it does not change 4-byte decode, ASCII, 2-byte, 3-byte,
+5/6-byte, invalid, NUL, or short-output scalar behavior.
+
+## Isomorphism
+
+- Ordering preserved: output byte triples/quads are packed in source order.
+- Tie-breaking unchanged: not applicable.
+- Floating point: not involved.
+- RNG seeds: unchanged/not involved.
+- Error behavior: unchanged. The SIMD path fires only for scalar `wctomb`'s
+  existing 4-byte branch. Surrogates, out-of-range values, 5/6-byte values,
+  NULs, mixed-width windows, and insufficient output capacity use scalar
+  `wctomb`.
+- Truncation behavior: unchanged. The SIMD path requires 16 output bytes before
+  firing; otherwise scalar handles exact remaining capacity.
+
+## Proof
+
+Local:
+
+- `cargo test -j 1 -p frankenlibc-core --lib wcstombs_simd_isomorphic_to_scalar -- --nocapture --test-threads=1`: passed.
+- `cargo test -j 1 -p frankenlibc-abi --test conformance_diff_wcstombs_simd -- --nocapture --test-threads=1`: passed.
+- `cargo test -j 1 -p frankenlibc-abi --test golden_wchar_conv_reentry -- --nocapture --test-threads=1`: passed.
+- `rustfmt --check crates/frankenlibc-core/src/string/wchar.rs crates/frankenlibc-abi/tests/conformance_diff_wcstombs_simd.rs crates/frankenlibc-bench/benches/wchar_bench.rs`: passed.
+- `cargo check -j 1 -p frankenlibc-core --lib`: passed.
+- `cargo check -j 1 -p frankenlibc-abi --test conformance_diff_wcstombs_simd`: passed with the existing `wchar_abi.rs` `work_local` unused-assignment warning.
+- `cargo check -j 1 -p frankenlibc-bench --bench wchar_bench`: passed.
+- `git diff --check`: passed.
+
+RCH `vmi1153651`:
+
+- `cargo test -j 1 -p frankenlibc-core --lib wcstombs_simd_isomorphic_to_scalar -- --nocapture --test-threads=1`: passed.
+- `cargo test -j 1 -p frankenlibc-abi --test conformance_diff_wcstombs_simd -- --nocapture --test-threads=1`: passed.
+- `cargo test -j 1 -p frankenlibc-abi --test golden_wchar_conv_reentry -- --nocapture --test-threads=1`: passed.
+- Golden SHA: `mbstowcs wide sha256=e52563fe0c036cc2d97d9b14a28d8d0e3adeec307686eecf8122466ca95dab50`.
+- Golden SHA: `wcstombs back sha256=5f71c2382d1655e56994e4022f3e88be237d22350f6af9bd744680ec108aad6e`.
+
+Known environment noise:
+
+- RCH and local builds report the existing missing SMT solver warning.
+- ABI builds report the existing `wchar_abi.rs` `work_local` unused-assignment warning.
+- Focused `cargo clippy -j 1 -p frankenlibc-core --lib -- -D warnings`
+  remains blocked by pre-existing lint debt in `math/exp.rs`, `stdlib/sort.rs`,
+  `string/fnmatch.rs`, and `string/regex.rs`. No reported clippy error was in
+  this pass's touched wchar encoder/test/bench files.
+
+## Post
+
+Same-worker RCH post on `vmi1153651`, same command:
+
+```text
+wchar_mbstowcs/astral_4byte
+  [10.735 us 10.994 us 11.304 us]
+  [345.56 MiB/s 355.29 MiB/s 363.88 MiB/s]
+
+wchar_wcstombs/astral_4byte
+  [918.85 ns 997.60 ns 1.0930 us]
+  [936.85 Melem/s 1.0265 Gelem/s 1.1144 Gelem/s]
+```
+
+Encode improvement:
+
+- Middle estimate: `17.148 us -> 997.60 ns`, `17.19x` faster.
+- Per-codepoint middle estimate: `16.746 ns/wc -> 0.974 ns/wc`.
+- Throughput middle estimate: `59.715 Melem/s -> 1.0265 Gelem/s`.
+
+## Remaining
+
+`bd-w7mtzu` should remain open for the 4-byte `mbstowcs` decode lane, which is
+still scalar and measured at `12.128 us` baseline / `10.994 us` post-control on
+this run. Re-profile it separately before changing decode.
