fix(hash*, #194): reduce future sizes

CHANGELOG.md

@@ -3,6 +3,11 @@
 
 ## Version 3
 
+3.4.3
+
+* Maximum theoretically capacity is adjusted to `2^(usize::BITS - 2)`.
+* Minor `Future` size improvement.
+
 3.4.2
 
 * Minor optimization.

Cargo.toml

@@ -2,7 +2,7 @@
 name = "scc"
 description = "A collection of high-performance containers providing both asynchronous and synchronous interfaces"
 documentation = "https://docs.rs/scc"
-version = "3.4.2"
+version = "3.4.3"
 authors = ["wvwwvwwv <wvwwvwwv@me.com>"]
 edition = "2024"
 rust-version = "1.85.0"
@@ -26,7 +26,7 @@ serde = { version = "1.0", optional = true }
 loom = ["dep:loom", "saa/loom", "sdd/loom"]
 
 [dev-dependencies]
-criterion = { version = "0.7", features = ["async_futures"] }
+criterion = { version = "0.8", features = ["async_futures"] }
 fnv = "1.0"
 futures = "0.3"
 proptest = "1.9"

src/async_helper.rs

@@ -30,6 +30,12 @@ pub(crate) trait TryWait {
     fn try_wait(&mut self, lock: &Lock);
 }
 
+/// Returns a fake [`Guard`] reference for methods that require a [`Guard`] to check the lifetime.
+#[inline]
+pub(super) const fn fake_guard() -> &'static Guard {
+    unsafe { &*ptr::from_ref(&FAKE_GUARD_GLOBAL).cast::<Guard>() }
+}
+
 impl AsyncGuard {
     /// Returns `true` if the [`AsyncGuard`] contains a valid [`Guard`].
     #[inline]
@@ -56,18 +62,21 @@ impl AsyncGuard {
         }
     }
 
-    /// Loads the content of the [`AtomicShared`] without exposing the [`Guard`].
+    /// Loads the content of the [`AtomicShared`] without exposing the [`Guard`] or checking tag
+    /// bits.
     #[inline]
-    pub(crate) fn load<T>(&self, atomic_ptr: &AtomicShared<T>, mo: Ordering) -> Option<&T> {
-        atomic_ptr.load(mo, self.guard()).as_ref()
+    pub(crate) fn load_unchecked<T>(
+        &self,
+        atomic_ptr: &AtomicShared<T>,
+        mo: Ordering,
+    ) -> Option<&T> {
+        unsafe { atomic_ptr.load(mo, self.guard()).as_ref_unchecked() }
     }
 
     /// Checks if the reference is valid.
     #[inline]
     pub(crate) fn check_ref<T>(&self, atomic_ptr: &AtomicShared<T>, r: &T, mo: Ordering) -> bool {
-        atomic_ptr
-            .load(mo, self.guard())
-            .as_ref()
+        self.load_unchecked(atomic_ptr, mo)
             .is_some_and(|s| ptr::eq(s, r))
     }
 }
@@ -120,3 +129,5 @@ impl TryWait for () {
         let _: Result<_, _> = pinned_pager.poll_sync();
     }
 }
+
+static FAKE_GUARD_GLOBAL: usize = 0;

src/hash_cache.rs

@@ -5,17 +5,20 @@ use std::fmt::{self, Debug};
 use std::hash::{BuildHasher, Hash};
 use std::mem::replace;
 use std::ops::{Deref, DerefMut, RangeInclusive};
-use std::pin::pin;
+#[cfg(not(feature = "loom"))]
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::Relaxed;
 
+#[cfg(feature = "loom")]
+use loom::sync::atomic::AtomicUsize;
 use sdd::{AtomicShared, Guard, Shared, Tag};
 
 use super::Equivalent;
+use super::async_helper::fake_guard;
+use super::hash_table::MAXIMUM_CAPACITY_LIMIT;
 use super::hash_table::bucket::{CACHE, DoublyLinkedList, EntryPtr};
 use super::hash_table::bucket_array::BucketArray;
 use super::hash_table::{HashTable, LockedBucket};
-use crate::async_helper::AsyncGuard;
 
 /// Scalable concurrent 32-way associative cache backed by [`HashMap`](super::HashMap).
 ///
@@ -189,7 +192,7 @@ where
         let maximum_capacity = maximum_capacity
             .max(minimum_capacity.load(Relaxed))
             .max(BucketArray::<K, V, DoublyLinkedList, CACHE>::minimum_capacity())
-            .min(1_usize << (usize::BITS - 1))
+            .min(MAXIMUM_CAPACITY_LIMIT)
             .next_power_of_two();
         HashCache {
             bucket_array: array,
@@ -219,10 +222,9 @@ where
     #[inline]
     pub async fn entry_async(&self, key: K) -> Entry<'_, K, V, H> {
         let hash = self.hash(&key);
-        let async_guard = pin!(AsyncGuard::default());
-        let locked_bucket = self.writer_async(hash, &async_guard).await;
-        let prolonged_guard = self.prolonged_guard_ref(async_guard.guard());
-        let entry_ptr = locked_bucket.search(&key, hash, prolonged_guard);
+        let locked_bucket = self.writer_async(hash).await;
+        let fake_guard = fake_guard();
+        let entry_ptr = locked_bucket.search(&key, hash, fake_guard);
         if entry_ptr.is_valid() {
             Entry::Occupied(OccupiedEntry {
                 hashcache: self,
@@ -341,14 +343,13 @@ where
     #[inline]
     pub async fn put_async(&self, key: K, val: V) -> Result<EvictedEntry<K, V>, (K, V)> {
         let hash = self.hash(&key);
-        let async_guard = pin!(AsyncGuard::default());
-        let locked_bucket = self.writer_async(hash, &async_guard).await;
-        let guard = async_guard.guard();
-        if locked_bucket.search(&key, hash, guard).is_valid() {
+        let locked_bucket = self.writer_async(hash).await;
+        let fake_guard = fake_guard();
+        if locked_bucket.search(&key, hash, fake_guard).is_valid() {
             Err((key, val))
         } else {
             let evicted = locked_bucket.evict_lru_head(locked_bucket.data_block);
-            let entry_ptr = locked_bucket.insert(hash, (key, val), guard);
+            let entry_ptr = locked_bucket.insert(hash, (key, val), fake_guard);
             locked_bucket.update_lru_tail(&entry_ptr);
             Ok(evicted)
         }
@@ -441,10 +442,9 @@ where
     #[inline]
     pub async fn replace_async(&self, key: K) -> ReplaceResult<'_, K, V, H> {
         let hash = self.hash(&key);
-        let async_guard = pin!(AsyncGuard::default());
-        let locked_bucket = self.writer_async(hash, &async_guard).await;
-        let prolonged_guard = self.prolonged_guard_ref(async_guard.guard());
-        let mut entry_ptr = locked_bucket.search(&key, hash, prolonged_guard);
+        let locked_bucket = self.writer_async(hash).await;
+        let fake_guard = fake_guard();
+        let mut entry_ptr = locked_bucket.search(&key, hash, fake_guard);
         if entry_ptr.is_valid() {
             let prev_key = replace(
                 &mut entry_ptr
@@ -610,10 +610,9 @@ where
         Q: Equivalent<K> + Hash + ?Sized,
     {
         let hash = self.hash(key);
-        let async_guard = pin!(AsyncGuard::default());
-        let locked_bucket = self.optional_writer_async(hash, &async_guard).await?;
-        let prolonged_guard = self.prolonged_guard_ref(async_guard.guard());
-        let entry_ptr = locked_bucket.search(key, hash, prolonged_guard);
+        let locked_bucket = self.optional_writer_async(hash).await?;
+        let fake_guard = fake_guard();
+        let entry_ptr = locked_bucket.search(key, hash, fake_guard);
         if entry_ptr.is_valid() {
             locked_bucket.writer.update_lru_tail(&entry_ptr);
             return Some(OccupiedEntry {
@@ -686,8 +685,7 @@ where
         Q: Equivalent<K> + Hash + ?Sized,
     {
         let hash = self.hash(key);
-        let async_guard = pin!(AsyncGuard::default());
-        self.reader_async(key, hash, reader, &async_guard).await
+        self.reader_async(key, hash, reader).await
     }
 
     /// Reads a key-value pair.
@@ -731,7 +729,8 @@ where
     where
         Q: Equivalent<K> + Hash + ?Sized,
     {
-        self.read_async(key, |_, _| ()).await.is_some()
+        let hash = self.hash(key);
+        self.reader_async(key, hash, |_, _| ()).await.is_some()
     }
 
     /// Returns `true` if the [`HashCache`] contains a value for the specified key.
@@ -778,11 +777,11 @@ where
         Q: Equivalent<K> + Hash + ?Sized,
     {
         let hash = self.hash(key);
-        let async_guard = pin!(AsyncGuard::default());
-        let mut locked_bucket = self.optional_writer_async(hash, &async_guard).await?;
-        let mut entry_ptr = locked_bucket.search(key, hash, async_guard.guard());
+        let mut locked_bucket = self.optional_writer_async(hash).await?;
+        let fake_guard = fake_guard();
+        let mut entry_ptr = locked_bucket.search(key, hash, fake_guard);
         if entry_ptr.is_valid() && condition(&mut locked_bucket.entry_mut(&mut entry_ptr).1) {
-            Some(locked_bucket.remove(self, &mut entry_ptr, async_guard.guard()))
+            Some(locked_bucket.remove(self, &mut entry_ptr, &Guard::new()))
         } else {
             None
         }
@@ -845,12 +844,11 @@ where
     /// ```
     #[inline]
     pub async fn iter_async<F: FnMut(&K, &V) -> bool>(&self, mut f: F) -> bool {
-        let async_guard = pin!(AsyncGuard::default());
         let mut result = true;
-        self.for_each_reader_async(&async_guard, |reader, data_block| {
-            let guard = async_guard.guard();
-            let mut entry_ptr = EntryPtr::new(guard);
-            while entry_ptr.move_to_next(&reader, guard) {
+        self.for_each_reader_async(|reader, data_block| {
+            let fake_guard = fake_guard();
+            let mut entry_ptr = EntryPtr::new(fake_guard);
+            while entry_ptr.move_to_next(&reader, fake_guard) {
                 let (k, v) = entry_ptr.get(data_block);
                 if !f(k, v) {
                     result = false;
@@ -937,17 +935,16 @@ where
         &self,
         mut f: F,
     ) -> bool {
-        let async_guard = pin!(AsyncGuard::default());
         let mut result = true;
-        self.for_each_writer_async(0, 0, &async_guard, |mut locked_bucket, removed| {
-            let guard = async_guard.guard();
-            let mut entry_ptr = EntryPtr::new(guard);
-            while entry_ptr.move_to_next(&locked_bucket.writer, guard) {
+        self.for_each_writer_async(0, 0, |mut locked_bucket, removed| {
+            let fake_guard = fake_guard();
+            let mut entry_ptr = EntryPtr::new(fake_guard);
+            while entry_ptr.move_to_next(&locked_bucket.writer, fake_guard) {
                 let consumable_entry = ConsumableEntry {
                     locked_bucket: &mut locked_bucket,
                     entry_ptr: &mut entry_ptr,
                     remove_probe: removed,
-                    guard,
+                    guard: fake_guard,
                 };
                 if !f(consumable_entry) {
                     result = false;
@@ -1329,12 +1326,12 @@ where
     }
 
     #[inline]
-    fn bucket_array(&self) -> &AtomicShared<BucketArray<K, V, DoublyLinkedList, CACHE>> {
+    fn bucket_array_var(&self) -> &AtomicShared<BucketArray<K, V, DoublyLinkedList, CACHE>> {
         &self.bucket_array
     }
 
     #[inline]
-    fn minimum_capacity(&self) -> &AtomicUsize {
+    fn minimum_capacity_var(&self) -> &AtomicUsize {
         &self.minimum_capacity
     }