nightly simd support

Author: anonrig

Cargo.toml

@@ -28,8 +28,8 @@ default = ["std"]
 serde = ["dep:serde", "std"]
 # enable allocations
 std = []
-# enable SIMD/SWAR optimizations for hot scanning paths
-simd = []
+# nightly-only: portable_simd (std::simd) — generates optimal SIMD for any target
+nightly-simd = []
 
 [dependencies]
 serde = { version = "1", optional = true, features = ["derive"] }

examples/bench_debug.rs

@@ -14,12 +14,12 @@ fmt *args:
 
 # run tests on all feature combinations
 test *args:
-  cargo hack test --feature-powerset {{args}}
+  cargo hack test --feature-powerset --exclude-features nightly-simd,simd {{args}}
 
 # type check and lint code on all feature combinations
 clippy *args:
-  cargo hack clippy --feature-powerset {{args}} -- -D warnings
+  cargo hack clippy --feature-powerset --exclude-features nightly-simd,simd {{args}} -- -D warnings
 
 # lint documentation on all feature combinations
 doc *args:
-  RUSTDOCFLAGS='-D warnings' cargo hack doc --feature-powerset {{args}}
+  RUSTDOCFLAGS='-D warnings' cargo hack doc --feature-powerset --exclude-features nightly-simd,simd {{args}}

examples/check_idna.rs

@@ -44,7 +44,7 @@ pub const HEX: &[u8; 1023] = b"%00\0%01\0%02\0%03\0%04\0%05\0%06\0%07\0\
 // Character set: C0 control percent-encode
 // Encodes: U+0000–U+001F, U+007F, and U+0080–U+FFFF
 // ---------------------------------------------------------------------------
-pub const C0_CONTROL_PERCENT_ENCODE: [u8; 32] = [
+pub static C0_CONTROL_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x00, 0x00, 0x00, 0x00, // 0x20–0x3F
     0x00, 0x00, 0x00, 0x00, // 0x40–0x5F
@@ -60,7 +60,7 @@ pub const C0_CONTROL_PERCENT_ENCODE: [u8; 32] = [
 // Encodes C0-control, space (0x20), " (0x22), < (0x3C), > (0x3E),
 //   ` (0x60), and everything >= 0x7F
 // ---------------------------------------------------------------------------
-pub const FRAGMENT_PERCENT_ENCODE: [u8; 32] = [
+pub static FRAGMENT_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x05, 0x00, 0x00, 0x50, // 0x20–0x3F: 0x05=space+", 0x50=<+>
     0x00, 0x00, 0x00, 0x00, // 0x40–0x5F
@@ -76,7 +76,7 @@ pub const FRAGMENT_PERCENT_ENCODE: [u8; 32] = [
 // Encodes C0-control, space, ", #, <, >, and everything >= 0x7F
 // NOTE: backtick (0x60) is NOT encoded here (only in fragment and path sets).
 // ---------------------------------------------------------------------------
-pub const QUERY_PERCENT_ENCODE: [u8; 32] = [
+pub static QUERY_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x0D, 0x00, 0x00, 0x50, // 0x20–0x3F: 0x0D=space+"+#, 0x50=<+>
     0x00, 0x00, 0x00, 0x00, // 0x40–0x5F
@@ -91,7 +91,7 @@ pub const QUERY_PERCENT_ENCODE: [u8; 32] = [
 // Character set: special-query percent-encode
 // Same as query but also encodes ' (0x27)
 // ---------------------------------------------------------------------------
-pub const SPECIAL_QUERY_PERCENT_ENCODE: [u8; 32] = [
+pub static SPECIAL_QUERY_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x8D, 0x00, 0x00, 0x50, // 0x20–0x3F: 0x8D=space+"+#+', 0x50=<+>
     0x00, 0x00, 0x00, 0x00, // 0x40–0x5F
@@ -106,7 +106,7 @@ pub const SPECIAL_QUERY_PERCENT_ENCODE: [u8; 32] = [
 // Character set: path percent-encode
 // Encodes C0-control, space, ", #, <, >, ?, ^, `, {, |, }, DEL, >= 0x80
 // ---------------------------------------------------------------------------
-pub const PATH_PERCENT_ENCODE: [u8; 32] = [
+pub static PATH_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x0D, 0x00, 0x00, 0xD0, // 0x20–0x3F: space+"+# and <+>+?
     0x00, 0x00, 0x00, 0x40, // 0x40–0x5F: ^ (0x5E)
@@ -122,7 +122,7 @@ pub const PATH_PERCENT_ENCODE: [u8; 32] = [
 // Encodes C0-control, space, ", #, /, :, ;, <, =, >, ?, @, [, \, ], ^,
 //   `, {, |, }, DEL, and >= 0x80
 // ---------------------------------------------------------------------------
-pub const USERINFO_PERCENT_ENCODE: [u8; 32] = [
+pub static USERINFO_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0x0D, 0x80, 0x00, 0xFC, // 0x20–0x3F: space+"+#+ /  and :;<=>?
     0x01, 0x00, 0x00, 0x78, // 0x40–0x5F: @  and [,\,],^
@@ -137,7 +137,7 @@ pub const USERINFO_PERCENT_ENCODE: [u8; 32] = [
 // Character set: application/x-www-form-urlencoded percent-encode
 // Like userinfo but space is NOT encoded (it becomes '+' separately)
 // ---------------------------------------------------------------------------
-pub const WWW_FORM_URLENCODED_PERCENT_ENCODE: [u8; 32] = [
+pub static WWW_FORM_URLENCODED_PERCENT_ENCODE: [u8; 32] = [
     0xFF, 0xFF, 0xFF, 0xFF, // 0x00–0x1F
     0xFE, 0x9B, 0x00, 0xFC, // 0x20–0x3F: (not space) !"#$%&'  ()+,/  :;<=>?
     0x01, 0x00, 0x00, 0x78, // 0x40–0x5F: @  and [,\,],^

justfile

@@ -115,7 +115,7 @@ pub fn is_ipv4(input: &str) -> bool {
 ///   bit 1 (0x02) – backslash `\`
 ///   bit 2 (0x04) – dot `.`
 ///   bit 3 (0x08) – percent `%`
-const PATH_SIG_TABLE: [u8; 256] = {
+pub(crate) const PATH_SIG_TABLE: [u8; 256] = {
     let mut t = [0u8; 256];
     // Needs encoding: C0 controls (0x00-0x1F), DEL (0x7F), high bytes (0x80-0xFF)
     let mut i = 0usize;
@@ -147,26 +147,33 @@ const PATH_SIG_TABLE: [u8; 256] = {
 ///
 /// Ada C++ uses `for (; i + 7 < size; i += 8)` — we match that exactly.
 pub fn path_signature(input: &str) -> u8 {
-    let b = input.as_bytes();
-    let mut acc = 0u8;
-    let mut i = 0;
-    // 8-at-a-time — Ada C++ uses this exact unroll factor
-    while i + 8 <= b.len() {
-        acc |= PATH_SIG_TABLE[b[i] as usize]
-            | PATH_SIG_TABLE[b[i + 1] as usize]
-            | PATH_SIG_TABLE[b[i + 2] as usize]
-            | PATH_SIG_TABLE[b[i + 3] as usize]
-            | PATH_SIG_TABLE[b[i + 4] as usize]
-            | PATH_SIG_TABLE[b[i + 5] as usize]
-            | PATH_SIG_TABLE[b[i + 6] as usize]
-            | PATH_SIG_TABLE[b[i + 7] as usize];
-        i += 8;
-    }
-    while i < b.len() {
-        acc |= PATH_SIG_TABLE[b[i] as usize];
-        i += 1;
+    #[cfg(feature = "nightly-simd")]
+    {
+        return crate::portable_simd_impl::path_signature(input);
+    }
+    #[cfg(not(feature = "nightly-simd"))]
+    {
+        let b = input.as_bytes();
+        let mut acc = 0u8;
+        let mut i = 0;
+        // 8-at-a-time — Ada C++ uses this exact unroll factor
+        while i + 8 <= b.len() {
+            acc |= PATH_SIG_TABLE[b[i] as usize]
+                | PATH_SIG_TABLE[b[i + 1] as usize]
+                | PATH_SIG_TABLE[b[i + 2] as usize]
+                | PATH_SIG_TABLE[b[i + 3] as usize]
+                | PATH_SIG_TABLE[b[i + 4] as usize]
+                | PATH_SIG_TABLE[b[i + 5] as usize]
+                | PATH_SIG_TABLE[b[i + 6] as usize]
+                | PATH_SIG_TABLE[b[i + 7] as usize];
+            i += 8;
+        }
+        while i < b.len() {
+            acc |= PATH_SIG_TABLE[b[i] as usize];
+            i += 1;
+        }
+        acc
     }
-    acc
 }
 
 /// Check that the domain name length and label lengths are within DNS limits.

src/character_sets.rs

@@ -34,11 +34,52 @@ use crate::unicode::{
 /// U+200D ZERO WIDTH JOINER, whose low byte is 0x0D) are never removed.
 #[inline]
 pub fn strip_tabs_newlines(s: &str) -> Cow<'_, str> {
-    // Fast presence check — SIMD-accelerated when the `simd` feature is on.
-    #[cfg(feature = "simd")]
-    let has_special = crate::simd::has_tabs_or_newline(s.as_bytes());
-    #[cfg(not(feature = "simd"))]
-    let has_special = s.bytes().any(|b| matches!(b, b'\t' | b'\n' | b'\r'));
+    // Fast presence check.
+    // nightly-simd: portable SIMD (16 bytes/iter via std::simd)
+    // otherwise: SWAR — 8 bytes/iter using u64 broadcast/xor, zero overhead
+    #[cfg(feature = "nightly-simd")]
+    let has_special = crate::portable_simd_impl::has_tabs_or_newline(s.as_bytes());
+    #[cfg(not(feature = "nightly-simd"))]
+    let has_special = {
+        // SWAR: process 8 bytes at a time
+        #[inline(always)]
+        const fn bcast(v: u8) -> u64 {
+            (v as u64).wrapping_mul(0x0101_0101_0101_0101)
+        }
+        #[inline(always)]
+        const fn has_zero(w: u64) -> u64 {
+            w.wrapping_sub(0x0101_0101_0101_0101) & !w & 0x8080_8080_8080_8080
+        }
+        let b = s.as_bytes();
+        let (cr, lf, ht) = (bcast(b'\r'), bcast(b'\n'), bcast(b'\t'));
+        let n = b.len();
+        let mut running: u64 = 0;
+        let mut i = 0;
+        while i + 8 <= n {
+            let mut w: u64 = 0;
+            unsafe {
+                core::ptr::copy_nonoverlapping(b.as_ptr().add(i), &mut w as *mut u64 as *mut u8, 8)
+            };
+            running |= has_zero(w ^ cr) | has_zero(w ^ lf) | has_zero(w ^ ht);
+            i += 8;
+        }
+        if running != 0 {
+            true
+        } else {
+            if i < n {
+                let mut w: u64 = 0;
+                unsafe {
+                    core::ptr::copy_nonoverlapping(
+                        b.as_ptr().add(i),
+                        &mut w as *mut u64 as *mut u8,
+                        n - i,
+                    )
+                };
+                running |= has_zero(w ^ cr) | has_zero(w ^ lf) | has_zero(w ^ ht);
+            }
+            running != 0
+        }
+    };
     if !has_special {
         return Cow::Borrowed(s); // zero allocation — common path
     }
@@ -111,8 +152,8 @@ pub fn shorten_path(path: &mut String, scheme_type: SchemeType) -> bool {
 /// Next authority delimiter for special URLs: `@`, `/`, `\`, `?`
 #[inline]
 pub fn find_authority_delimiter_special(view: &str) -> usize {
-    #[cfg(feature = "simd")]
-    return crate::simd::find_authority_delimiter_special(view);
+    #[cfg(feature = "nightly-simd")]
+    return crate::portable_simd_impl::find_authority_delimiter_special(view);
     #[allow(unreachable_code)]
     view.bytes()
         .position(|b| matches!(b, b'@' | b'/' | b'\\' | b'?'))
@@ -122,8 +163,8 @@ pub fn find_authority_delimiter_special(view: &str) -> usize {
 /// Next authority delimiter for non-special URLs: `@`, `/`, `?`
 #[inline]
 pub fn find_authority_delimiter(view: &str) -> usize {
-    #[cfg(feature = "simd")]
-    return crate::simd::find_authority_delimiter(view);
+    #[cfg(feature = "nightly-simd")]
+    return crate::portable_simd_impl::find_authority_delimiter(view);
     #[allow(unreachable_code)]
     view.bytes()
         .position(|b| matches!(b, b'@' | b'/' | b'?'))
@@ -136,8 +177,8 @@ pub fn find_authority_delimiter(view: &str) -> usize {
 
 #[inline]
 fn find_next_host_delimiter_special(view: &str, from: usize) -> usize {
-    #[cfg(feature = "simd")]
-    return crate::simd::find_next_host_delimiter_special(view, from);
+    #[cfg(feature = "nightly-simd")]
+    return crate::portable_simd_impl::find_next_host_delimiter_special(view, from);
     #[allow(unreachable_code)]
     view.as_bytes()[from..]
         .iter()
@@ -148,8 +189,8 @@ fn find_next_host_delimiter_special(view: &str, from: usize) -> usize {
 
 #[inline]
 fn find_next_host_delimiter(view: &str, from: usize) -> usize {
-    #[cfg(feature = "simd")]
-    return crate::simd::find_next_host_delimiter(view, from);
+    #[cfg(feature = "nightly-simd")]
+    return crate::portable_simd_impl::find_next_host_delimiter(view, from);
     #[allow(unreachable_code)]
     view.as_bytes()[from..]
         .iter()

src/checkers.rs

@@ -1,3 +1,5 @@
+// Enable std::simd when the nightly-simd feature is active.
+#![cfg_attr(feature = "nightly-simd", feature(portable_simd))]
 //! # Ada URL
 //!
 //! Fast, WHATWG-compliant URL parser written in pure Rust.
@@ -36,10 +38,10 @@ pub(crate) mod idna_impl;
 pub(crate) mod idna_norm_tables;
 pub(crate) mod idna_tables;
 pub(crate) mod parser;
+#[cfg(feature = "nightly-simd")]
+pub(crate) mod portable_simd_impl;
 pub(crate) mod scheme;
 pub(crate) mod serializers;
-#[cfg(feature = "simd")]
-pub(crate) mod simd;
 pub(crate) mod unicode;
 pub(crate) mod url_search_params;
 pub(crate) mod validator;
@@ -1123,7 +1125,7 @@ impl Url {
     /// `input` sets the query to the empty string (not null) — `href` will end
     /// with `?`.  CoW: borrows `input` directly when no encoding is needed.
     pub(crate) fn update_base_search_with_encode(&mut self, input: &str, set: &[u8; 32]) {
-        // CoW: only allocates when encoding is actually required
+        // CoW: borrows when no encoding needed, owns otherwise.
         let enc: Cow<'_, str> = percent_encode(input, set);
         self.write_search_content(&enc);
     }

src/helpers.rs

@@ -1,5 +1,5 @@
 //! WHATWG URL parser state machine.
-//! https://url.spec.whatwg.org/#concept-url-parser
+//! <https://url.spec.whatwg.org/#concept-url-parser>
 
 #[cfg(not(feature = "std"))]
 extern crate alloc;
@@ -888,7 +888,7 @@ pub(crate) fn try_parse_absolute_fast(raw_input: &str) -> Option<Url> {
 /// Returns `Some(())` = definitely valid, `None` = fall back to full validator.
 #[inline]
 pub(crate) fn try_validate_absolute_fast(raw_input: &str) -> Option<()> {
-    use crate::unicode::{contains_xn_prefix_pub, DOMAIN_CHECK};
+    use crate::unicode::{DOMAIN_CHECK, contains_xn_prefix_pub};
 
     let raw = raw_input.as_bytes();