use super::*;
use std::sync::Arc;
use std::sync::mpsc;
use std::time::Duration;
const LONG: Duration = Duration::from_secs(10);
fn until_waiting(d: &Domain, n: u32) {
let start = std::time::Instant::now();
while d.waiting() < n {
assert!(start.elapsed() < LONG, "never registered");
std::thread::yield_now();
}
}
fn until_issued(d: &Domain, n: u64) {
let start = std::time::Instant::now();
while d.issued.load(Ordering::SeqCst) < n {
assert!(start.elapsed() < LONG, "never issued");
std::thread::yield_now();
}
}
fn held_leader(d: &Arc<Domain>, need: u64) -> (mpsc::Sender<()>, mpsc::Receiver<bool>) {
let (go, wait_go) = mpsc::channel::<()>();
let (tx, rx) = mpsc::channel();
let d = Arc::clone(d);
let _h = std::thread::spawn(move || {
let r = d.barrier(need, |_, _| {
let _released = wait_go.recv_timeout(3 * LONG);
Ok(())
});
let _sent = tx.send(r.is_ok());
});
(go, rx)
}
fn barrier(d: &Arc<Domain>, need: u64) -> mpsc::Receiver<bool> {
let (tx, rx) = mpsc::channel();
let d = Arc::clone(d);
let _h = std::thread::spawn(move || {
let _sent = tx.send(d.barrier(need, |_, _| Ok(())).is_ok());
});
rx
}
#[test]
fn test_every_barrier_a_flush_covered_is_woken() {
let d = Arc::new(Domain::new());
let need = d.ticket();
let (go, leader) = held_leader(&d, need);
until_issued(&d, 1);
let followers: Vec<_> = (0..3).map(|_| barrier(&d, need)).collect();
until_waiting(&d, 3);
let _sent = go.send(());
for f in &followers {
assert_eq!(f.recv_timeout(LONG), Ok(true), "a covered barrier slept on");
}
assert_eq!(leader.recv_timeout(LONG), Ok(true));
assert_eq!(d.waiting(), 0);
}
#[test]
fn test_a_jump_past_several_flushes_wakes_each_bucket() {
let d = Arc::new(Domain::with_slots(2));
let first = d.ticket();
let (go_first, l1) = held_leader(&d, first);
until_issued(&d, 1);
let second = d.ticket();
let (go_second, l2) = held_leader(&d, second);
until_issued(&d, 2);
let f1 = barrier(&d, first);
let f2 = barrier(&d, second);
until_waiting(&d, 2);
let _sent = go_second.send(());
until_waiting(&d, 3);
assert_eq!(d.done.load(Ordering::SeqCst), 0);
let _sent = go_first.send(());
assert_eq!(f1.recv_timeout(LONG), Ok(true), "need 1 slept on");
assert_eq!(f2.recv_timeout(LONG), Ok(true), "need 2 slept on");
assert_eq!(l1.recv_timeout(LONG), Ok(true));
assert_eq!(l2.recv_timeout(LONG), Ok(true));
assert_eq!(d.done.load(Ordering::SeqCst), 2);
}
#[test]
fn test_a_barrier_needing_the_next_flush_is_woken_to_lead_it() {
let d = Arc::new(Domain::new());
let first = d.ticket();
let (go, leader) = held_leader(&d, first);
until_issued(&d, 1);
let next = d.ticket();
assert_eq!(next, 2);
let f = barrier(&d, next);
until_waiting(&d, 1);
let _sent = go.send(());
assert_eq!(f.recv_timeout(LONG), Ok(true), "the next flush never led");
assert_eq!(leader.recv_timeout(LONG), Ok(true));
assert_eq!(d.done.load(Ordering::SeqCst), 2);
}
#[test]
fn test_a_barrier_whose_bucket_holds_another_need_is_still_woken() {
let d = Arc::new(Domain::with_slots(3));
let first = d.ticket();
let (go_first, l1) = held_leader(&d, first);
until_issued(&d, 1);
let (go_second, l2) = held_leader(&d, d.ticket());
until_issued(&d, 2);
let third_need = d.ticket();
let (go_third, l3) = held_leader(&d, third_need);
until_issued(&d, 3);
let third = barrier(&d, third_need);
until_waiting(&d, 1);
let late = barrier(&d, first);
until_waiting(&d, 2);
assert_eq!(d.lock().shared, 1, "the late barrier shares no bucket");
let _sent = go_first.send(());
assert_eq!(
late.recv_timeout(LONG),
Ok(true),
"need 1 slept past its flush"
);
let _sent = go_second.send(());
let _sent = go_third.send(());
assert_eq!(third.recv_timeout(LONG), Ok(true));
assert_eq!(l1.recv_timeout(LONG), Ok(true));
assert_eq!(l2.recv_timeout(LONG), Ok(true));
assert_eq!(l3.recv_timeout(LONG), Ok(true));
}
#[test]
fn test_the_designate_leads_the_next_flush_for_its_bucket() {
let d = Arc::new(Domain::new());
let (go, leader) = held_leader(&d, d.ticket());
until_issued(&d, 1);
let next = d.ticket();
let first = barrier(&d, next);
until_waiting(&d, 1);
assert_eq!(d.lock().designate, Some(next));
let rest: Vec<_> = (0..3).map(|_| barrier(&d, next)).collect();
until_waiting(&d, 4);
let b = (next % BUCKETS as u64) as usize;
assert_eq!(
d.lock().buckets[b].waiting,
3,
"the rest sleep in the bucket"
);
let _sent = go.send(());
assert_eq!(first.recv_timeout(LONG), Ok(true));
for r in &rest {
assert_eq!(r.recv_timeout(LONG), Ok(true), "a covered barrier slept on");
}
assert_eq!(leader.recv_timeout(LONG), Ok(true));
assert_eq!(d.stats().flushes, 2, "the next flush was led once");
assert_eq!(d.waiting(), 0);
}
#[test]
fn test_the_next_flush_is_led_by_a_barrier_that_can_use_the_freed_slot() {
let d = Arc::new(Domain::with_slots(2));
let (go_first, l1) = held_leader(&d, d.ticket());
until_issued(&d, 1);
let (go_second, l2) = held_leader(&d, d.ticket());
until_issued(&d, 2);
let need = d.ticket();
let (tx, main) = mpsc::channel();
{
let d = Arc::clone(&d);
let _h = std::thread::spawn(move || {
let _sent = tx.send(d.barrier_main(need, || Ok(())).is_ok());
});
}
until_waiting(&d, 1);
let data = barrier(&d, need);
until_waiting(&d, 2);
let _sent = go_first.send(());
until_issued(&d, 3);
let _sent = go_second.send(());
assert_eq!(data.recv_timeout(LONG), Ok(true));
assert_eq!(main.recv_timeout(LONG), Ok(true));
assert_eq!(l1.recv_timeout(LONG), Ok(true));
assert_eq!(l2.recv_timeout(LONG), Ok(true));
}
#[test]
fn test_a_wake_that_deregisters_nobody_leaves_the_barrier_asleep() {
let d = Arc::new(Domain::new());
let need = d.ticket();
let (go, leader) = held_leader(&d, need);
until_issued(&d, 1);
let f = barrier(&d, need);
until_waiting(&d, 1);
std::thread::sleep(Duration::from_millis(20));
d.bucket_words[(need % BUCKETS as u64) as usize].wake_all();
std::thread::sleep(Duration::from_millis(50));
assert_eq!(d.waiting(), 1, "a barrier left its bed unregistered");
assert_eq!(f.try_recv(), Err(mpsc::TryRecvError::Empty));
let _sent = go.send(());
assert_eq!(f.recv_timeout(LONG), Ok(true));
assert_eq!(leader.recv_timeout(LONG), Ok(true));
}
#[test]
fn test_a_jump_past_more_needs_than_buckets_wakes_every_need() {
let d = Arc::new(Domain::with_slots(3));
let needs: Vec<u64> = (0..3).map(|i| i + d.ticket()).collect();
let mut leaders = Vec::new();
for (i, &need) in needs.iter().enumerate() {
leaders.push(held_leader(&d, need));
until_issued(&d, i as u64 + 1);
}
let followers: Vec<_> = needs.iter().map(|&n| barrier(&d, n)).collect();
until_waiting(&d, 3);
for (parked, (go, _)) in (4..).zip(leaders.iter().rev().take(2)) {
let _sent = go.send(());
until_waiting(&d, parked);
}
assert_eq!(d.done.load(Ordering::SeqCst), 0);
let _sent = leaders[0].0.send(());
for f in &followers {
assert_eq!(f.recv_timeout(LONG), Ok(true), "a covered need slept on");
}
for (_, l) in &leaders {
assert_eq!(l.recv_timeout(LONG), Ok(true));
}
assert_eq!(d.done.load(Ordering::SeqCst), 3);
assert_eq!(d.waiting(), 0);
}
#[test]
fn test_poison_wakes_barriers_asleep_in_a_bucket() {
let d = Arc::new(Domain::new());
let need = d.ticket();
let (go, leader) = held_leader(&d, need);
until_issued(&d, 1);
let followers: Vec<_> = (0..2).map(|_| barrier(&d, need)).collect();
until_waiting(&d, 2);
d.poison(FirstCause {
op: None,
raw: None,
});
for f in &followers {
assert_eq!(
f.recv_timeout(LONG),
Ok(false),
"a poisoned barrier slept on"
);
}
let _sent = go.send(());
assert!(leader.recv_timeout(LONG).is_ok());
}
#[test]
fn test_waits_stop_yielding_after_misses_and_try_again_once() {
let p = Patience::default();
for _ in 0..MISSES {
assert!(p.try_yield(), "stopped before its misses");
p.ran_out();
}
for _ in 0..SKIPS {
assert!(!p.try_yield(), "yielded during the skips");
}
assert!(p.try_yield(), "no try after the skips");
p.ran_out();
assert!(!p.try_yield(), "a miss on the try did not stop it again");
}
#[test]
fn test_a_wait_that_reached_its_goal_forgets_the_misses() {
let p = Patience::default();
for _ in 0..MISSES - 1 {
p.ran_out();
}
p.reached();
for _ in 0..MISSES - 1 {
p.ran_out();
}
assert!(p.try_yield(), "misses that were not in a row stopped it");
}
fn missed(d: &Domain) -> u32 {
d.patience
.missed
.load(core::sync::atomic::Ordering::Relaxed)
}
#[test]
fn test_yields_that_run_out_are_counted() {
let d = Domain::new();
d.yield_to(1);
assert_eq!(missed(&d), 1, "ran out, and not counted");
d.yield_to(0);
assert_eq!(missed(&d), 0, "reached, and not forgotten");
d.poison(FirstCause {
op: None,
raw: None,
});
d.yield_to(1);
assert_eq!(missed(&d), 0, "poison counted as a miss");
}
#[test]
fn test_a_barrier_needing_the_next_flush_yields_for_the_one_before_it() {
let d = Arc::new(Domain::new());
assert!(d.barrier(d.ticket(), |_, _| Ok(())).is_ok());
let need = d.ticket();
assert!(d.hold_leadership());
let r = barrier(&d, need);
until_waiting(&d, 1);
assert_eq!(missed(&d), 0, "yielded for a flush only it could lead");
d.drop_leadership();
assert_eq!(r.recv_timeout(LONG), Ok(true));
}
#[test]
fn test_a_wait_in_the_skips_sleeps_without_yielding() {
let d = Arc::new(Domain::new());
for _ in 0..MISSES {
d.patience.ran_out();
}
let need = d.ticket();
let (go, leader) = held_leader(&d, need);
until_issued(&d, 1);
let r = barrier(&d, need);
until_waiting(&d, 1);
let left = d.patience.skip.load(core::sync::atomic::Ordering::Relaxed);
assert_eq!(left, SKIPS - 1, "yielded in the skips");
let _sent = go.send(());
assert_eq!(r.recv_timeout(LONG), Ok(true));
assert_eq!(leader.recv_timeout(LONG), Ok(true));
}