311 lines
10 KiB
Rust
311 lines
10 KiB
Rust
//! Stress-tests
|
||
//!
|
||
//! The tests in here try to torture the implementation with multiple threads, in an attempt to
|
||
//! discover any possible race condition.
|
||
|
||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
|
||
|
||
use adaptive_barrier::{Barrier, PanicMode};
|
||
use arc_swap::strategy::{CaS, DefaultStrategy, IndependentStrategy, Strategy};
|
||
use arc_swap::ArcSwapAny;
|
||
use crossbeam_utils::thread;
|
||
use itertools::Itertools;
|
||
use once_cell::sync::Lazy;
|
||
|
||
static LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
|
||
|
||
/// We want to prevent these tests from running concurrently, because they run multi-threaded.
|
||
fn lock() -> MutexGuard<'static, ()> {
|
||
LOCK.lock().unwrap_or_else(PoisonError::into_inner)
|
||
}
|
||
|
||
struct LLNode<S: Strategy<Option<Arc<LLNode<S>>>>> {
|
||
next: ArcSwapAny<Option<Arc<LLNode<S>>>, S>,
|
||
num: usize,
|
||
owner: usize,
|
||
}
|
||
|
||
/// A test that repeatedly builds a linked list concurrently with multiple threads.
|
||
///
|
||
/// The idea here is to stress-test the RCU implementation and see that no items get lost and that
|
||
/// the ref counts are correct afterwards.
|
||
fn storm_link_list<S>(node_cnt: usize, iters: usize)
|
||
where
|
||
S: Default + CaS<Option<Arc<LLNode<S>>>> + Send + Sync,
|
||
{
|
||
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 {
|
||
// We want to borrow these, but that kind-of conflicts with the move closure mode
|
||
let mut barr = barr.clone();
|
||
let head = &head;
|
||
scope.spawn(move |_| {
|
||
let nodes = (0..node_cnt)
|
||
.map(|i| LLNode {
|
||
next: ArcSwapAny::from(None),
|
||
num: i,
|
||
owner: thread,
|
||
})
|
||
.map(Arc::new)
|
||
.collect::<Vec<_>>();
|
||
for iter in 0..iters {
|
||
barr.wait(); // Start synchronously
|
||
for n in nodes.iter().rev() {
|
||
head.rcu(|head| {
|
||
n.next.store(head.clone()); // Cloning the optional Arc
|
||
Some(Arc::clone(n))
|
||
});
|
||
}
|
||
// And do the checks once everyone finishes
|
||
barr.wait();
|
||
// First, check that all our numbers are increasing by one and all are present
|
||
let mut node = head.load();
|
||
let mut expecting = 0;
|
||
while node.is_some() {
|
||
// A bit of gymnastics, we don't have NLL yet and we need to persuade the
|
||
// borrow checker this is safe.
|
||
let next = {
|
||
let inner = node.as_ref().unwrap();
|
||
if inner.owner == thread {
|
||
assert_eq!(expecting, inner.num);
|
||
expecting += 1;
|
||
}
|
||
inner.next.load()
|
||
};
|
||
node = next;
|
||
}
|
||
assert_eq!(node_cnt, expecting);
|
||
// We don't want to count the ref-counts while someone still plays around with
|
||
// them and loading.
|
||
barr.wait();
|
||
// Now that we've checked we have everything, check that all the nodes have ref
|
||
// count 2 ‒ once in the vector, once in the linked list.
|
||
for n in &nodes {
|
||
assert_eq!(
|
||
2,
|
||
Arc::strong_count(n),
|
||
"Wrong number of counts in item {} in iteration {}",
|
||
n.num,
|
||
iter,
|
||
);
|
||
}
|
||
// Reset the head so we don't mix the runs together, which would create a mess.
|
||
// Also, the tails might disturb the ref counts.
|
||
barr.wait();
|
||
head.store(None);
|
||
nodes.last().unwrap().next.store(None);
|
||
}
|
||
barr.wait();
|
||
// We went through all the iterations. Dismantle the list and see that everything
|
||
// has ref count 1.
|
||
head.store(None);
|
||
for n in &nodes {
|
||
n.next.store(None);
|
||
}
|
||
barr.wait(); // Wait until everyone resets their own nexts
|
||
for n in &nodes {
|
||
assert_eq!(1, Arc::strong_count(n));
|
||
}
|
||
});
|
||
}
|
||
|
||
drop(barr);
|
||
})
|
||
.unwrap();
|
||
}
|
||
|
||
struct LLNodeCnt<'a> {
|
||
next: Option<Arc<LLNodeCnt<'a>>>,
|
||
num: usize,
|
||
owner: usize,
|
||
live_cnt: &'a AtomicUsize,
|
||
}
|
||
|
||
impl<'a> Drop for LLNodeCnt<'a> {
|
||
fn drop(&mut self) {
|
||
self.live_cnt.fetch_sub(1, Ordering::Relaxed);
|
||
}
|
||
}
|
||
|
||
/// Test where we build and then deconstruct a linked list using multiple threads.
|
||
fn storm_unroll<S>(node_cnt: usize, iters: usize)
|
||
where
|
||
S: Default + Send + Sync,
|
||
for<'a> S: CaS<Option<Arc<LLNodeCnt<'a>>>>,
|
||
{
|
||
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.
|
||
let live_cnt = AtomicUsize::new(cpus * node_cnt * iters);
|
||
let head = ArcSwapAny::<_, S>::from(None);
|
||
thread::scope(|scope| {
|
||
for thread in 0..cpus {
|
||
// Borrow these instead of moving.
|
||
let head = &head;
|
||
let mut barr = barr.clone();
|
||
let global_cnt = &global_cnt;
|
||
let live_cnt = &live_cnt;
|
||
scope.spawn(move |_| {
|
||
for iter in 0..iters {
|
||
barr.wait();
|
||
// Create bunch of nodes and put them into the list.
|
||
for i in 0..node_cnt {
|
||
let mut node = Arc::new(LLNodeCnt {
|
||
next: None,
|
||
num: i,
|
||
owner: thread,
|
||
live_cnt,
|
||
});
|
||
head.rcu(|head| {
|
||
// Clone Option<Arc>
|
||
Arc::get_mut(&mut node).unwrap().next = head.clone();
|
||
Arc::clone(&node)
|
||
});
|
||
}
|
||
if barr.wait().is_leader() {
|
||
let mut cnt = 0;
|
||
let mut node = head.load_full();
|
||
while let Some(n) = node.as_ref() {
|
||
cnt += 1;
|
||
node = n.next.clone();
|
||
}
|
||
assert_eq!(cnt, node_cnt * cpus);
|
||
}
|
||
barr.wait();
|
||
// Keep removing items, count how many there are and that they increase in each
|
||
// thread's list.
|
||
let mut last_seen = vec![node_cnt; cpus];
|
||
let mut cnt = 0;
|
||
while let Some(node) =
|
||
head.rcu(|head| head.as_ref().and_then(|h| h.next.clone()))
|
||
{
|
||
assert!(last_seen[node.owner] > node.num);
|
||
last_seen[node.owner] = node.num;
|
||
cnt += 1;
|
||
}
|
||
global_cnt.fetch_add(cnt, Ordering::Relaxed);
|
||
if barr.wait().is_leader() {
|
||
assert_eq!(node_cnt * cpus, global_cnt.swap(0, Ordering::Relaxed));
|
||
}
|
||
assert_eq!(
|
||
(iters - iter - 1) * node_cnt * cpus,
|
||
live_cnt.load(Ordering::Relaxed),
|
||
);
|
||
}
|
||
});
|
||
}
|
||
|
||
drop(barr);
|
||
})
|
||
.unwrap();
|
||
// Everything got destroyed properly.
|
||
assert_eq!(0, live_cnt.load(Ordering::Relaxed));
|
||
}
|
||
|
||
fn load_parallel<S>(iters: usize)
|
||
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(|_| {
|
||
for i in 0..iters {
|
||
shared.store(Arc::new(i));
|
||
}
|
||
});
|
||
for _ in 0..cpus {
|
||
scope.spawn(|_| {
|
||
for _ in 0..iters {
|
||
let guards = (0..256).map(|_| shared.load()).collect::<Vec<_>>();
|
||
for (l, h) in guards.iter().tuple_windows() {
|
||
assert!(**l <= **h, "{} > {}", l, h);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
})
|
||
.unwrap();
|
||
let v = shared.load_full();
|
||
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::*;
|
||
|
||
#[allow(deprecated)] // We use some "deprecated" testing strategies
|
||
type Strategy = $strategy;
|
||
|
||
#[test]
|
||
fn storm_link_list_small() {
|
||
storm_link_list::<Strategy>(ITER_SMALL, 5);
|
||
}
|
||
|
||
#[test]
|
||
#[ignore]
|
||
fn storm_link_list_large() {
|
||
storm_link_list::<Strategy>(10_000, 50);
|
||
}
|
||
|
||
#[test]
|
||
fn storm_unroll_small() {
|
||
storm_unroll::<Strategy>(ITER_SMALL, 5);
|
||
}
|
||
|
||
#[test]
|
||
#[ignore]
|
||
fn storm_unroll_large() {
|
||
storm_unroll::<Strategy>(10_000, 50);
|
||
}
|
||
|
||
#[test]
|
||
fn load_parallel_small() {
|
||
load_parallel::<Strategy>(ITER_MID);
|
||
}
|
||
|
||
#[test]
|
||
#[ignore]
|
||
fn load_parallel_large() {
|
||
load_parallel::<Strategy>(100_000);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
t!(default, DefaultStrategy);
|
||
t!(independent, IndependentStrategy);
|
||
#[cfg(feature = "internal-test-strategies")]
|
||
t!(
|
||
full_slots,
|
||
arc_swap::strategy::test_strategies::FillFastSlots
|
||
);
|