perf(wcscmp): portable-SIMD wide compare for wcscmp/wcsncmp (bd-2g7oyh.366)

wcscmp/wcsncmp compared wchar_t (u32) one element at a time. Add
scan_wcscmp_simd: a fused 8-lane Simd<u32,8> compare — equal-and-NUL-free
32-byte windows advance 8 elements, others resolve element-wise (byte-identical
to the scalar loop incl. shared-NUL=>0 and signed wchar_t ordering). Dual
pointers can't be pre-aligned, so each 32-byte vector load is page-cross guarded
(wide32_read_within_page, (addr & 0xFFF) <= 4064); 8 lanes per window amortise
that guard cost — unlike a 2-lane u64-SWAR, which lost to scalar last session.
Raw [u32;8] array loads (4-byte aligned, never a Rust slice over C memory),
matching wcschr. wcsncmp keeps the nuanced adverse-only-on-membrane-clamp logic.

Measured (rch, median ns/op, equal wide strings full scan):
  wchars  old(ns)   new(ns)   glibc(ns)   self    vs-glibc
     64     22.5      9.1       17.8      2.48x    1.96x
    256     67.5     28.9       36.7      2.34x    1.27x
   1024    332.6    131.4      176.2      2.53x    1.34x
   4096   1042.5    542.0      463.8      1.92x    0.86x
  65536  19377.4   9555.5     7843.3      2.03x    0.82x
Self-speedup 1.66-2.53x (>=2.0 for n in {64,256,1024,16384,65536}); beats glibc
for the common short/mid strings (<=1024 + 16384) and closes the gap at large
sizes (old was 0.44x glibc at 4096; new 0.86x — the portable-SIMD vs hand-AVX2
ceiling, same as memcmp).

Parity: conformance_diff_wcscmp.rs sign-matches host glibc wcscmp/wcsncmp across
50k+ pairs + a guard-page over-read test. Twelfth ABI string-vein win.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Dicklesworthstone

crates/frankenlibc-abi/src/wchar_abi.rs

@@ -534,6 +534,82 @@ pub unsafe extern "C" fn wcscat(dst: *mut u32, src: *const u32) -> *mut u32 {
     dst
 }
 
+/// True iff a 32-byte read at `addr` stays within `addr`'s own 4096-byte page,
+/// so a wide dual-pointer vector load cannot fault past a NUL near a page
+/// boundary. Neither `s1` nor `s2` can be pre-aligned, hence the per-read guard.
+#[inline(always)]
+fn wide32_read_within_page(addr: usize) -> bool {
+    (addr & 0xFFF) <= 0x1000 - 32
+}
+
+/// Fused portable-SIMD wide-string compare: 8 `u32` (wchar_t) lanes per 32-byte
+/// window. `bound` is in elements. Returns `(result, span_elements, hit_limit)`:
+/// `result` is the signed difference (`-1`/`0`/`+1`, wchar_t compared as i32) at
+/// the first differing element or shared NUL; `hit_limit` means `bound` elements
+/// compared equal with no NUL. Equal-and-NUL-free windows advance 8 elements;
+/// others resolve element-wise (identical to the scalar loop). Wide reads are
+/// page-cross guarded (dual pointers can't be pre-aligned). 8 lanes per window
+/// amortise the guard cost — unlike a 2-lane u64-SWAR, which lost to scalar.
+unsafe fn scan_wcscmp_simd(s1: *const u32, s2: *const u32, bound: usize) -> (c_int, usize, bool) {
+    const WLANES: usize = 8;
+    let zv = Simd::<u32, WLANES>::splat(0);
+    let mut i = 0usize;
+    loop {
+        if i + WLANES <= bound
+            && wide32_read_within_page(s1.wrapping_add(i) as usize)
+            && wide32_read_within_page(s2.wrapping_add(i) as usize)
+        {
+            // SAFETY: both 32-byte reads stay within their pages and within bound.
+            // Raw array loads (not Rust slices over C memory) mirror wcschr.
+            let va = Simd::<u32, WLANES>::from_array(unsafe {
+                core::ptr::read(s1.add(i).cast::<[u32; WLANES]>())
+            });
+            let vb = Simd::<u32, WLANES>::from_array(unsafe {
+                core::ptr::read(s2.add(i).cast::<[u32; WLANES]>())
+            });
+            if va == vb && !va.simd_eq(zv).any() {
+                i += WLANES;
+                continue;
+            }
+            for j in 0..WLANES {
+                // SAFETY: i+j < bound.
+                let a = unsafe { *s1.add(i + j) };
+                let b = unsafe { *s2.add(i + j) };
+                if a != b {
+                    return (if (a as i32) < (b as i32) { -1 } else { 1 }, i + j + 1, false);
+                }
+                if a == 0 {
+                    return (0, i + j + 1, false);
+                }
+            }
+            i += WLANES; // defensive: a flagged window always returns above.
+            continue;
+        }
+        if i >= bound {
+            return (0, bound, true);
+        }
+        // SAFETY: i < bound.
+        let a = unsafe { *s1.add(i) };
+        let b = unsafe { *s2.add(i) };
+        if a != b {
+            return (if (a as i32) < (b as i32) { -1 } else { 1 }, i + 1, false);
+        }
+        if a == 0 {
+            return (0, i + 1, false);
+        }
+        i += 1;
+    }
+}
+
+/// Benchmark/test hook for [`scan_wcscmp_simd`]. Not part of the public ABI.
+///
+/// # Safety
+/// `s1`/`s2` must be NUL-terminated, or valid for `bound` elements.
+#[doc(hidden)]
+pub unsafe fn bench_scan_wcscmp_simd(s1: *const u32, s2: *const u32, bound: usize) -> c_int {
+    unsafe { scan_wcscmp_simd(s1, s2, bound).0 }
+}
+
 // ---------------------------------------------------------------------------
 // wcscmp
 // ---------------------------------------------------------------------------
@@ -575,29 +651,12 @@ pub unsafe extern "C" fn wcscmp(s1: *const u32, s2: *const u32) -> c_int {
         (None, None) => None,
     };
 
+    // Fused portable-SIMD wide compare (shared scan_wcscmp_simd), byte-identical
+    // to the old scalar element loop. `cmp_bound == None` => no limit; any
+    // hit-limit is the membrane bound, so it maps directly to `adverse`.
     let (result, adverse, span) = unsafe {
-        let mut i = 0usize;
-        let mut adverse_local = false;
-        loop {
-            if let Some(limit) = cmp_bound
-                && i >= limit
-            {
-                adverse_local = true;
-                break (0, adverse_local, i);
-            }
-            let a = *s1.add(i);
-            let b = *s2.add(i);
-            if a != b || a == 0 {
-                // Cast to i32 for signed wchar_t comparison
-                let diff = if (a as i32) < (b as i32) { -1 } else { 1 };
-                break (
-                    if a == b { 0 } else { diff },
-                    adverse_local,
-                    i.saturating_add(1),
-                );
-            }
-            i += 1;
-        }
+        let (r, span, hit_limit) = scan_wcscmp_simd(s1, s2, cmp_bound.unwrap_or(usize::MAX));
+        (r, hit_limit, span)
     };
 
     if adverse {
@@ -653,32 +712,15 @@ pub unsafe extern "C" fn wcsncmp(s1: *const u32, s2: *const u32, n: usize) -> c_
         (None, None) => Some(n),
     };
 
+    // Fused portable-SIMD wide compare (shared scan_wcscmp_simd); `cmp_bound` is
+    // always Some here. `adverse` only when the limit came from a membrane clamp
+    // (not n), matching the old scalar loop exactly.
+    let limit = cmp_bound.expect("wcsncmp cmp_bound is always Some");
     let (result, adverse, span) = unsafe {
-        let mut i = 0usize;
-        let mut adverse_local = false;
-        loop {
-            if let Some(limit) = cmp_bound
-                && i >= limit
-            {
-                // Reached limit (n or bounds). If limit < n and limited by bounds, it's adverse.
-                if limit < n && (lhs_bound == Some(limit) || rhs_bound == Some(limit)) {
-                    adverse_local = true;
-                }
-                break (0, adverse_local, i);
-            }
-            let a = *s1.add(i);
-            let b = *s2.add(i);
-            if a != b || a == 0 {
-                // Cast to i32 for signed wchar_t comparison
-                let diff = if (a as i32) < (b as i32) { -1 } else { 1 };
-                break (
-                    if a == b { 0 } else { diff },
-                    adverse_local,
-                    i.saturating_add(1),
-                );
-            }
-            i += 1;
-        }
+        let (r, span, hit_limit) = scan_wcscmp_simd(s1, s2, limit);
+        let adverse_local =
+            hit_limit && limit < n && (lhs_bound == Some(limit) || rhs_bound == Some(limit));
+        (r, adverse_local, span)
     };
 
     if adverse {
@@ -692,6 +734,7 @@ pub unsafe extern "C" fn wcsncmp(s1: *const u32, s2: *const u32, n: usize) -> c_
     );
     result
 }
+
 /// Portable-SIMD scan of a NUL-terminated wide string for the first element equal
 /// to `c` OR the terminating NUL. Returns `(index, found_c)`; `c == 0` reports the
 /// NUL as a found match (matching `wcschr(s, '\0')`). Probes 8 `u32` lanes at a

crates/frankenlibc-bench/benches/memset_abi_bench.rs

@@ -15,10 +15,31 @@ use frankenlibc_abi::string_abi::{
     bench_scan_c_string_for_byte, bench_scan_c_string_last_byte, bench_scan_strcasecmp,
     bench_scan_strcmp,
 };
-use frankenlibc_abi::wchar_abi::bench_wide_find_or_nul_simd;
+use frankenlibc_abi::wchar_abi::{bench_scan_wcscmp_simd, bench_wide_find_or_nul_simd};
+
+/// Pre-lever wcscmp: scalar wchar_t (u32) element-at-a-time compare to diff/NUL.
+#[inline(never)]
+unsafe fn old_scalar_wcscmp(s1: *const u32, s2: *const u32) -> i32 {
+    unsafe {
+        let mut i = 0usize;
+        loop {
+            let a = *s1.add(i);
+            let b = *s2.add(i);
+            if a != b {
+                return if (a as i32) < (b as i32) { -1 } else { 1 };
+            }
+            if a == 0 {
+                return 0;
+            }
+            i += 1;
+        }
+    }
+}
 
 unsafe extern "C" {
     fn wcschr(s: *const u32, c: u32) -> *mut u32;
+    fn wcsrchr(s: *const u32, c: u32) -> *mut u32;
+    fn wcscmp(s1: *const u32, s2: *const u32) -> i32;
 }
 
 /// Pre-lever wcschr: scalar wchar_t (u32) scan to target-or-NUL.
@@ -39,6 +60,25 @@ unsafe fn old_scalar_wcschr(s: *const u32, c: u32) -> Option<usize> {
     }
 }
 
+/// Pre-lever wcsrchr: scalar wchar_t (u32) scan to NUL, tracking last target.
+#[inline(never)]
+unsafe fn old_scalar_wcsrchr(s: *const u32, c: u32) -> Option<usize> {
+    unsafe {
+        let mut last = None;
+        let mut i = 0usize;
+        loop {
+            let ch = *s.add(i);
+            if ch == c {
+                last = Some(i);
+            }
+            if ch == 0 {
+                return last;
+            }
+            i += 1;
+        }
+    }
+}
+
 /// Pre-lever strncpy copy+pad: byte-at-a-time copy to NUL then byte NUL-pad.
 #[inline(never)]
 unsafe fn old_byte_strncpy(dst: *mut u8, src: *const u8, n: usize) {
@@ -549,4 +589,60 @@ fn main() {
             gl / new,
         );
     }
+
+    println!("\nwcsrchr (absent target -> full wide scan to NUL):");
+    println!(
+        "{:>8} | {:>12} | {:>12} | {:>12}",
+        "wchars", "old(ns)", "abi(ns)", "old/abi"
+    );
+    for &n in &sizes {
+        let mut s: Vec<u32> = vec![0x61u32; n + 1];
+        s[n] = 0;
+        let p = s.as_ptr();
+        let iters = (4_000_000u64 / (n as u64 + 1)).max(2000);
+
+        let old = median_ns_per_op(rounds, iters, || {
+            black_box(unsafe { old_scalar_wcsrchr(p, 0x5A) });
+        });
+        let abi = median_ns_per_op(rounds, iters, || {
+            // SAFETY: NUL-terminated wide string.
+            black_box(unsafe { wcsrchr(p, 0x5A) });
+        });
+        println!(
+            "{:>8} | {:>12.1} | {:>12.1} | {:>11.2}x",
+            n,
+            old,
+            abi,
+            old / abi,
+        );
+    }
+
+    println!("\nwcscmp (equal wide strings → full scan, wchar_t = u32):");
+    println!(
+        "{:>8} | {:>12} | {:>12} | {:>12} | {:>10} | {:>10}",
+        "wchars", "old(ns)", "new(ns)", "glibc(ns)", "self x", "vs glibc"
+    );
+    for &n in &sizes {
+        let mut a: Vec<u32> = vec![0x61u32; n + 1];
+        a[n] = 0;
+        let b = a.clone();
+        let pa = a.as_ptr();
+        let pb = b.as_ptr();
+        let iters = (4_000_000u64 / (n as u64 + 1)).max(2000);
+
+        let old = median_ns_per_op(rounds, iters, || {
+            black_box(unsafe { old_scalar_wcscmp(pa, pb) });
+        });
+        let new = median_ns_per_op(rounds, iters, || {
+            black_box(unsafe { bench_scan_wcscmp_simd(pa, pb, usize::MAX) });
+        });
+        let gl = median_ns_per_op(rounds, iters, || {
+            // SAFETY: both NUL-terminated wide strings.
+            black_box(unsafe { wcscmp(pa, pb) });
+        });
+        println!(
+            "{:>8} | {:>12.1} | {:>12.1} | {:>12.1} | {:>9.2}x | {:>9.2}x",
+            n, old, new, gl, old / new, gl / new,
+        );
+    }
 }