Move garbage collection to seize

.github/workflows/miri.yml

@@ -22,4 +22,4 @@ jobs:
           command: miri
           args: test
         env:
-          MIRIFLAGS: "-Zmiri-ignore-leaks"
+          MIRIFLAGS: "-Zmiri-tag-raw-pointers -Zmiri-disable-isolation"

.github/workflows/msrv.yml

@@ -10,10 +10,10 @@ jobs:
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: 1.52.0 # rustdoc:: lint prefix
+          toolchain: 1.56.0 # UnsafeCell::raw_get
           override: true
       - uses: actions/checkout@v2
-      - name: cargo +1.52.0 check
+      - name: cargo +1.56.0 check
         uses: actions-rs/cargo@v1
         with:
           command: check

Cargo.toml

@@ -19,15 +19,12 @@ azure-devops = { project = "jonhoo/jonhoo", pipeline = "flurry", build = "15" }
 codecov = { repository = "jonhoo/flurry", branch = "master", service = "github" }
 maintenance = { status = "experimental" }
 
-[features]
-sanitize = ['crossbeam-epoch/sanitize']
-
 [dependencies]
-crossbeam-epoch = "0.8.2"
 parking_lot = "0.10"
 num_cpus = "1.12.0"
 rayon = {version = "1.3", optional = true}
 serde = {version = "1.0.105", optional = true}
+seize = "0.2.0"
 
 [dependencies.ahash]
 version = "0.3.2"

src/iter/mod.rs

@@ -1,7 +1,7 @@
 mod traverser;
 pub(crate) use traverser::NodeIter;
 
-use crossbeam_epoch::Guard;
+use crate::reclaim::{Guard, Shared};
 use std::sync::atomic::Ordering;
 
 /// An iterator over a map's entries.
@@ -10,17 +10,23 @@ use std::sync::atomic::Ordering;
 #[derive(Debug)]
 pub struct Iter<'g, K, V> {
     pub(crate) node_iter: NodeIter<'g, K, V>,
-    pub(crate) guard: &'g Guard,
+    pub(crate) guard: &'g Guard<'g>,
+}
+
+impl<'g, K, V> Iter<'g, K, V> {
+    pub(crate) fn next_internal(&mut self) -> Option<(&'g K, Shared<'g, V>)> {
+        let node = self.node_iter.next()?;
+        let value = node.value.load(Ordering::SeqCst, self.guard);
+        Some((&node.key, value))
+    }
 }
 
 impl<'g, K, V> Iterator for Iter<'g, K, V> {
     type Item = (&'g K, &'g V);
     fn next(&mut self) -> Option<Self::Item> {
-        let node = self.node_iter.next()?;
-        let value = node.value.load(Ordering::SeqCst, self.guard);
         // safety: flurry does not drop or move until after guard drop
-        let value = unsafe { value.deref() };
-        Some((&node.key, value))
+        self.next_internal()
+            .map(|(k, v)| unsafe { (k, &**v.deref()) })
     }
 }
 
@@ -46,7 +52,7 @@ impl<'g, K, V> Iterator for Keys<'g, K, V> {
 #[derive(Debug)]
 pub struct Values<'g, K, V> {
     pub(crate) node_iter: NodeIter<'g, K, V>,
-    pub(crate) guard: &'g Guard,
+    pub(crate) guard: &'g Guard<'g>,
 }
 
 impl<'g, K, V> Iterator for Values<'g, K, V> {
@@ -63,19 +69,18 @@ impl<'g, K, V> Iterator for Values<'g, K, V> {
 #[cfg(test)]
 mod tests {
     use crate::HashMap;
-    use crossbeam_epoch as epoch;
     use std::collections::HashSet;
     use std::iter::FromIterator;
 
     #[test]
     fn iter() {
         let map = HashMap::<usize, usize>::new();
 
-        let guard = epoch::pin();
+        let guard = map.guard();
         map.insert(1, 42, &guard);
         map.insert(2, 84, &guard);
 
-        let guard = epoch::pin();
+        let guard = map.guard();
         assert_eq!(
             map.iter(&guard).collect::<HashSet<(&usize, &usize)>>(),
             HashSet::from_iter(vec![(&1, &42), (&2, &84)])
@@ -86,11 +91,11 @@ mod tests {
     fn keys() {
         let map = HashMap::<usize, usize>::new();
 
-        let guard = epoch::pin();
+        let guard = map.guard();
         map.insert(1, 42, &guard);
         map.insert(2, 84, &guard);
 
-        let guard = epoch::pin();
+        let guard = map.guard();
         assert_eq!(
             map.keys(&guard).collect::<HashSet<&usize>>(),
             HashSet::from_iter(vec![&1, &2])
@@ -101,10 +106,10 @@ mod tests {
     fn values() {
         let map = HashMap::<usize, usize>::new();
 
-        let mut guard = epoch::pin();
+        let mut guard = map.guard();
         map.insert(1, 42, &guard);
         map.insert(2, 84, &guard);
-        guard.repin();
+        guard.flush();
 
         assert_eq!(
             map.values(&guard).collect::<HashSet<&usize>>(),

src/iter/traverser.rs

@@ -1,12 +1,12 @@
 use crate::node::{BinEntry, Node, TreeNode};
 use crate::raw::Table;
-use crossbeam_epoch::{Guard, Shared};
+use crate::reclaim::{Guard, Linked, Shared};
 use std::sync::atomic::Ordering;
 
 #[derive(Debug)]
 pub(crate) struct NodeIter<'g, K, V> {
     /// Current table; update if resized
-    table: Option<&'g Table<K, V>>,
+    table: Option<&'g Linked<Table<K, V>>>,
 
     stack: Option<Box<TableStack<'g, K, V>>>,
     spare: Option<Box<TableStack<'g, K, V>>>,
@@ -26,11 +26,11 @@ pub(crate) struct NodeIter<'g, K, V> {
     /// Initial table size
     base_size: usize,
 
-    guard: &'g Guard,
+    guard: &'g Guard<'g>,
 }
 
 impl<'g, K, V> NodeIter<'g, K, V> {
-    pub(crate) fn new(table: Shared<'g, Table<K, V>>, guard: &'g Guard) -> Self {
+    pub(crate) fn new(table: Shared<'g, Table<K, V>>, guard: &'g Guard<'_>) -> Self {
         let (table, len) = if table.is_null() {
             (None, 0)
         } else {
@@ -53,7 +53,7 @@ impl<'g, K, V> NodeIter<'g, K, V> {
         }
     }
 
-    fn push_state(&mut self, t: &'g Table<K, V>, i: usize, n: usize) {
+    fn push_state(&mut self, t: &'g Linked<Table<K, V>>, i: usize, n: usize) {
         let mut s = self.spare.take();
         if let Some(ref mut s) = s {
             self.spare = s.next.take();
@@ -121,11 +121,11 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
                 // inheritance (everything is a node), but we have to explicitly
                 // check
                 // safety: flurry does not drop or move until after guard drop
-                match unsafe { next.deref() } {
-                    BinEntry::Node(node) => {
+                match **unsafe { next.deref() } {
+                    BinEntry::Node(ref node) => {
                         e = Some(node);
                     }
-                    BinEntry::TreeNode(tree_node) => {
+                    BinEntry::TreeNode(ref tree_node) => {
                         e = Some(&tree_node.node);
                     }
                     BinEntry::Moved => unreachable!("Nodes can only point to Nodes or TreeNodes"),
@@ -156,7 +156,7 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
             if !bin.is_null() {
                 // safety: flurry does not drop or move until after guard drop
                 let bin = unsafe { bin.deref() };
-                match bin {
+                match **bin {
                     BinEntry::Moved => {
                         // recurse down into the target table
                         // safety: same argument as for following Moved in Table::find
@@ -166,17 +166,17 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
                         self.push_state(t, i, n);
                         continue;
                     }
-                    BinEntry::Node(node) => {
+                    BinEntry::Node(ref node) => {
                         e = Some(node);
                     }
-                    BinEntry::Tree(tree_bin) => {
+                    BinEntry::Tree(ref tree_bin) => {
                         // since we want to iterate over all entries, TreeBins
                         // are also traversed via the `next` pointers of their
                         // contained node
                         e = Some(
                             // safety: `bin` was read under our guard, at which
-                            // point the tree was valid. Since our guard pins
-                            // the current epoch, the TreeNodes remain valid for
+                            // point the tree was valid. Since our guard marks
+                            // the current thread as active, the TreeNodes remain valid for
                             // at least as long as we hold onto the guard.
                             // Structurally, TreeNodes always point to TreeNodes, so this is sound.
                             &unsafe {
@@ -210,51 +210,55 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
 struct TableStack<'g, K, V> {
     length: usize,
     index: usize,
-    table: &'g Table<K, V>,
+    table: &'g Linked<Table<K, V>>,
     next: Option<Box<TableStack<'g, K, V>>>,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::raw::Table;
-    use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    use crate::reclaim::Atomic;
     use parking_lot::Mutex;
 
     #[test]
     fn iter_new() {
-        let guard = epoch::pin();
+        let guard = unsafe { seize::Guard::unprotected() };
         let iter = NodeIter::<usize, usize>::new(Shared::null(), &guard);
         assert_eq!(iter.count(), 0);
     }
 
     #[test]
     fn iter_empty() {
-        let table = Owned::new(Table::<usize, usize>::new(16));
-        let guard = epoch::pin();
-        let table = table.into_shared(&guard);
+        let collector = seize::Collector::new();
+
+        let table = Shared::boxed(Table::<usize, usize>::new(16, &collector), &collector);
+        let guard = collector.enter();
         let iter = NodeIter::new(table, &guard);
         assert_eq!(iter.count(), 0);
 
         // safety: nothing holds on to references into the table any more
-        let mut t = unsafe { table.into_owned() };
+        let mut t = unsafe { table.into_box() };
         t.drop_bins();
     }
 
     #[test]
     fn iter_simple() {
+        let collector = seize::Collector::new();
         let mut bins = vec![Atomic::null(); 16];
-        bins[8] = Atomic::new(BinEntry::Node(Node {
-            hash: 0,
-            key: 0usize,
-            value: Atomic::new(0usize),
-            next: Atomic::null(),
-            lock: Mutex::new(()),
-        }));
-
-        let table = Owned::new(Table::from(bins));
-        let guard = epoch::pin();
-        let table = table.into_shared(&guard);
+        bins[8] = Atomic::from(Shared::boxed(
+            BinEntry::Node(Node {
+                hash: 0,
+                key: 0usize,
+                value: Atomic::from(Shared::boxed(0usize, &collector)),
+                next: Atomic::null(),
+                lock: Mutex::new(()),
+            }),
+            &collector,
+        ));
+
+        let table = Shared::boxed(Table::from(bins, &collector), &collector);
+        let guard = collector.enter();
         {
             let mut iter = NodeIter::new(table, &guard);
             let e = iter.next().unwrap();
@@ -263,27 +267,32 @@ mod tests {
         }
 
         // safety: nothing holds on to references into the table any more
-        let mut t = unsafe { table.into_owned() };
+        let mut t = unsafe { table.into_box() };
         t.drop_bins();
     }
 
     #[test]
     fn iter_fw() {
         // construct the forwarded-to table
+        let collector = seize::Collector::new();
         let mut deep_bins = vec![Atomic::null(); 16];
-        deep_bins[8] = Atomic::new(BinEntry::Node(Node {
-            hash: 0,
-            key: 0usize,
-            value: Atomic::new(0usize),
-            next: Atomic::null(),
-            lock: Mutex::new(()),
-        }));
-        let guard = epoch::pin();
-        let deep_table = Owned::new(Table::from(deep_bins)).into_shared(&guard);
+        deep_bins[8] = Atomic::from(Shared::boxed(
+            BinEntry::Node(Node {
+                hash: 0,
+                key: 0usize,
+                value: Atomic::from(Shared::boxed(0usize, &collector)),
+                next: Atomic::null(),
+                lock: Mutex::new(()),
+            }),
+            &collector,
+        ));
+
+        let guard = collector.enter();
+        let deep_table = Shared::boxed(Table::from(deep_bins, &collector), &collector);
 
         // construct the forwarded-from table
         let mut bins = vec![Shared::null(); 16];
-        let table = Table::<usize, usize>::new(bins.len());
+        let table = Table::<usize, usize>::new(bins.len(), &collector);
         for bin in &mut bins[8..] {
             // this also sets table.next_table to deep_table
             *bin = table.get_moved(deep_table, &guard);
@@ -293,7 +302,7 @@ mod tests {
         for i in 0..bins.len() {
             table.store_bin(i, bins[i]);
         }
-        let table = Owned::new(table).into_shared(&guard);
+        let table = Shared::boxed(table, &collector);
         {
             let mut iter = NodeIter::new(table, &guard);
             let e = iter.next().unwrap();
@@ -302,9 +311,9 @@ mod tests {
         }
 
         // safety: nothing holds on to references into the table any more
-        let mut t = unsafe { table.into_owned() };
+        let mut t = unsafe { table.into_box() };
         t.drop_bins();
         // no one besides this test case uses deep_table
-        unsafe { deep_table.into_owned() }.drop_bins();
+        unsafe { deep_table.into_box() }.drop_bins();
     }
 }