Merge branch 'wfs' of github.com:vorner/arc-swap into wfs

.github/workflows/test.yaml

@@ -144,4 +144,26 @@ jobs:
       - name: Run clippy linter
         run: rm Cargo.lock && cargo check
 
-# TODO: Some miri checks
+  miri:
+    name: Miri checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          profile: minimal
+          default: true
+          components: "miri"
+
+      - name: Restore cache
+        uses: Swatinem/rust-cache@v1
+
+      - name: Run miri
+        env:
+          PROPTEST_CASES: "10"
+          MIRIFLAGS: "-Zmiri-disable-isolation"
+        run: cargo miri test

src/debt.rs

@@ -43,7 +43,11 @@ impl Node {
         traverse(|node| {
             // Try to claim this node. Nothing is synchronized through this atomic, we only
             // track if someone claims ownership of it.
-            if !node.in_use.compare_and_swap(false, true, Ordering::Relaxed) {
+            let claimed = node
+                .in_use
+                .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+                .is_ok();
+            if claimed {
                 Some(node)
             } else {
                 None

src/gen_lock.rs

@@ -230,7 +230,7 @@ pub(crate) fn wait_for_readers<S: LockStorage>(storage: &S) {
         let next_gen = gen.wrapping_add(1);
         if groups[next_gen % GEN_CNT] == 0 {
             // Replace it only if someone else didn't do it in the meantime
-            gen_idk.compare_and_swap(gen, next_gen, Ordering::Relaxed);
+            let _ = gen_idk.compare_exchange(gen, next_gen, Ordering::Relaxed, Ordering::Relaxed);
         }
         for i in 0..GEN_CNT {
             seen_group[i] = seen_group[i] || (groups[i] == 0);

src/lib.rs

@@ -777,9 +777,9 @@ macro_rules! t {
             /// Similar to the one in doc tests of the lib, but more times and more intensive (we
             /// want to torture it a bit).
             #[test]
-            #[cfg(not(miri))] // Infinitely slow under miri :-(
+            #[cfg_attr(miri, ignore)] // Takes like 1 or 2 infinities to run under miri
             fn publish() {
-                const READERS: usize = 3;
+                const READERS: usize = 2;
                 for _ in 0..ITERATIONS {
                     let config = AS::<String>::default();
                     let ended = AtomicUsize::new(0);
@@ -842,6 +842,9 @@ macro_rules! t {
                 let shared = AS::from(Arc::clone(&first_value));
                 const WRITER_CNT: usize = 2;
                 const READER_CNT: usize = 3;
+                #[cfg(miri)]
+                const ITERATIONS: usize = 10;
+                #[cfg(not(miri))]
                 const ITERATIONS: usize = 100;
                 const SEQ: usize = 50;
                 let barrier = Barrier::new(PanicMode::Poison);

src/strategy/gen_lock.rs

@@ -1,4 +1,3 @@
-use std::ptr;
 use std::sync::atomic::{AtomicPtr, Ordering};
 
 use crate::gen_lock::{self, GenLock, LockStorage};
@@ -44,8 +43,12 @@ impl<T: RefCnt, L: LockStorage> CaS<T> for GenLockStrategy<L> {
         // which ones upfront, so we need to implement safety measures for both.
         let lock = GenLock::new(&self.0);
 
-        let previous_ptr = storage.compare_and_swap(cur_ptr, new, Ordering::SeqCst);
-        let swapped = ptr::eq(cur_ptr, previous_ptr);
+        let swap_result =
+            storage.compare_exchange(cur_ptr, new, Ordering::SeqCst, Ordering::SeqCst);
+        let (previous_ptr, swapped) = match swap_result {
+            Ok(previous) => (previous, true),
+            Err(previous) => (previous, false),
+        };
 
         // Drop it here, because:
         // * We can't drop it before the compare_and_swap ‒ in such case, it could get recycled,

src/strategy/helping.rs

@@ -9,13 +9,12 @@ use std::fmt::{Debug, Formatter, Result as FmtResult};
 use std::mem::{self, ManuallyDrop};
 use std::ops::Deref;
 use std::ptr;
-use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize, Ordering};
+use std::sync::atomic::Ordering::*;
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
 
 use super::sealed::{InnerStrategy, Protected};
 use crate::RefCnt;
 
-use Ordering::*;
-
 /// A wrapper around a node pointer, to un-claim the node on thread shutdown.
 struct DebtHead {
     // Node for this thread.
@@ -133,7 +132,7 @@ impl Debt {
             //
             // The Release works as kind of Mutex. We make sure nothing from the debt-protected
             // sections leaks below this point.
-            .compare_exchange(ptr as usize, NO_DEBT, Ordering::Release, Ordering::Relaxed)
+            .compare_exchange(ptr as usize, NO_DEBT, Release, Relaxed)
             .is_ok()
     }
 

src/strategy/hybrid.rs

@@ -147,8 +147,12 @@ impl<T: RefCnt, L: LockStorage> CaS<T> for HybridStrategy<GenLockStrategy<L>> {
         // which ones upfront, so we need to implement safety measures for both.
         let gen = GenLock::new(&self.fallback.0);
 
-        let previous_ptr = storage.compare_and_swap(cur_ptr, new, Ordering::SeqCst);
-        let swapped = ptr::eq(cur_ptr, previous_ptr);
+        let swap_result =
+            storage.compare_exchange(cur_ptr, new, Ordering::SeqCst, Ordering::SeqCst);
+        let (previous_ptr, swapped) = match swap_result {
+            Ok(previous) => (previous, true),
+            Err(previous) => (previous, false),
+        };
 
         // Drop it here, because:
         // * We can't drop it before the compare_and_swap ‒ in such case, it could get recycled,

src/weak.rs

@@ -49,6 +49,8 @@ mod tests {
 
     // Replace a weak pointer with a NULL one
     #[test]
+    // Miri-bug in std, see https://github.com/rust-lang/rust/issues/80365
+    #[cfg_attr(miri, ignore)]
     fn reset() {
         let data = Arc::new("Hello");
         let shared = ArcSwapWeak::new(Arc::downgrade(&data));

tests/random.rs

@@ -29,6 +29,10 @@ impl OpsInstruction {
 proptest! {}
 
 const LIMIT: usize = 5;
+#[cfg(not(miri))]
+const SIZE: usize = 100;
+#[cfg(miri)]
+const SIZE: usize = 10;
 static ARCS: Lazy<Vec<Arc<usize>>> = Lazy::new(|| (0..LIMIT).map(Arc::new).collect());
 
 #[derive(Copy, Clone, Debug)]
@@ -52,7 +56,7 @@ macro_rules! t {
         t!(@compose => $name, $strategy,
             #[test]
             fn selection(
-                instructions in proptest::collection::vec(SelInstruction::random(), 1..100),
+                instructions in proptest::collection::vec(SelInstruction::random(), 1..SIZE),
             ) {
                 let mut bare = Arc::clone(&ARCS[0]);
                 let a = ArcSwapAny::<_, $strategy>::from(Arc::clone(&ARCS[0]));
@@ -88,7 +92,7 @@ macro_rules! t {
 
                 #[test]
                 fn ops(
-                    instructions in proptest::collection::vec(OpsInstruction::random(), 1..100),
+                    instructions in proptest::collection::vec(OpsInstruction::random(), 1..SIZE),
                 ) {
                     use crate::OpsInstruction::*;
                     let mut m = 0;

tests/stress.rs

@@ -36,7 +36,10 @@ where
 {
     let _lock = lock();
     let head = ArcSwapAny::<_, S>::from(None::<Arc<LLNode<S>>>);
+    #[cfg(not(miri))]
     let cpus = num_cpus::get();
+    #[cfg(miri)]
+    let cpus = 2;
     let barr = Barrier::new(PanicMode::Poison);
     thread::scope(|scope| {
         for thread in 0..cpus {
@@ -139,7 +142,10 @@ where
 {
     let _lock = lock();
 
+    #[cfg(not(miri))]
     let cpus = num_cpus::get();
+    #[cfg(miri)]
+    let cpus = 2;
     let barr = Barrier::new(PanicMode::Poison);
     let global_cnt = AtomicUsize::new(0);
     // We plan to create this many nodes during the whole test.
@@ -201,7 +207,10 @@ where
     S: Default + Strategy<Arc<usize>> + Send + Sync,
 {
     let _lock = lock();
+    #[cfg(not(miri))]
     let cpus = num_cpus::get();
+    #[cfg(miri)]
+    let cpus = 2;
     let shared = ArcSwapAny::<_, S>::from(Arc::new(0));
     thread::scope(|scope| {
         scope.spawn(|_| {
@@ -225,14 +234,24 @@ where
     assert_eq!(2, Arc::strong_count(&v));
 }
 
+#[cfg(not(miri))]
+const ITER_SMALL: usize = 100;
+#[cfg(not(miri))]
+const ITER_MID: usize = 1000;
+
+#[cfg(miri)]
+const ITER_SMALL: usize = 2;
+#[cfg(miri)]
+const ITER_MID: usize = 5;
+
 macro_rules! t {
     ($name: ident, $strategy: ty) => {
         mod $name {
             use super::*;
 
             #[test]
             fn storm_link_list_small() {
-                storm_link_list::<$strategy>(100, 5);
+                storm_link_list::<$strategy>(ITER_SMALL, 5);
             }
 
             #[test]
@@ -243,7 +262,7 @@ macro_rules! t {
 
             #[test]
             fn storm_unroll_small() {
-                storm_unroll::<$strategy>(100, 5);
+                storm_unroll::<$strategy>(ITER_SMALL, 5);
             }
 
             #[test]
@@ -254,7 +273,7 @@ macro_rules! t {
 
             #[test]
             fn load_parallel_small() {
-                load_parallel::<$strategy>(1000);
+                load_parallel::<$strategy>(ITER_MID);
             }
 
             #[test]