use super::Mutex;
use crate::{Error, Runtime, local_scope, yield_now};
use std::{
sync::{
Arc,
atomic::{AtomicU8, Ordering},
},
thread,
};
const LOCK_UNSET: u8 = 0;
const LOCK_REJECTED: u8 = 1;
const LOCK_ACQUIRED: u8 = 2;
const LOCK_UNEXPECTED: u8 = 3;
struct LockOnDrop {
mutex: Arc<Mutex<usize>>,
outcome: Arc<AtomicU8>,
}
impl Drop for LockOnDrop {
fn drop(&mut self) {
let outcome = match self.mutex.lock() {
Err(Error::SuspensionDuringPanic) => LOCK_REJECTED,
Ok(_) => LOCK_ACQUIRED,
Err(_) => LOCK_UNEXPECTED,
};
self.outcome.store(outcome, Ordering::SeqCst);
}
}
#[test]
fn single_carrier_contention_is_fifo_and_guards_can_yield() {
Runtime::new()
.unwrap()
.run_scope(|scope| {
scope
.spawn("parent", || {
let mutex = Mutex::with_wait_capacity(Vec::new(), 4).unwrap();
let guard = mutex.lock().unwrap();
local_scope(|local| {
let mut children = Vec::new();
for i in 0..4 {
let mutex = &mutex;
children.push(local.spawn("contender", move || {
let owner = thread::current().id();
let mut guard = mutex.lock().unwrap();
yield_now().unwrap();
assert_eq!(owner, thread::current().id());
guard.push(i);
})?);
while mutex.waiting() != i + 1 {
yield_now()?;
}
}
drop(guard);
assert!(matches!(mutex.try_lock(), Err(Error::WouldBlock)));
for mut child in children {
child.join()?;
}
Ok(())
})
.unwrap();
assert_eq!(*mutex.lock().unwrap(), vec![0, 1, 2, 3]);
})?
.join()
})
.unwrap();
}
#[test]
fn multiple_carriers_exclude_each_other_and_preserve_updates() {
let runtime = Runtime::builder().carriers(4).build().unwrap();
let mutex = Arc::new(Mutex::with_wait_capacity(0, 16).unwrap());
runtime
.run_scope(|scope| {
let mut children = Vec::new();
for _ in 0..16 {
let mutex = Arc::clone(&mutex);
children.push(scope.spawn("increment", move || {
for _ in 0..64 {
let mut value = mutex.lock().unwrap();
let before = *value;
yield_now().unwrap();
*value = before + 1;
}
})?);
}
for mut child in children {
child.join()?;
}
Ok(())
})
.unwrap();
assert_eq!(*mutex.try_lock().unwrap(), 1024);
}
#[test]
fn panic_unlocks_and_returns_the_modified_value_without_poisoning() {
let runtime = Runtime::new().unwrap();
let mutex = Arc::new(Mutex::with_wait_capacity(0, 1).unwrap());
runtime
.run_scope(|scope| {
let shared = Arc::clone(&mutex);
let mut task = scope.spawn("panic", move || {
*shared.lock().unwrap() = 42;
let _guard = shared.lock().unwrap();
panic!("owner failed");
})?;
assert!(matches!(task.join(), Err(Error::TaskPanicked { .. })));
Ok(())
})
.unwrap();
assert_eq!(*mutex.try_lock().unwrap(), 42);
}
#[test]
fn cancelling_a_selected_owner_hands_the_mutex_to_its_successor() {
Runtime::new()
.unwrap()
.run_scope(|scope| {
scope
.spawn("parent", || {
let mutex = Mutex::with_wait_capacity(0, 2).unwrap();
let guard = mutex.try_lock().unwrap();
local_scope(|local| {
let mut first = local.spawn("cancelled", || mutex.lock().map(drop))?;
let mut second = local.spawn("successor", || {
*mutex.lock()? = 42;
Ok::<_, Error>(())
})?;
while mutex.waiting() != 2 {
yield_now()?;
}
drop(guard);
first.cancel();
assert!(matches!(first.join()?, Err(Error::Cancelled)));
second.join()??;
Ok(())
})
.unwrap();
assert_eq!(*mutex.try_lock().unwrap(), 42);
})?
.join()
})
.unwrap();
}
#[test]
fn local_mutexes_can_protect_borrowed_non_send_values() {
use std::{cell::Cell, rc::Rc};
Runtime::new()
.unwrap()
.run_scope(|scope| {
scope
.spawn("parent", || {
let value = Rc::new(Cell::new(0));
let mutex = Mutex::with_wait_capacity(&value, 1).unwrap();
local_scope(|local| {
local
.spawn("borrower", || {
let guard = mutex.lock().unwrap();
yield_now().unwrap();
guard.set(42);
})?
.join()
})
.unwrap();
assert_eq!(value.get(), 42);
})?
.join()
})
.unwrap();
}
#[test]
fn a_panicking_handed_off_guard_releases_its_fifo_successor() {
Runtime::new()
.unwrap()
.run_scope(|scope| {
scope
.spawn("parent", || {
let mutex = Mutex::with_wait_capacity(0, 2).unwrap();
let owner = mutex.try_lock().unwrap();
local_scope(|local| {
let mut first = local.spawn("panicking successor", || {
let mut guard = mutex.lock().unwrap();
*guard = 42;
panic!("handed off owner failed");
})?;
while mutex.waiting() != 1 {
yield_now()?;
}
let mut second = local.spawn("remaining successor", || {
*mutex.lock()? += 1;
Ok::<_, Error>(())
})?;
while mutex.waiting() != 2 {
yield_now()?;
}
drop(owner);
assert!(matches!(first.join(), Err(Error::TaskPanicked { .. })));
second.join()??;
Ok(())
})
.unwrap();
assert_eq!(mutex.waiting(), 0);
assert_eq!(*mutex.try_lock().unwrap(), 43);
})?
.join()
})
.unwrap();
}
#[test]
fn contended_lock_during_unwind_rejects_before_queue_publication() {
let runtime = Runtime::builder().carriers(1).build().unwrap();
let mutex = Arc::new(Mutex::with_wait_capacity(0_usize, 1).unwrap());
let outcome = Arc::new(AtomicU8::new(LOCK_UNSET));
runtime
.run_scope(|scope| {
let owner = mutex.try_lock().unwrap();
let waiting_mutex = Arc::clone(&mutex);
let mut waiter = scope.spawn("queued mutex waiter", move || {
*waiting_mutex.lock()? += 1;
Ok::<_, Error>(())
})?;
crate::support_test::until(|| mutex.waiting() == 1);
let mut panicking = scope.spawn("panic-time mutex contender", {
let mutex = Arc::clone(&mutex);
let outcome = Arc::clone(&outcome);
move || {
let _lock_on_drop = LockOnDrop { mutex, outcome };
panic!("expected mutex contender panic");
}
})?;
assert!(matches!(panicking.join(), Err(Error::TaskPanicked { .. })));
assert_eq!(outcome.load(Ordering::SeqCst), LOCK_REJECTED);
assert_eq!(mutex.waiting(), 1);
drop(owner);
waiter.join()??;
let successor_mutex = Arc::clone(&mutex);
scope
.spawn("mutex successor", move || {
*successor_mutex.lock().unwrap() = 52;
})?
.join()?;
Ok(())
})
.unwrap();
assert_eq!(outcome.load(Ordering::SeqCst), LOCK_REJECTED);
assert_eq!(mutex.waiting(), 0);
assert_eq!(*mutex.try_lock().unwrap(), 52);
let snapshot = runtime.snapshot();
assert_eq!(
(snapshot.active, snapshot.parked, snapshot.timers),
(0, 0, 0)
);
assert!(
snapshot
.carriers
.iter()
.all(|carrier| carrier.pending_starts == 0 && carrier.pending_wakes == 0)
);
runtime.shutdown().unwrap();
}