chore(*): finalize SCC 2.3.1

wvwwvwwv · wvwwvwwv · commit 7aa799bf48cf · 2025-02-05T10:24:25.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,8 +4,9 @@
 
 2.3.1
 
+* Fix a problem with `HashCache::read` and `HashMap::read` where the read lock is dropped too early: [#176](https://github.com/wvwwvwwv/scalable-concurrent-containers/issues/176).
 * Fix `HashCache` documentation: [#175](https://github.com/wvwwvwwv/scalable-concurrent-containers/issues/175).
-* Implement `FromIterator` for collection types: [#173](https://github.com/wvwwvwwv/scalable-concurrent-containers/issues/173).
+* Implement `FromIterator` for `Hash*` types: [#173](https://github.com/wvwwvwwv/scalable-concurrent-containers/issues/173).
 
 2.3.0
 
diff --git a/src/hash_cache.rs b/src/hash_cache.rs
@@ -472,7 +472,7 @@ where
         self.read_entry(key, self.hash(key), &mut (), &Guard::new())
             .ok()
             .flatten()
-            .map(|(k, v, r)| {
+            .map(|(r, (k, v))| {
                 let result = reader(k, v);
                 drop(r);
                 result
@@ -503,7 +503,7 @@ where
             let mut async_wait = AsyncWait::default();
             let mut async_wait_pinned = Pin::new(&mut async_wait);
             if let Ok(result) = self.read_entry(key, hash, &mut async_wait_pinned, &Guard::new()) {
-                return result.map(|(k, v, r)| {
+                return result.map(|(r, (k, v))| {
                     let result = reader(k, v);
                     drop(r);
                     result
@@ -1205,6 +1205,27 @@ where
     }
 }
 
+impl<K, V, H> FromIterator<(K, V)> for HashCache<K, V, H>
+where
+    K: Eq + Hash,
+    H: BuildHasher + Default,
+{
+    #[inline]
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
+        let into_iter = iter.into_iter();
+        let size_hint = into_iter.size_hint();
+        let hashcache = Self::with_capacity_and_hasher(
+            size_hint.0,
+            Self::capacity_from_size_hint(size_hint),
+            H::default(),
+        );
+        into_iter.for_each(|e| {
+            let _result = hashcache.put(e.0, e.1);
+        });
+        hashcache
+    }
+}
+
 impl<K, V, H> HashTable<K, V, H, DoublyLinkedList, CACHE> for HashCache<K, V, H>
 where
     K: Eq + Hash,
diff --git a/src/hash_index.rs b/src/hash_index.rs
@@ -756,7 +756,7 @@ where
         self.read_entry(key, self.hash(key), &mut (), guard)
             .ok()
             .flatten()
-            .map(|(_, v, _)| v)
+            .map(|(_, (_, v))| v)
     }
 
     /// Peeks a key-value pair without acquiring locks.
@@ -783,7 +783,7 @@ where
         self.read_entry(key, self.hash(key), &mut (), &guard)
             .ok()
             .flatten()
-            .map(|(k, v, _)| reader(k, v))
+            .map(|(_, (k, v))| reader(k, v))
     }
 
     /// Returns `true` if the [`HashIndex`] contains a value for the specified key.
@@ -1201,6 +1201,26 @@ where
     }
 }
 
+impl<K, V, H> FromIterator<(K, V)> for HashIndex<K, V, H>
+where
+    K: 'static + Clone + Eq + Hash,
+    V: 'static + Clone,
+    H: BuildHasher + Default,
+{
+    #[inline]
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
+        let into_iter = iter.into_iter();
+        let hashindex = Self::with_capacity_and_hasher(
+            Self::capacity_from_size_hint(into_iter.size_hint()),
+            H::default(),
+        );
+        into_iter.for_each(|e| {
+            let _result = hashindex.insert(e.0, e.1);
+        });
+        hashindex
+    }
+}
+
 impl<K, V, H> HashTable<K, V, H, (), OPTIMISTIC> for HashIndex<K, V, H>
 where
     K: 'static + Clone + Eq + Hash,
diff --git a/src/hash_map.rs b/src/hash_map.rs
@@ -873,7 +873,7 @@ where
         self.read_entry(key, self.hash(key), &mut (), &Guard::new())
             .ok()
             .flatten()
-            .map(|(k, v, r)| {
+            .map(|(r, (k, v))| {
                 let result = reader(k, v);
                 drop(r);
                 result
@@ -904,7 +904,7 @@ where
             let mut async_wait = AsyncWait::default();
             let mut async_wait_pinned = Pin::new(&mut async_wait);
             if let Ok(result) = self.read_entry(key, hash, &mut async_wait_pinned, &Guard::new()) {
-                return result.map(|(k, v, r)| {
+                return result.map(|(r, (k, v))| {
                     let result = reader(k, v);
                     drop(r);
                     result
diff --git a/src/hash_set.rs b/src/hash_set.rs
@@ -1,5 +1,6 @@
 //! [`HashSet`] is a concurrent and asynchronous hash set.
 
+use super::hash_table::HashTable;
 use super::{Equivalent, HashMap};
 use std::collections::hash_map::RandomState;
 use std::fmt::{self, Debug};
@@ -736,6 +737,25 @@ where
     }
 }
 
+impl<K, H> FromIterator<K> for HashSet<K, H>
+where
+    K: Eq + Hash,
+    H: BuildHasher + Default,
+{
+    #[inline]
+    fn from_iter<T: IntoIterator<Item = K>>(iter: T) -> Self {
+        let into_iter = iter.into_iter();
+        let hashset = Self::with_capacity_and_hasher(
+            HashMap::<K, (), H>::capacity_from_size_hint(into_iter.size_hint()),
+            H::default(),
+        );
+        into_iter.for_each(|k| {
+            let _result = hashset.insert(k);
+        });
+        hashset
+    }
+}
+
 impl<K, H> PartialEq for HashSet<K, H>
 where
     K: Eq + Hash,
diff --git a/src/hash_table.rs b/src/hash_table.rs
@@ -282,14 +282,15 @@ where
     }
 
     /// Reads an entry from the [`HashTable`].
+    #[allow(clippy::type_complexity)]
     #[inline]
     fn read_entry<'g, Q, D>(
         &self,
         key: &Q,
         hash: u64,
         async_wait: &mut D,
         guard: &'g Guard,
-    ) -> Result<Option<(&'g K, &'g V, Option<Reader<'g, K, V, L, TYPE>>)>, ()>
+    ) -> Result<Option<(Option<Reader<'g, K, V, L, TYPE>>, &'g (K, V))>, ()>
     where
         Q: Equivalent<K> + Hash + ?Sized,
         D: DeriveAsyncWait,
@@ -302,13 +303,13 @@ where
                         != Ok(true)
                     {
                         let index = old_array.calculate_bucket_index(hash);
-                        if let Some((k, v)) = old_array.bucket(index).search_entry(
+                        if let Some(entry) = old_array.bucket(index).search_entry(
                             old_array.data_block(index),
                             key,
                             BucketArray::<K, V, L, TYPE>::partial_hash(hash),
                             guard,
                         ) {
-                            return Ok(Some((k, v, None)));
+                            return Ok(Some((None, entry)));
                         }
                     }
                 } else {
@@ -325,7 +326,7 @@ where
                     BucketArray::<K, V, L, TYPE>::partial_hash(hash),
                     guard,
                 ) {
-                    return Ok(Some((&entry.0, &entry.1, None)));
+                    return Ok(Some((None, entry)));
                 }
             } else {
                 let lock_result = if let Some(async_wait) = async_wait.derive() {
@@ -334,13 +335,13 @@ where
                     Reader::lock(bucket, guard)
                 };
                 if let Some(reader) = lock_result {
-                    if let Some((key, val)) = reader.search_entry(
+                    if let Some(entry) = reader.search_entry(
                         current_array.data_block(index),
                         key,
                         BucketArray::<K, V, L, TYPE>::partial_hash(hash),
                         guard,
                     ) {
-                        return Ok(Some((key, val, Some(reader))));
+                        return Ok(Some((Some(reader), entry)));
                     }
                 }
             }
diff --git a/src/tests/correctness.rs b/src/tests/correctness.rs
@@ -172,7 +172,7 @@ mod hashmap_test {
                     assert_eq!(first_item.unwrap(), &123_u8);
                 }
                 barrier_clone.wait();
-                thread::sleep(Duration::from_millis(100));
+                thread::sleep(Duration::from_millis(16));
                 {
                     let first_item = value.get(0);
                     assert_eq!(first_item.unwrap(), &123_u8);
@@ -1007,6 +1007,24 @@ mod hashindex_test {
         }
     }
 
+    #[test]
+    fn from_iter() {
+        static INST_CNT: AtomicUsize = AtomicUsize::new(0);
+
+        let workload_size = 256;
+        let hashindex = (0..workload_size)
+            .into_iter()
+            .map(|k| (k / 2, R::new(&INST_CNT)))
+            .collect::<HashIndex<usize, R>>();
+        assert_eq!(hashindex.len(), workload_size / 2);
+        drop(hashindex);
+
+        while INST_CNT.load(Relaxed) != 0 {
+            Guard::new().accelerate();
+            thread::yield_now();
+        }
+    }
+
     #[test]
     fn clone() {
         static INST_CNT: AtomicUsize = AtomicUsize::new(0);
@@ -1553,6 +1571,16 @@ mod hashset_test {
         assert!(hashset.contains("HELLO"));
     }
 
+    #[test]
+    fn from_iter() {
+        let workload_size = 256;
+        let hashset = (0..workload_size)
+            .into_iter()
+            .map(|k| k / 2)
+            .collect::<HashSet<usize>>();
+        assert_eq!(hashset.len(), workload_size / 2);
+    }
+
     #[test]
     fn compare() {
         let hashset1: HashSet<String> = HashSet::new();
