Address some feedback from rust-lang PR

Author: Amanieu

src/raw/generic.rs

@@ -36,6 +36,7 @@ fn repeat(byte: u8) -> GroupWord {
 /// parallel.
 ///
 /// This implementation uses a word-sized integer.
+#[derive(Copy, Clone)]
 pub struct Group(GroupWord);
 
 // We perform all operations in the native endianess, and convert to
@@ -52,16 +53,14 @@ impl Group {
     /// This is guaranteed to be aligned to the group size.
     #[inline]
     pub fn static_empty() -> &'static [u8] {
-        #[repr(C)]
-        struct Dummy {
-            _align: [GroupWord; 0],
+        union AlignedBytes {
+            _align: Group,
             bytes: [u8; Group::WIDTH],
         };
-        const DUMMY: Dummy = Dummy {
-            _align: [],
+        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
             bytes: [EMPTY; Group::WIDTH],
         };
-        &DUMMY.bytes
+        unsafe { &ALIGNED_BYTES.bytes }
     }
 
     /// Loads a group of bytes starting at the given address.
@@ -71,16 +70,18 @@ impl Group {
     }
 
     /// Loads a group of bytes starting at the given address, which must be
-    /// aligned to `WIDTH`.
+    /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     pub unsafe fn load_aligned(ptr: *const u8) -> Group {
+        debug_assert_eq!(ptr as usize & (mem::align_of::<Group>() - 1), 0);
         Group(ptr::read(ptr as *const _))
     }
 
     /// Stores the group of bytes to the given address, which must be
-    /// aligned to `WIDTH`.
+    /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     pub unsafe fn store_aligned(&self, ptr: *mut u8) {
+        debug_assert_eq!(ptr as usize & (mem::align_of::<Group>() - 1), 0);
         ptr::write(ptr as *mut _, self.0);
     }
 

src/raw/mod.rs

@@ -36,7 +36,13 @@ unsafe fn offset_from<T>(to: *const T, from: *const T) -> usize {
 }
 
 // Use the SSE2 implementation if possible: it allows us to scan 16 buckets at
-// once instead of 8.
+// once instead of 8. We don't bother with AVX since it would require runtime
+// dispatch and wouldn't gain us much anyways: the probability of finding a
+// match drops off drastically after the first few buckets.
+//
+// I attempted an implementation on ARM using NEON instructions, but it turns
+// out that most NEON instructions have multi-cycle latency, which in the end
+// outweighs any gains over the generic implementation.
 #[cfg(all(
     target_feature = "sse2",
     any(target_arch = "x86", target_arch = "x86_64")

src/raw/sse2.rs

@@ -15,6 +15,7 @@ pub const BITMASK_MASK: u16 = 0xffff;
 /// parallel.
 ///
 /// This implementation uses a 128-bit SSE value.
+#[derive(Copy, Clone)]
 pub struct Group(x86::__m128i);
 
 impl Group {
@@ -27,16 +28,14 @@ impl Group {
     /// This is guaranteed to be aligned to the group size.
     #[inline]
     pub fn static_empty() -> &'static [u8] {
-        #[repr(C)]
-        struct Dummy {
-            _align: [x86::__m128i; 0],
+        union AlignedBytes {
+            _align: Group,
             bytes: [u8; Group::WIDTH],
         };
-        const DUMMY: Dummy = Dummy {
-            _align: [],
+        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
             bytes: [EMPTY; Group::WIDTH],
         };
-        &DUMMY.bytes
+        unsafe { &ALIGNED_BYTES.bytes }
     }
 
     /// Loads a group of bytes starting at the given address.
@@ -46,16 +45,18 @@ impl Group {
     }
 
     /// Loads a group of bytes starting at the given address, which must be
-    /// aligned to `WIDTH`.
+    /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     pub unsafe fn load_aligned(ptr: *const u8) -> Group {
+        debug_assert_eq!(ptr as usize & (mem::align_of::<Group>() - 1), 0);
         Group(x86::_mm_load_si128(ptr as *const _))
     }
 
     /// Stores the group of bytes to the given address, which must be
-    /// aligned to `WIDTH`.
+    /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     pub unsafe fn store_aligned(&self, ptr: *mut u8) {
+        debug_assert_eq!(ptr as usize & (mem::align_of::<Group>() - 1), 0);
         x86::_mm_store_si128(ptr as *mut _, self.0);
     }
 

tests/set.rs

@@ -2,7 +2,7 @@ extern crate hashbrown;
 extern crate rand;
 
 use hashbrown::HashSet;
-use rand::{Rng, SeedableRng, XorShiftRng, distributions::Alphanumeric};
+use rand::{distributions::Alphanumeric, Rng, SeedableRng, XorShiftRng};
 
 #[test]
 fn test_hashset_insert_remove() {