slice/ascii: Optimize eq_ignore_ascii_case with auto-vectorization

library/core/src/slice/ascii.rs

@@ -60,6 +60,25 @@ impl [u8] {
             return false;
         }
 
+        #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+        {
+            const CHUNK_SIZE: usize = 16;
+            // The following function has two invariants:
+            // 1. The slice lengths must be equal, which we checked above.
+            // 2. The slice lengths must greater than or equal to N, which this
+            //    if-statement is checking.
+            if self.len() >= CHUNK_SIZE {
+                return self.eq_ignore_ascii_case_chunks::<CHUNK_SIZE>(other);
+            }
+        }
+
+        self.eq_ignore_ascii_case_simple(other)
+    }
+
+    /// ASCII case-insensitive equality check without chunk-at-a-time
+    /// optimization.
+    #[inline]
+    const fn eq_ignore_ascii_case_simple(&self, other: &[u8]) -> bool {
         // FIXME(const-hack): This implementation can be reverted when
         // `core::iter::zip` is allowed in const. The original implementation:
         //  self.len() == other.len() && iter::zip(self, other).all(|(a, b)| a.eq_ignore_ascii_case(b))
@@ -78,6 +97,65 @@ impl [u8] {
         true
     }
 
+    /// Optimized version of `eq_ignore_ascii_case` to process chunks at a time.
+    ///
+    /// Platforms that have SIMD instructions may benefit from this
+    /// implementation over `eq_ignore_ascii_case_simple`.
+    ///
+    /// # Invariants
+    ///
+    /// The caller must guarantee that the slices are equal in length, and the
+    /// slice lengths are greater than or equal to `N` bytes.
+    #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+    #[inline]
+    const fn eq_ignore_ascii_case_chunks<const N: usize>(&self, other: &[u8]) -> bool {
+        // FIXME(const-hack): The while-loops that follow should be replaced by
+        // for-loops when available in const.
+
+        let (self_chunks, self_rem) = self.as_chunks::<N>();
+        let (other_chunks, _) = other.as_chunks::<N>();
+
+        // Branchless check to encourage auto-vectorization
+        #[inline(always)]
+        const fn eq_ignore_ascii_inner<const L: usize>(lhs: &[u8; L], rhs: &[u8; L]) -> bool {
+            let mut equal_ascii = true;
+            let mut j = 0;
+            while j < L {
+                equal_ascii &= lhs[j].eq_ignore_ascii_case(&rhs[j]);
+                j += 1;
+            }
+
+            equal_ascii
+        }
+
+        // Process the chunks, returning early if an inequality is found
+        let mut i = 0;
+        while i < self_chunks.len() && i < other_chunks.len() {
+            if !eq_ignore_ascii_inner(&self_chunks[i], &other_chunks[i]) {
+                return false;
+            }
+            i += 1;
+        }
+
+        // Check the length invariant which is necessary for the tail-handling
+        // logic to be correct. This should have been upheld by the caller,
+        // otherwise lengths less than N will compare as true without any
+        // checking.
+        debug_assert!(self.len() >= N);
+
+        // If there are remaining tails, load the last N bytes in the slices to
+        // avoid falling back to per-byte checking.
+        if !self_rem.is_empty() {
+            if let (Some(a_rem), Some(b_rem)) = (self.last_chunk::<N>(), other.last_chunk::<N>()) {
+                if !eq_ignore_ascii_inner(a_rem, b_rem) {
+                    return false;
+                }
+            }
+        }
+
+        true
+    }
+
     /// Converts this slice to its ASCII upper case equivalent in-place.
     ///
     /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',

library/coretests/benches/str.rs

@@ -5,6 +5,7 @@ use test::{Bencher, black_box};
 mod char_count;
 mod corpora;
 mod debug;
+mod eq_ignore_ascii_case;
 mod iter;
 
 #[bench]

library/coretests/benches/str/eq_ignore_ascii_case.rs

@@ -0,0 +1,45 @@
+use test::{Bencher, black_box};
+
+use super::corpora::*;
+
+#[bench]
+fn bench_str_under_8_bytes_eq(b: &mut Bencher) {
+    let s = black_box("foo");
+    let other = black_box("foo");
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}
+
+#[bench]
+fn bench_str_of_8_bytes_eq(b: &mut Bencher) {
+    let s = black_box(en::TINY);
+    let other = black_box(en::TINY);
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}
+
+#[bench]
+fn bench_str_17_bytes_eq(b: &mut Bencher) {
+    let s = black_box(&en::SMALL[..17]);
+    let other = black_box(&en::SMALL[..17]);
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}
+
+#[bench]
+fn bench_str_31_bytes_eq(b: &mut Bencher) {
+    let s = black_box(&en::SMALL[..31]);
+    let other = black_box(&en::SMALL[..31]);
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}
+
+#[bench]
+fn bench_medium_str_eq(b: &mut Bencher) {
+    let s = black_box(en::MEDIUM);
+    let other = black_box(en::MEDIUM);
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}
+
+#[bench]
+fn bench_large_str_eq(b: &mut Bencher) {
+    let s = black_box(en::LARGE);
+    let other = black_box(en::LARGE);
+    b.iter(|| assert!(s.eq_ignore_ascii_case(other)))
+}

tests/codegen-llvm/lib-optimizations/eq_ignore_ascii_case.rs

@@ -0,0 +1,16 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+#![crate_type = "lib"]
+
+// Ensure that the optimized variant of the function gets auto-vectorized and
+// that the inner helper function is inlined.
+// CHECK-LABEL: @eq_ignore_ascii_case_autovectorized
+#[no_mangle]
+pub fn eq_ignore_ascii_case_autovectorized(s: &str, other: &str) -> bool {
+    // CHECK: load <16 x i8>
+    // CHECK: load <16 x i8>
+    // CHECK: bitcast <16 x i1>
+    // CHECK-NOT: call {{.*}}eq_ignore_ascii_inner
+    // CHECK-NOT: panic
+    s.eq_ignore_ascii_case(other)
+}