Simplify

Author: Dandandan

src/control/group/generic.rs

@@ -119,17 +119,6 @@ impl Group {
         BitMask((self.0 & (self.0 << 1) & repeat(Tag::DELETED)).to_le())
     }
 
-    /// Loads the group and checks for empty tags. On the generic backend
-    /// this just delegates to `Group::load` + `match_empty`.
-    ///
-    /// # Safety
-    ///
-    /// `ptr` must be valid to read `Group::WIDTH` bytes from.
-    #[inline]
-    pub(crate) unsafe fn load_and_match_empty(ptr: *const Tag) -> BitMask {
-        unsafe { Group::load(ptr).match_empty() }
-    }
-
     /// Returns a `BitMask` indicating all tags in the group which are
     /// `EMPTY` or `DELETED`.
     #[inline]

src/control/group/lsx.rs

@@ -84,17 +84,6 @@ impl Group {
         }
     }
 
-    /// Loads the group and checks for empty tags. On LSX this just
-    /// delegates to `Group::load` + `match_empty`.
-    ///
-    /// # Safety
-    ///
-    /// `ptr` must be valid to read `Group::WIDTH` bytes from.
-    #[inline]
-    pub(crate) unsafe fn load_and_match_empty(ptr: *const Tag) -> BitMask {
-        unsafe { Group::load(ptr).match_empty() }
-    }
-
     /// Returns a `BitMask` indicating all tags in the group which are
     /// `EMPTY` or `DELETED`.
     #[inline]

src/control/group/neon.rs

@@ -74,26 +74,18 @@ impl Group {
 
     /// Returns a `BitMask` indicating all tags in the group which are
     /// `EMPTY`.
-    #[inline]
-    pub(crate) fn match_empty(self) -> BitMask {
-        self.match_tag(Tag::EMPTY)
-    }
-
-    /// Loads the group as a scalar `u64` and checks for empty tags using
-    /// SWAR bit operations. This is faster than the NEON `match_empty`
-    /// followed by `any_bit_set` because it avoids the slow `umaxv`
-    /// horizontal vector reduction that LLVM emits for that pattern.
     ///
-    /// EMPTY (0xFF) is the only tag with both top bits set, so
+    /// This uses SWAR bit operations on the scalar representation of the
+    /// group rather than NEON comparison. Converting the `uint8x8_t`
+    /// directly to a `u64` allows LLVM to eliminate the vector load
+    /// entirely. EMPTY (0xFF) is the only tag with both top bits set, so
     /// `(x & (x << 1) & 0x8080..80) != 0` detects empty bytes.
-    ///
-    /// # Safety
-    ///
-    /// `ptr` must be valid to read `Group::WIDTH` bytes from.
     #[inline]
-    pub(crate) unsafe fn load_and_match_empty(ptr: *const Tag) -> BitMask {
-        let ctrl = unsafe { ptr.cast::<u64>().read_unaligned() };
-        BitMask(ctrl & (ctrl << 1) & BITMASK_ITER_MASK)
+    pub(crate) fn match_empty(self) -> BitMask {
+        unsafe {
+            let ctrl = neon::vget_lane_u64(neon::vreinterpret_u64_u8(self.0), 0);
+            BitMask(ctrl & (ctrl << 1) & BITMASK_ITER_MASK)
+        }
     }
 
     /// Returns a `BitMask` indicating all tags in the group which are

src/control/group/sse2.rs

@@ -92,18 +92,6 @@ impl Group {
         self.match_tag(Tag::EMPTY)
     }
 
-    /// Loads the group and checks for empty tags. On SSE2 this just
-    /// delegates to `Group::load` + `match_empty` since the movemask
-    /// codegen is already optimal.
-    ///
-    /// # Safety
-    ///
-    /// `ptr` must be valid to read `Group::WIDTH` bytes from.
-    #[inline]
-    pub(crate) unsafe fn load_and_match_empty(ptr: *const Tag) -> BitMask {
-        unsafe { Group::load(ptr).match_empty() }
-    }
-
     /// Returns a `BitMask` indicating all tags in the group which are
     /// `EMPTY` or `DELETED`.
     #[inline]

src/raw.rs

@@ -1818,9 +1818,7 @@ impl RawTableInner {
             // * Also, even if `RawTableInner` is not already allocated, `ProbeSeq.pos` will
             //   always return "0" (zero), so Group::load will read unaligned `Group::static_empty()`
             //   bytes, which is safe (see RawTableInner::new).
-            let ctrl = unsafe { self.ctrl(probe_seq.pos) };
-            let group = unsafe { Group::load(ctrl) };
-            let empty = unsafe { Group::load_and_match_empty(ctrl) };
+            let group = unsafe { Group::load(self.ctrl(probe_seq.pos)) };
 
             for bit in group.match_tag(tag_hash) {
                 let index = (probe_seq.pos + bit) & self.bucket_mask;
@@ -1839,7 +1837,7 @@ impl RawTableInner {
             if let Some(insert_index) = insert_index {
                 // Only stop the search if the group contains at least one empty element.
                 // Otherwise, the element that we are looking for might be in a following group.
-                if likely(empty.any_bit_set()) {
+                if likely(group.match_empty().any_bit_set()) {
                     // We must have found a insert slot by now, since the current group contains at
                     // least one. For tables smaller than the group width, there will still be an
                     // empty element in the current (and only) group due to the load factor.
@@ -2026,13 +2024,7 @@ impl RawTableInner {
             // * Also, even if `RawTableInner` is not already allocated, `ProbeSeq.pos` will
             //   always return "0" (zero), so Group::load will read unaligned `Group::static_empty()`
             //   bytes, which is safe (see RawTableInner::new_in).
-            let ctrl = unsafe { self.ctrl(probe_seq.pos) };
-            let group = unsafe { Group::load(ctrl) };
-
-            // Compute the empty check early so it can execute in parallel
-            // with the tag comparison. On some backends this uses a
-            // separate code path optimized for the empty check.
-            let empty = unsafe { Group::load_and_match_empty(ctrl) };
+            let group = unsafe { Group::load(self.ctrl(probe_seq.pos)) };
 
             for bit in group.match_tag(tag_hash) {
                 // This is the same as `(probe_seq.pos + bit) % self.num_buckets()` because the number
@@ -2044,7 +2036,7 @@ impl RawTableInner {
                 }
             }
 
-            if likely(empty.any_bit_set()) {
+            if likely(group.match_empty().any_bit_set()) {
                 return None;
             }