fix(hash_cache, #175): update doc regarding the capacity

Author: wvwwvwwv

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Version 2
 
+2.3.1
+
+* Fix documentation.
+
 2.3.0
 
 * Fix incorrect Sync trait bounds of `Bag` and `Hash*`.

Cargo.toml

@@ -2,7 +2,7 @@
 name = "scc"
 description = "High-performance containers and utilities for concurrent and asynchronous programming"
 documentation = "https://docs.rs/scc"
-version = "2.3.0"
+version = "2.3.1"
 authors = ["wvwwvwwv <[email protected]>"]
 edition = "2021"
 rust-version = "1.65.0"

src/hash_cache.rs

@@ -1109,8 +1109,9 @@ where
 
     /// Creates an empty [`HashCache`] with the specified capacity.
     ///
-    /// The supplied minimum and maximum capacity values are adjusted to any suitable
-    /// `power-of-two` values that are close to them.
+    /// The supplied minimum and maximum capacity values are adjusted to power-of-two values equal
+    /// to or larger than them, while the adjusted values cannot be in a range of (0, 64), and the
+    /// maximum capacity cannot be 0.
     ///
     /// # Examples
     ///
@@ -1121,6 +1122,10 @@ where
     ///
     /// let result = hashcache.capacity();
     /// assert_eq!(result, 1024);
+    ///
+    /// let hashcache: HashCache<u64, u32> = HashCache::with_capacity(0, 0);
+    /// let result = hashcache.capacity_range();
+    /// assert_eq!(result, 0..=64);
     /// ```
     #[inline]
     #[must_use]

src/tests/correctness.rs

@@ -12,7 +12,7 @@ mod hashmap_test {
     use std::rc::Rc;
     use std::sync::atomic::Ordering::{Acquire, Relaxed, Release};
     use std::sync::atomic::{AtomicU64, AtomicUsize};
-    use std::sync::Arc;
+    use std::sync::{Arc, Barrier};
     use tokio::sync::Barrier as AsyncBarrier;
 
     static_assertions::assert_not_impl_all!(HashMap<Rc<String>, Rc<String>>: Send, Sync);
@@ -392,6 +392,47 @@ mod hashmap_test {
         }
     }
 
+    #[cfg_attr(miri, ignore)]
+    #[test]
+    fn insert_read() {
+        for i in 0..65536 {
+            let hashmap: Arc<HashMap<[u8; 32], usize>> = Arc::new(HashMap::default());
+            let num_tasks = 16;
+            let workload_size = 65536;
+            let mut task_handles = Vec::with_capacity(num_tasks);
+            let barrier = Arc::new(Barrier::new(num_tasks));
+            for task_id in 0..num_tasks {
+                let barrier_clone = barrier.clone();
+                let hashmap_clone = hashmap.clone();
+                task_handles.push(std::thread::spawn(move || {
+                    barrier_clone.wait();
+                    let range = (task_id * workload_size)..((task_id + 1) * workload_size);
+                    let mut key = [0_u8; 32];
+                    for id in range.clone() {
+                        for i in 0..8 {
+                            key[i] = (id >> (i * 8)) as u8;
+                        }
+                        let e = hashmap_clone.entry(key.clone()).insert_entry(id);
+                        assert_eq!(e.get(), &id);
+                        drop(e);
+                        assert!(hashmap_clone.read(&key, |_, _| ()).is_some());
+                    }
+                    for id in range {
+                        for i in 0..8 {
+                            key[i] = (id >> (i * 8)) as u8;
+                        }
+                        assert!(hashmap_clone.read(&key, |_, _| ()).is_some());
+                    }
+                }));
+            }
+            println!("OK {i}");
+
+            for r in task_handles {
+                assert!(r.join().is_ok());
+            }
+        }
+    }
+
     #[cfg_attr(miri, ignore)]
     #[tokio::test(flavor = "multi_thread", worker_threads = 8)]
     async fn entry_next_retain() {