WIP: Replace HashMap implementation with SwissTable

Author: Amanieu

src/libstd/collections/hash/map.rs

@@ -11,14 +11,6 @@
 //! Unordered containers, implemented as hash-tables
 
 mod bench;
-mod table;
+mod raw;
 pub mod map;
 pub mod set;
-
-trait Recover<Q: ?Sized> {
-    type Key;
-
-    fn get(&self, key: &Q) -> Option<&Self::Key>;
-    fn take(&mut self, key: &Q) -> Option<Self::Key>;
-    fn replace(&mut self, key: Self::Key) -> Option<Self::Key>;
-}

src/libstd/collections/hash/mod.rs

@@ -0,0 +1,93 @@
+use super::imp::{BitMaskWord, BITMASK_MASK, BITMASK_SHIFT};
+use core::intrinsics;
+
+/// A bit mask which contains the result of a `Match` operation on a `Group` and
+/// allows iterating through them.
+///
+/// The bit mask is arranged so that low-order bits represent lower memory
+/// addresses for group match results.
+#[derive(Copy, Clone)]
+pub struct BitMask(pub BitMaskWord);
+
+impl BitMask {
+    /// Returns a new `BitMask` with all bits inverted.
+    #[inline]
+    #[must_use]
+    pub fn invert(self) -> BitMask {
+        BitMask(self.0 ^ BITMASK_MASK)
+    }
+
+    /// Returns a new `BitMask` with the lowest bit removed.
+    #[inline]
+    #[must_use]
+    pub fn remove_lowest_bit(self) -> BitMask {
+        BitMask(self.0 & (self.0 - 1))
+    }
+    /// Returns whether the `BitMask` has at least one set bits.
+    #[inline]
+    pub fn any_bit_set(self) -> bool {
+        self.0 != 0
+    }
+
+    /// Returns the first set bit in the `BitMask`, if there is one.
+    #[inline]
+    pub fn lowest_set_bit(self) -> Option<usize> {
+        if self.0 == 0 {
+            None
+        } else {
+            Some(self.trailing_zeros())
+        }
+    }
+
+    /// Returns the first set bit in the `BitMask`, if there is one. The
+    /// bitmask must not be empty.
+    #[inline]
+    pub unsafe fn lowest_set_bit_nonzero(self) -> usize {
+        intrinsics::cttz_nonzero(self.0) as usize >> BITMASK_SHIFT
+    }
+
+    /// Returns the number of trailing zeroes in the `BitMask`.
+    #[inline]
+    pub fn trailing_zeros(self) -> usize {
+        // ARM doesn't have a CTZ instruction, and instead uses RBIT + CLZ.
+        // However older ARM versions (pre-ARMv7) don't have RBIT and need to
+        // emulate it instead. Since we only have 1 bit set in each byte we can
+        // use REV + CLZ instead.
+        if cfg!(target_arch = "arm") && BITMASK_SHIFT >= 3 {
+            self.0.swap_bytes().leading_zeros() as usize >> BITMASK_SHIFT
+        } else {
+            self.0.trailing_zeros() as usize >> BITMASK_SHIFT
+        }
+    }
+
+    /// Returns the number of leading zeroes in the `BitMask`.
+    #[inline]
+    pub fn leading_zeros(self) -> usize {
+        self.0.leading_zeros() as usize >> BITMASK_SHIFT
+    }
+}
+
+impl IntoIterator for BitMask {
+    type Item = usize;
+    type IntoIter = BitMaskIter;
+
+    #[inline]
+    fn into_iter(self) -> BitMaskIter {
+        BitMaskIter(self)
+    }
+}
+
+/// Iterator over the contents of a `BitMask`, returning the indicies of set
+/// bits.
+pub struct BitMaskIter(BitMask);
+
+impl Iterator for BitMaskIter {
+    type Item = usize;
+
+    #[inline]
+    fn next(&mut self) -> Option<usize> {
+        let bit = self.0.lowest_set_bit()?;
+        self.0 = self.0.remove_lowest_bit();
+        Some(bit)
+    }
+}

src/libstd/collections/hash/raw/bitmask.rs

@@ -0,0 +1,127 @@
+use super::bitmask::BitMask;
+use super::EMPTY;
+use core::{mem, ptr};
+
+// Use the native word size as the group size. Using a 64-bit group size on
+// a 32-bit architecture will just end up being more expensive because
+// shifts and multiplies will need to be emulated.
+#[cfg(any(
+    target_pointer_width = "64",
+    target_arch = "aarch64",
+    target_arch = "x86_64",
+))]
+type GroupWord = u64;
+#[cfg(all(
+    target_pointer_width = "32",
+    not(target_arch = "aarch64"),
+    not(target_arch = "x86_64"),
+))]
+type GroupWord = u32;
+
+pub type BitMaskWord = GroupWord;
+pub const BITMASK_SHIFT: u32 = 3;
+pub const BITMASK_MASK: GroupWord = 0x8080808080808080u64 as GroupWord;
+
+/// Helper function to replicate a byte across a `GroupWord`.
+#[inline]
+fn repeat(byte: u8) -> GroupWord {
+    let repeat = byte as GroupWord;
+    let repeat = repeat | repeat.wrapping_shl(8);
+    let repeat = repeat | repeat.wrapping_shl(16);
+    // This last line is a no-op with a 32-bit GroupWord
+    repeat | repeat.wrapping_shl(32)
+}
+
+/// Abstraction over a group of control bytes which can be scanned in
+/// parallel.
+///
+/// This implementation uses a word-sized integer.
+pub struct Group(GroupWord);
+
+// We perform all operations in the native endianess, and convert to
+// little-endian just before creating a BitMask. The can potentially
+// enable the compiler to eliminate unnecessary byte swaps if we are
+// only checking whether a BitMask is empty.
+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] {
+        #[repr(C)]
+        struct Dummy {
+            _align: [GroupWord; 0],
+            bytes: [u8; Group::WIDTH],
+        };
+        const DUMMY: Dummy = Dummy {
+            _align: [],
+            bytes: [EMPTY; Group::WIDTH],
+        };
+        &DUMMY.bytes
+    }
+
+    /// Loads a group of bytes starting at the given address.
+    #[inline]
+    pub unsafe fn load(ptr: *const u8) -> Group {
+        Group(ptr::read_unaligned(ptr as *const _))
+    }
+
+    /// Loads a group of bytes starting at the given address, which must be
+    /// aligned to `WIDTH`.
+    #[inline]
+    pub unsafe fn load_aligned(ptr: *const u8) -> Group {
+        Group(ptr::read(ptr as *const _))
+    }
+
+    /// Stores the group of bytes to the given address, which must be
+    /// aligned to `WIDTH`.
+    #[inline]
+    pub unsafe fn store_aligned(&self, ptr: *mut u8) {
+        ptr::write(ptr as *mut _, self.0);
+    }
+
+    /// Returns a `BitMask` indicating all bytes in the group which *may*
+    /// have the given value.
+    ///
+    /// This function may return a false positive in certain cases where
+    /// the byte in the group differs from the searched value only in its
+    /// lowest bit. This is fine because:
+    /// - This never happens for `EMPTY` and `DELETED`, only full entries.
+    /// - The check for key equality will catch these.
+    /// - This only happens if there is at least 1 true match.
+    /// - The chance of this happening is very low (< 1% chance per byte).
+    #[inline]
+    pub fn match_byte(&self, byte: u8) -> BitMask {
+        // This algorithm is derived from
+        // http://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
+        let cmp = self.0 ^ repeat(byte);
+        BitMask((cmp.wrapping_sub(repeat(0x01)) & !cmp & repeat(0x80)).to_le())
+    }
+
+    /// Returns a `BitMask` indicating all bytes in the group which are
+    /// `EMPTY`.
+    #[inline]
+    pub fn match_empty(&self) -> BitMask {
+        BitMask((self.0 & (self.0 << 1) & repeat(0x80)).to_le())
+    }
+
+    /// Returns a `BitMask` indicating all bytes in the group which are
+    /// `EMPTY` pr `DELETED`.
+    #[inline]
+    pub fn match_empty_or_deleted(&self) -> BitMask {
+        BitMask((self.0 & repeat(0x80)).to_le())
+    }
+
+    /// Performs the following transformation on all bytes in the group:
+    /// - `EMPTY => EMPTY`
+    /// - `DELETED => EMPTY`
+    /// - `FULL => DELETED`
+    #[inline]
+    pub fn convert_special_to_empty_and_full_to_deleted(&self) -> Group {
+        Group(((self.0 & repeat(0x80)) >> 7) * 0xff)
+    }
+}