Add loom behind cfg debug_assertions and make all the test use it

Cargo.toml

@@ -23,6 +23,8 @@ maintenance = { status = "experimental" }
 crossbeam-epoch = "0.8"
 parking_lot = "0.10"
 num_cpus = "1.12.0"
+lazy_static = "1.4"
+loom = "0.2.14"
 
 [dev-dependencies]
 rand = "0.7"

src/iter/iter.rs

@@ -67,46 +67,52 @@ mod tests {
 
     #[test]
     fn iter() {
-        let map = HashMap::<usize, usize>::new();
-
-        let guard = epoch::pin();
-        map.insert(1, 42, &guard);
-        map.insert(2, 84, &guard);
-
-        let guard = epoch::pin();
-        assert_eq!(
-            map.iter(&guard).collect::<HashSet<(&usize, &usize)>>(),
-            HashSet::from_iter(vec![(&1, &42), (&2, &84)])
-        );
+        loom::model(|| {
+            let map = HashMap::<usize, usize>::new();
+
+            let guard = epoch::pin();
+            map.insert(1, 42, &guard);
+            map.insert(2, 84, &guard);
+
+            let guard = epoch::pin();
+            assert_eq!(
+                map.iter(&guard).collect::<HashSet<(&usize, &usize)>>(),
+                HashSet::from_iter(vec![(&1, &42), (&2, &84)])
+            );
+        });
     }
 
     #[test]
     fn keys() {
-        let map = HashMap::<usize, usize>::new();
-
-        let guard = epoch::pin();
-        map.insert(1, 42, &guard);
-        map.insert(2, 84, &guard);
-
-        let guard = epoch::pin();
-        assert_eq!(
-            map.keys(&guard).collect::<HashSet<&usize>>(),
-            HashSet::from_iter(vec![&1, &2])
-        );
+        loom::model(|| {
+            let map = HashMap::<usize, usize>::new();
+
+            let guard = epoch::pin();
+            map.insert(1, 42, &guard);
+            map.insert(2, 84, &guard);
+
+            let guard = epoch::pin();
+            assert_eq!(
+                map.keys(&guard).collect::<HashSet<&usize>>(),
+                HashSet::from_iter(vec![&1, &2])
+            );
+        });
     }
 
     #[test]
     fn values() {
-        let map = HashMap::<usize, usize>::new();
-
-        let mut guard = epoch::pin();
-        map.insert(1, 42, &guard);
-        map.insert(2, 84, &guard);
-        guard.repin();
-
-        assert_eq!(
-            map.values(&guard).collect::<HashSet<&usize>>(),
-            HashSet::from_iter(vec![&42, &84])
-        );
+        loom::model(|| {
+            let map = HashMap::<usize, usize>::new();
+
+            let mut guard = epoch::pin();
+            map.insert(1, 42, &guard);
+            map.insert(2, 84, &guard);
+            guard.repin();
+
+            assert_eq!(
+                map.values(&guard).collect::<HashSet<&usize>>(),
+                HashSet::from_iter(vec![&42, &84])
+            );
+        });
     }
 }

src/lib.rs

@@ -200,6 +200,9 @@
 )]
 #![warn(rust_2018_idioms)]
 
+#[macro_use]
+extern crate lazy_static;
+
 mod map;
 mod node;
 mod raw;

src/map.rs

@@ -7,6 +7,14 @@ use std::collections::hash_map::RandomState;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::iter::FromIterator;
+
+#[cfg(debug_assertions)]
+use loom::sync::atomic::{AtomicUsize, Ordering};
+#[cfg(debug_assertions)]
+use std::sync::atomic::AtomicIsize;
+#[cfg(debug_assertions)]
+use std::sync::Once;
+#[cfg(not(debug_assertions))]
 use std::sync::{
     atomic::{AtomicIsize, AtomicUsize, Ordering},
     Once,
@@ -49,8 +57,14 @@ const MAX_RESIZERS: isize = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
 const RESIZE_STAMP_SHIFT: usize = 32 - RESIZE_STAMP_BITS;
 
 static NCPU_INITIALIZER: Once = Once::new();
+#[cfg(not(debug_assertions))]
 static NCPU: AtomicUsize = AtomicUsize::new(0);
 
+#[cfg(debug_assertions)]
+lazy_static! {
+    static ref NCPU: AtomicUsize = AtomicUsize::new(0);
+}
+
 /// A concurrent hash table.
 ///
 /// See the [crate-level documentation](index.html) for details.