POC for outlined RawTable

Author: Gankra

src/raw/generic.rs

@@ -53,22 +53,6 @@ impl Group {
     /// Number of bytes in the group.
     pub const WIDTH: usize = mem::size_of::<Self>();
 
-    /// Returns a full group of empty bytes, suitable for use as the initial
-    /// value for an empty hash table.
-    ///
-    /// This is guaranteed to be aligned to the group size.
-    #[inline]
-    pub const fn static_empty() -> &'static [u8] {
-        union AlignedBytes {
-            _align: Group,
-            bytes: [u8; Group::WIDTH],
-        };
-        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
-            bytes: [EMPTY; Group::WIDTH],
-        };
-        unsafe { &ALIGNED_BYTES.bytes }
-    }
-
     /// Loads a group of bytes starting at the given address.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)] // unaligned load

src/raw/mod.rs

@@ -353,22 +353,23 @@ impl<T> Bucket<T> {
     }
 }
 
+/// A raw hash table with an unsafe API.
 pub struct RawTable<T> {
     header: NonNull<Header<T>>,
     marker: PhantomData<T>,
 }
 
-/// A raw hash table with an unsafe API.
+/// The header of a RawTable's allocation (or the EMPTY_SINGLETON)
 pub struct Header<T> {
     // Mask to get an index from a hash value. The value is one less than the
     // number of buckets in the table.
     bucket_mask: usize,
 
     // Pointer to the array of control bytes
-    ctrl: *mut u8,
+    ctrl: *const u8,
 
     // Pointer to the array of buckets
-    data: *mut T,
+    data: *const T,
 
     // Number of elements that can be inserted before we need to grow the table
     growth_left: usize,
@@ -377,14 +378,27 @@ pub struct Header<T> {
     items: usize,
 }
 
-static EMPTY_SINGLETON: Header<()> = Header {
-    data: 0xA000_0000 as *mut (),
-    ctrl: std::ptr::null_mut(),
-    bucket_mask: 0,
-    items: 0,
-    growth_left: 0,
+static EMPTY_SINGLETON: Header<()> = {
+    union AlignedBytes {
+        _align: Group,
+        bytes: [u8; Group::WIDTH],
+    };
+    static ALIGNED_BYTES: AlignedBytes = AlignedBytes {
+        bytes: [EMPTY; Group::WIDTH],
+    };
+    let ctrl = unsafe { &ALIGNED_BYTES.bytes as *const u8 };
+
+    Header {
+        data: core::ptr::null(),
+        ctrl,
+        bucket_mask: 0,
+        items: 0,
+        growth_left: 0,
+    }
 };
 
+unsafe impl<T: Sync> Sync for Header<T> { }
+
 impl<T> RawTable<T> {
     /// Creates a new empty hash table without allocating any memory.
     ///
@@ -411,8 +425,8 @@ impl<T> RawTable<T> {
             calculate_layout::<T>(buckets).ok_or_else(|| fallability.capacity_overflow())?;
 
         let header = NonNull::new(alloc(layout)).ok_or_else(|| fallability.alloc_err(layout))?;
-        let ctrl = NonNull::new_unchecked(header.as_ptr().add(ctrl_offset) as *mut u8);
-        let data = NonNull::new_unchecked(header.as_ptr().add(data_offset) as *mut T);
+        let ctrl = header.as_ptr().add(ctrl_offset) as *mut u8;
+        let data = header.as_ptr().add(data_offset) as *mut T;
 
         let header = header.cast();
         *header.as_ptr() = Header {
@@ -476,24 +490,26 @@ impl<T> RawTable<T> {
 
     #[inline]
     fn header(&self) -> &Header<T> {
-        &*self.header.as_ptr()
+        unsafe {
+            &*self.header.as_ptr()
+        }
     }
 
     #[inline]
-    unsafe fn header_mut(&self) -> &mut Header<T> {
+    unsafe fn header_mut(&mut self) -> &mut Header<T> {
         &mut *self.header.as_ptr()
     }
 
     /// Returns a pointer to the data array
     #[inline]
     fn data_ptr(&self) -> *mut T {
-        self.header().data.as_ptr()
+        self.header().data as *mut T
     }
 
     /// Returns a pointer to the ctrl array
     #[inline]
     fn ctrl_ptr(&self) -> *mut u8 {
-        self.header().ctrl.as_ptr()
+        self.header().ctrl as *mut u8
     }
 
     #[inline]

src/raw/sse2.rs

@@ -19,27 +19,11 @@ pub const BITMASK_MASK: BitMaskWord = 0xffff;
 pub struct Group(x86::__m128i);
 
 // FIXME: https://github.com/rust-lang/rust-clippy/issues/3859
-#[allow(clippy::use_self)] 
+#[allow(clippy::use_self)]
 impl Group {
     /// Number of bytes in the group.
     pub const WIDTH: usize = mem::size_of::<Self>();
 
-    /// Returns a full group of empty bytes, suitable for use as the initial
-    /// value for an empty hash table.
-    ///
-    /// This is guaranteed to be aligned to the group size.
-    #[inline]
-    pub fn static_empty() -> &'static [u8] {
-        union AlignedBytes {
-            _align: Group,
-            bytes: [u8; Group::WIDTH],
-        };
-        const ALIGNED_BYTES: AlignedBytes = AlignedBytes {
-            bytes: [EMPTY; Group::WIDTH],
-        };
-        unsafe { &ALIGNED_BYTES.bytes }
-    }
-
     /// Loads a group of bytes starting at the given address.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)] // unaligned load