use super::{MutexQueue, Subscription};
use crate::{
Error, TaskId,
signal::lock,
task_slab::TaskKey,
wait::{WaitBegin, WaitCell, WaitHub, WakeCause},
};
use std::sync::{Arc, mpsc};
use vthread_sync_core::ExclusiveCell;
#[test]
fn subscription_closes_an_unlock_before_enqueue_race() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(42);
drop(value.try_lock().expect("first owner"));
let wait = WaitCell::new();
let Subscription::Acquired(guard) = queue.subscribe(&value, &wait).unwrap() else {
panic!("released mutex queued a waiter");
};
assert_eq!(*guard, 42);
assert_eq!(queue.waiting(), 0);
}
#[test]
fn abandoned_selected_ticket_returns_ownership() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(0);
let owner = value.try_lock().expect("first owner");
let wait = WaitCell::new();
let Subscription::Waiting(ticket) = queue.subscribe(&value, &wait).unwrap() else {
panic!("locked mutex admitted a new owner");
};
queue.release(&value, owner);
assert!(value.try_lock().is_none());
drop(ticket);
assert!(value.try_lock().is_some());
assert_eq!(queue.waiting(), 0);
}
#[test]
fn outstanding_tickets_remain_bounded() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(0);
let owner = value.try_lock().expect("first owner");
let first_wait = WaitCell::new();
let Subscription::Waiting(first) = queue.subscribe(&value, &first_wait).unwrap() else {
panic!("locked mutex admitted a new owner");
};
let second_wait = WaitCell::new();
assert!(matches!(
queue.subscribe(&value, &second_wait),
Err(Error::Capacity { limit: 1, .. })
));
drop(first);
queue.release(&value, owner);
assert!(value.try_lock().is_some());
}
#[test]
fn selected_ticket_remains_part_of_the_wait_bound() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(0);
let owner = value.try_lock().expect("first owner");
let selected_wait = WaitCell::new();
let Subscription::Waiting(selected) = queue.subscribe(&value, &selected_wait).unwrap() else {
panic!("locked mutex admitted a new owner");
};
queue.release(&value, owner);
let rejected_wait = WaitCell::new();
assert!(matches!(
queue.subscribe(&value, &rejected_wait),
Err(Error::Capacity { limit: 1, .. })
));
drop(selected);
assert!(value.try_lock().is_some());
assert_eq!(queue.waiting(), 0);
}
#[test]
fn an_idle_ticket_can_return_ownership_before_deferred_publication() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(42);
std::thread::scope(|threads| {
let (held_tx, held_rx) = mpsc::channel();
let (unlock_tx, unlock_rx) = mpsc::channel();
let (dequeued_tx, dequeued_rx) = mpsc::channel();
let (publish_tx, publish_rx) = mpsc::channel();
*lock(&queue.after_dequeue) = Some(Box::new(move || {
let _ = dequeued_tx.send(());
let _ = publish_rx.recv();
}));
let queue = &queue;
let value = &value;
let owner = threads.spawn(move || {
let owner = value.try_lock().unwrap();
let _ = held_tx.send(());
let _ = unlock_rx.recv();
queue.release(value, owner);
});
held_rx.recv().unwrap();
let wait = WaitCell::new();
let Subscription::Waiting(ticket) = queue.subscribe(value, &wait).unwrap() else {
panic!("locked mutex admitted a new owner");
};
unlock_tx.send(()).unwrap();
dequeued_rx.recv().unwrap();
drop(ticket);
assert_eq!(queue.waiting(), 0);
assert_eq!(
*value.try_lock().expect("idle grant returned ownership"),
42
);
assert!(wait.recycle());
publish_tx.send(()).unwrap();
owner.join().unwrap();
assert_eq!(wait.take_resource(), None);
assert!(value.try_lock().is_some());
});
}
#[test]
fn unwinding_after_queue_removal_still_publishes_the_selected_handoff() {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(42);
let owner = value.try_lock().unwrap();
let wait = WaitCell::new();
let Subscription::Waiting(ticket) = queue.subscribe(&value, &wait).unwrap() else {
panic!("locked mutex admitted a new owner");
};
let hub = Arc::new(WaitHub::new(1, Arc::default()));
let WaitBegin::Park { request, .. } = wait
.begin(TaskId::new(1), TaskKey::owned(0), &hub, None)
.unwrap()
else {
panic!("expected a park")
};
*lock(&queue.after_dequeue) = Some(Box::new(|| panic!("publisher interrupted")));
assert!(
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
queue.release(&value, owner);
}))
.is_err()
);
assert_eq!(hub.pop_wake().unwrap().token, request.token());
assert!(hub.pop_wake().is_none());
drop(ticket);
assert_eq!(wait.finish(request.token()).unwrap(), WakeCause::Ready);
assert_eq!(queue.waiting(), 0);
assert_eq!(
*value.try_lock().expect("unwound grant returned ownership"),
42
);
}
#[cfg(feature = "handoff-profiling")]
#[test]
fn stored_rejected_and_still_queued_cleanup_keep_distinct_accounting() {
let local = std::rc::Rc::new(crate::local_carrier::LocalCarrier::new(
crate::RuntimeConfig::default(),
));
let hub = Arc::new(WaitHub::new(1, Arc::default()));
let _route = crate::context::mount_carrier(&hub, &local);
for case in 0..3 {
let queue = MutexQueue::new(1).unwrap();
let value = ExclusiveCell::new(42);
let owner = value.try_lock().unwrap();
let wait = WaitCell::new();
let Subscription::Waiting(ticket) = queue.subscribe(&value, &wait).unwrap() else {
panic!("must queue behind the existing owner")
};
let excess = WaitCell::new();
assert!(matches!(
queue.subscribe(&value, &excess),
Err(Error::Capacity { .. })
));
if case == 2 {
drop(ticket);
queue.release(&value, owner);
} else {
if case == 1 {
assert!(wait.close());
}
queue.release(&value, owner);
drop(ticket);
}
assert_eq!(queue.waiting(), 0);
assert_eq!(*value.try_lock().unwrap(), 42);
}
let profile = local.handoff_profile.borrow();
let counts = profile.mutex();
assert_eq!(
counts.queued(),
3,
"capacity rejection is not an admitted ticket"
);
assert_eq!(counts.dropped(), 3);
assert_eq!(counts.completed(), 0);
assert_eq!(counts.removed(), 1);
assert_eq!(counts.abandoned(), 1);
assert_eq!(counts.attempts(), 2);
assert_eq!(counts.stored(), 1);
assert_eq!(counts.rejected(), 1);
assert_eq!(counts.same_owner(), 0);
assert_eq!(counts.other_owner(), 0);
}