Use custom needle position in original AVX2 implementation for fair comparison

Author: zakcutner

src/avx2/rust.rs

@@ -302,6 +302,7 @@ pub fn strstr_avx2_rust_fast_2(haystack: &[u8], needle: &[u8]) -> bool {
 #[cfg(target_feature = "avx2")]
 pub struct StrStrAVX2Searcher {
     needle: Box<[u8]>,
+    position: usize,
     sse_first: __m128i,
     sse_last: __m128i,
     avx2_first: __m256i,
@@ -312,16 +313,21 @@ pub struct StrStrAVX2Searcher {
 #[cfg(target_feature = "avx2")]
 impl StrStrAVX2Searcher {
     pub fn new(needle: &[u8]) -> Self {
+        Self::with_position(needle, needle.len() - 1)
+    }
+
+    pub fn with_position(needle: &[u8], position: usize) -> Self {
         let mut needle_sum = 0_usize;
         for &c in needle {
             needle_sum += c as usize;
         }
         StrStrAVX2Searcher {
             needle: needle.to_vec().into_boxed_slice(),
+            position,
             sse_first: unsafe { _mm_set1_epi8(needle[0] as i8) },
-            sse_last: unsafe { _mm_set1_epi8(needle[needle.len() - 1] as i8) },
+            sse_last: unsafe { _mm_set1_epi8(needle[position] as i8) },
             avx2_first: unsafe { _mm256_set1_epi8(needle[0] as i8) },
-            avx2_last: unsafe { _mm256_set1_epi8(needle[needle.len() - 1] as i8) },
+            avx2_last: unsafe { _mm256_set1_epi8(needle[position] as i8) },
             needle_sum,
         }
     }
@@ -333,19 +339,18 @@ impl StrStrAVX2Searcher {
         match self.needle.len() {
             0 => true,
             1 => memchr::memchr(self.needle[0], haystack).is_some(),
-            2 => unsafe { self.avx2_memcmp(haystack, memcmp0) },
-            3 => unsafe { self.avx2_memcmp(haystack, memcmp1) },
-            4 => unsafe { self.avx2_memcmp(haystack, memcmp2) },
+            2 => unsafe { self.avx2_memcmp(haystack, memcmp1) },
+            3 => unsafe { self.avx2_memcmp(haystack, memcmp2) },
+            4 => unsafe { self.avx2_memcmp(haystack, memcmp3) },
             5 => unsafe { self.avx2_memcmp(haystack, memcmp4) },
-            6 => unsafe { self.avx2_memcmp(haystack, memcmp4) },
-            7 => unsafe { self.avx2_memcmp(haystack, memcmp5) },
-            8 => unsafe { self.avx2_memcmp(haystack, memcmp6) },
+            6 => unsafe { self.avx2_memcmp(haystack, memcmp5) },
+            7 => unsafe { self.avx2_memcmp(haystack, memcmp6) },
+            8 => unsafe { self.avx2_memcmp(haystack, memcmp7) },
             9 => unsafe { self.avx2_memcmp(haystack, memcmp8) },
-            10 => unsafe { self.avx2_memcmp(haystack, memcmp8) },
-            11 => unsafe { self.avx2_memcmp(haystack, memcmp9) },
-            12 => unsafe { self.avx2_memcmp(haystack, memcmp10) },
-            13 => unsafe { self.avx2_memcmp(haystack, memcmp11) },
-            14 => unsafe { self.avx2_memcmp(haystack, memcmp12) },
+            10 => unsafe { self.avx2_memcmp(haystack, memcmp9) },
+            11 => unsafe { self.avx2_memcmp(haystack, memcmp10) },
+            12 => unsafe { self.avx2_memcmp(haystack, memcmp11) },
+            13 => unsafe { self.avx2_memcmp(haystack, memcmp12) },
             _ => unsafe { self.avx2_memcmp(haystack, memcmp) },
         }
     }
@@ -359,22 +364,19 @@ impl StrStrAVX2Searcher {
         while let Some(chunk) = chunks.next() {
             let i = chunk.as_ptr() as usize - haystack.as_ptr() as usize;
             let block_first = _mm_loadu_si128(chunk.as_ptr() as *const __m128i);
-            let block_last =
-                _mm_loadu_si128(chunk.as_ptr().add(self.needle.len() - 1) as *const __m128i);
+            let block_last = _mm_loadu_si128(chunk.as_ptr().add(self.position) as *const __m128i);
 
             let eq_first = _mm_cmpeq_epi8(self.sse_first, block_first);
             let eq_last = _mm_cmpeq_epi8(self.sse_last, block_last);
 
-            let mut mask = std::mem::transmute::<i32, u32>(_mm_movemask_epi8(_mm_and_si128(
-                eq_first, eq_last,
-            )));
+            let mut mask = _mm_movemask_epi8(_mm_and_si128(eq_first, eq_last)) as u32;
             while mask != 0 {
                 let bitpos = mask.trailing_zeros() as usize;
                 let startpos = i + bitpos;
                 if startpos + self.needle.len() <= haystack.len()
                     && memcmp(
-                        &haystack[(startpos + 1)..(startpos + self.needle.len() - 1)],
-                        &self.needle[1..self.needle.len() - 1],
+                        &haystack[(startpos + 1)..(startpos + self.needle.len())],
+                        &self.needle[1..self.needle.len()],
                     )
                 {
                     return true;
@@ -403,7 +405,7 @@ impl StrStrAVX2Searcher {
             let i = chunk.as_ptr() as usize - haystack.as_ptr() as usize;
             let block_first = _mm256_loadu_si256(chunk.as_ptr() as *const __m256i);
             let block_last =
-                _mm256_loadu_si256(chunk.as_ptr().add(self.needle.len() - 1) as *const __m256i);
+                _mm256_loadu_si256(chunk.as_ptr().add(self.position) as *const __m256i);
 
             let eq_first = _mm256_cmpeq_epi8(self.avx2_first, block_first);
             let eq_last = _mm256_cmpeq_epi8(self.avx2_last, block_last);
@@ -416,8 +418,8 @@ impl StrStrAVX2Searcher {
                 let startpos = i + bitpos;
                 if startpos + self.needle.len() <= haystack.len()
                     && memcmp(
-                        &haystack[(startpos + 1)..(startpos + self.needle.len() - 1)],
-                        &self.needle[1..self.needle.len() - 1],
+                        &haystack[(startpos + 1)..(startpos + self.needle.len())],
+                        &self.needle[1..self.needle.len()],
                     )
                 {
                     return true;