Use SSE2 SIMD in IndexTable::find_entry

src/index.rs

@@ -11,6 +11,10 @@ use crate::{
 	table::{key::TableKey, SIZE_TIERS_BITS},
 	Key,
 };
+#[cfg(target_arch = "x86")]
+use std::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
 use std::convert::TryInto;
 
 // Index chunk consists of 8 64-bit entries.
@@ -231,7 +235,46 @@ impl IndexTable {
 		Ok(try_io!(Ok(&map[offset..offset + CHUNK_LEN])))
 	}
 
-	#[inline(never)]
+	#[cfg(target_feature = "sse2")]
+	fn find_entry(&self, key_prefix: u64, sub_index: usize, chunk: &[u8]) -> (Entry, usize) {
+		assert!(chunk.len() >= CHUNK_ENTRIES * 8); // Bound checking (not done by SIMD instructions)
+		debug_assert!(
+			Entry::address_bits(self.id.index_bits()) <= 32,
+			"To be sure we can use all high 32 bits as key prefix"
+		);
+		const _: () = assert!(
+			CHUNK_ENTRIES % 4 == 0,
+			"We assume here we got buffer with a number of elements that is a multiple of 4"
+		);
+
+		unsafe {
+			let target = _mm_set1_epi32(((key_prefix << self.id.index_bits()) >> 32) as i32);
+			let mut i = (sub_index >> 2) << 2; // We keep an alignment of 4
+			while i + 4 <= CHUNK_ENTRIES {
+				// We load the value 2 by 2 and move the high bits into the low part of the register
+				let first_two = _mm_shuffle_epi32::<0b10001101>(_mm_loadu_si128(
+					chunk[i * 8..].as_ptr() as *const __m128i,
+				));
+				let last_two = _mm_shuffle_epi32::<0b10001101>(_mm_loadu_si128(
+					chunk[(i + 2) * 8..].as_ptr() as *const __m128i,
+				));
+				// We set into current the input low parts
+				let current = _mm_unpacklo_epi64(first_two, last_two);
+				let cmp = _mm_movemask_epi8(_mm_cmpeq_epi32(current, target));
+				if cmp != 0 {
+					let position = i + (cmp.trailing_zeros() as usize) / 4;
+					if position >= sub_index {
+						// We need to check we are not reading again the same input
+						return (Self::read_entry(chunk, position), position)
+					}
+				}
+				i += 4;
+			}
+		}
+		(Entry::empty(), 0)
+	}
+
+	#[cfg(not(target_feature = "sse2"))]
 	fn find_entry(&self, key_prefix: u64, sub_index: usize, chunk: &[u8]) -> (Entry, usize) {
 		assert!(chunk.len() >= CHUNK_ENTRIES * 8);
 		let partial_key = Entry::extract_key(key_prefix, self.id.index_bits());