Merge branch 'master' of https://github.com/rust-lang/hashbrown into or-default-entry

Author: braddunbar

.github/workflows/release-plz.yml

@@ -0,0 +1,56 @@
+name: Release-plz
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'rust-lang' }}
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/[email protected]
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'rust-lang' }}
+    permissions:
+      contents: write
+      pull-requests: write
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Run release-plz
+        uses: release-plz/[email protected]
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

CHANGELOG.md

@@ -1,12 +1,33 @@
-# Change Log
+# Changelog
 
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/)
-and this project adheres to [Semantic Versioning](https://semver.org/).
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.15.4](https://github.com/rust-lang/hashbrown/compare/v0.15.3...v0.15.4) - 2025-06-05
+
+### Changed
+
+- Removed optional dependency on compiler-builtins. This only affects building as part of `std`.
+
+## [0.15.3](https://github.com/rust-lang/hashbrown/compare/v0.15.2...v0.15.3) - 2025-04-29
+
+### Added
+
+- SIMD implementation for LoongArch (#592, requires nightly)
+
+### Changed
+
+- Optimized insertion path by avoiding an unnecessary `match_empty` (#607)
+- Increased minimum table size for small types (#615)
+- Dropped FnMut trait bounds from `ExtractIf` data structures (#616)
+- Relaxed constraint in `hash_map::EntryRef` insertion methods `K: From<&Q>` to &Q: `Into<K>` (#611)
+- Added allocator template argument for `rustc_iter` (#605)
+- The `allocator-api2/nightly` feature is no longer enabled by `hashbrown/nightly` (#606)
+
 ## [v0.15.2] - 2024-11-14
 
 ### Added

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hashbrown"
-version = "0.15.2"
+version = "0.15.4"
 authors = ["Amanieu d'Antras <[email protected]>"]
 description = "A Rust port of Google's SwissTable hash map"
 license = "MIT OR Apache-2.0"
@@ -22,7 +22,6 @@ serde = { version = "1.0.25", default-features = false, optional = true }
 
 # When built as part of libstd
 core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
-compiler_builtins = { version = "0.1.2", optional = true }
 alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
 
 # Support for allocators that use allocator-api2
@@ -35,7 +34,7 @@ equivalent = { version = "1.0", optional = true, default-features = false }
 
 [dev-dependencies]
 lazy_static = "1.4"
-rand = { version = "0.8.3", features = ["small_rng"] }
+rand = { version = "0.9.0", features = ["small_rng"] }
 rayon = "1.2"
 fnv = "1.0.7"
 serde_test = "1.0"
@@ -47,7 +46,7 @@ default = ["default-hasher", "inline-more", "allocator-api2", "equivalent", "raw
 
 # Enables use of nightly features. This is only guaranteed to work on the latest
 # version of nightly Rust.
-nightly = ["allocator-api2?/nightly", "bumpalo/allocator_api"]
+nightly = ["bumpalo/allocator_api"]
 
 # Enables the RustcEntry API used to provide the standard library's Entry API.
 rustc-internal-api = []
@@ -56,10 +55,8 @@ rustc-internal-api = []
 rustc-dep-of-std = [
     "nightly",
     "core",
-    "compiler_builtins",
     "alloc",
     "rustc-internal-api",
-    "raw-entry",
 ]
 
 # Enables the deprecated RawEntry API.

README.md

@@ -4,7 +4,7 @@ hashbrown
 [![Build Status](https://github.com/rust-lang/hashbrown/actions/workflows/rust.yml/badge.svg)](https://github.com/rust-lang/hashbrown/actions)
 [![Crates.io](https://img.shields.io/crates/v/hashbrown.svg)](https://crates.io/crates/hashbrown)
 [![Documentation](https://docs.rs/hashbrown/badge.svg)](https://docs.rs/hashbrown)
-[![Rust](https://img.shields.io/badge/rust-1.63.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/hashbrown)
+[![Rust](https://img.shields.io/badge/rust-1.65.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/hashbrown)
 
 This crate is a Rust port of Google's high-performance [SwissTable] hash
 map, adapted to make it a drop-in replacement for Rust's standard `HashMap`

benches/bench.rs

@@ -45,9 +45,7 @@ impl Iterator for RandomKeys {
 
 // Just an arbitrary side effect to make the maps not shortcircuit to the non-dropping path
 // when dropping maps/entries (most real world usages likely have drop in the key or value)
-lazy_static::lazy_static! {
-    static ref SIDE_EFFECT: AtomicUsize = AtomicUsize::new(0);
-}
+static SIDE_EFFECT: AtomicUsize = AtomicUsize::new(0);
 
 #[derive(Clone)]
 struct DropType(usize);

src/control/group/lsx.rs

@@ -0,0 +1,137 @@
+use super::super::{BitMask, Tag};
+use core::mem;
+use core::num::NonZeroU16;
+
+use core::arch::loongarch64::*;
+use mem::transmute;
+
+pub(crate) type BitMaskWord = u16;
+pub(crate) type NonZeroBitMaskWord = NonZeroU16;
+pub(crate) const BITMASK_STRIDE: usize = 1;
+pub(crate) const BITMASK_MASK: BitMaskWord = 0xffff;
+pub(crate) const BITMASK_ITER_MASK: BitMaskWord = !0;
+
+/// Abstraction over a group of control tags which can be scanned in
+/// parallel.
+///
+/// This implementation uses a 128-bit LSX value.
+#[derive(Copy, Clone)]
+pub(crate) struct Group(v16i8);
+
+// FIXME: https://github.com/rust-lang/rust-clippy/issues/3859
+#[allow(clippy::use_self)]
+impl Group {
+    /// Number of bytes in the group.
+    pub(crate) const WIDTH: usize = mem::size_of::<Self>();
+
+    /// Returns a full group of empty tags, suitable for use as the initial
+    /// value for an empty hash table.
+    ///
+    /// This is guaranteed to be aligned to the group size.
+    #[inline]
+    #[allow(clippy::items_after_statements)]
+    pub(crate) const fn static_empty() -> &'static [Tag; Group::WIDTH] {
+        #[repr(C)]
+        struct AlignedTags {
+            _align: [Group; 0],
+            tags: [Tag; Group::WIDTH],
+        }
+        const ALIGNED_TAGS: AlignedTags = AlignedTags {
+            _align: [],
+            tags: [Tag::EMPTY; Group::WIDTH],
+        };
+        &ALIGNED_TAGS.tags
+    }
+
+    /// Loads a group of tags starting at the given address.
+    #[inline]
+    #[allow(clippy::cast_ptr_alignment)] // unaligned load
+    pub(crate) unsafe fn load(ptr: *const Tag) -> Self {
+        Group(lsx_vld::<0>(ptr.cast()))
+    }
+
+    /// Loads a group of tags starting at the given address, which must be
+    /// aligned to `mem::align_of::<Group>()`.
+    #[inline]
+    #[allow(clippy::cast_ptr_alignment)]
+    pub(crate) unsafe fn load_aligned(ptr: *const Tag) -> Self {
+        debug_assert_eq!(ptr.align_offset(mem::align_of::<Self>()), 0);
+        Group(lsx_vld::<0>(ptr.cast()))
+    }
+
+    /// Stores the group of tags to the given address, which must be
+    /// aligned to `mem::align_of::<Group>()`.
+    #[inline]
+    #[allow(clippy::cast_ptr_alignment)]
+    pub(crate) unsafe fn store_aligned(self, ptr: *mut Tag) {
+        debug_assert_eq!(ptr.align_offset(mem::align_of::<Self>()), 0);
+        lsx_vst::<0>(self.0, ptr.cast());
+    }
+
+    /// Returns a `BitMask` indicating all tags in the group which have
+    /// the given value.
+    #[inline]
+    pub(crate) fn match_tag(self, tag: Tag) -> BitMask {
+        #[allow(clippy::missing_transmute_annotations)]
+        unsafe {
+            let cmp = lsx_vseq_b(self.0, lsx_vreplgr2vr_b(tag.0 as i32));
+            BitMask(lsx_vpickve2gr_hu::<0>(transmute(lsx_vmskltz_b(cmp))) as u16)
+        }
+    }
+
+    /// Returns a `BitMask` indicating all tags in the group which are
+    /// `EMPTY`.
+    #[inline]
+    pub(crate) fn match_empty(self) -> BitMask {
+        #[allow(clippy::missing_transmute_annotations)]
+        unsafe {
+            let cmp = lsx_vseqi_b::<{ Tag::EMPTY.0 as i8 as i32 }>(self.0);
+            BitMask(lsx_vpickve2gr_hu::<0>(transmute(lsx_vmskltz_b(cmp))) as u16)
+        }
+    }
+
+    /// Returns a `BitMask` indicating all tags in the group which are
+    /// `EMPTY` or `DELETED`.
+    #[inline]
+    pub(crate) fn match_empty_or_deleted(self) -> BitMask {
+        #[allow(clippy::missing_transmute_annotations)]
+        unsafe {
+            // A tag is EMPTY or DELETED iff the high bit is set
+            BitMask(lsx_vpickve2gr_hu::<0>(transmute(lsx_vmskltz_b(self.0))) as u16)
+        }
+    }
+
+    /// Returns a `BitMask` indicating all tags in the group which are full.
+    #[inline]
+    pub(crate) fn match_full(&self) -> BitMask {
+        #[allow(clippy::missing_transmute_annotations)]
+        unsafe {
+            // A tag is EMPTY or DELETED iff the high bit is set
+            BitMask(lsx_vpickve2gr_hu::<0>(transmute(lsx_vmskgez_b(self.0))) as u16)
+        }
+    }
+
+    /// Performs the following transformation on all tags in the group:
+    /// - `EMPTY => EMPTY`
+    /// - `DELETED => EMPTY`
+    /// - `FULL => DELETED`
+    #[inline]
+    pub(crate) fn convert_special_to_empty_and_full_to_deleted(self) -> Self {
+        // Map high_bit = 1 (EMPTY or DELETED) to 1111_1111
+        // and high_bit = 0 (FULL) to 1000_0000
+        //
+        // Here's this logic expanded to concrete values:
+        //   let special = 0 > tag = 1111_1111 (true) or 0000_0000 (false)
+        //   1111_1111 | 1000_0000 = 1111_1111
+        //   0000_0000 | 1000_0000 = 1000_0000
+        #[allow(clippy::missing_transmute_annotations)]
+        unsafe {
+            let zero = lsx_vreplgr2vr_b(0);
+            let special = lsx_vslt_b(self.0, zero);
+            Group(transmute(lsx_vor_v(
+                transmute(special),
+                transmute(lsx_vreplgr2vr_b(Tag::DELETED.0 as i32)),
+            )))
+        }
+    }
+}

src/control/group/mod.rs

@@ -24,6 +24,14 @@ cfg_if! {
     ))] {
         mod neon;
         use neon as imp;
+    } else if #[cfg(all(
+        feature = "nightly",
+        target_arch = "loongarch64",
+        target_feature = "lsx",
+        not(miri),
+    ))] {
+        mod lsx;
+        use lsx as imp;
     } else {
         mod generic;
         use generic as imp;

src/lib.rs

@@ -42,6 +42,10 @@
     feature = "nightly",
     allow(clippy::incompatible_msrv, internal_features)
 )]
+#![cfg_attr(
+    all(feature = "nightly", target_arch = "loongarch64"),
+    feature(stdarch_loongarch)
+)]
 
 /// Default hasher for [`HashMap`] and [`HashSet`].
 #[cfg(feature = "default-hasher")]