use std::sync::{Arc, PoisonError};
#[cfg(loom)]
use loom::sync::{Condvar, Mutex};
#[cfg(not(loom))]
use std::sync::{Condvar, Mutex};
use crate::sync::{AtomicU64, Ordering};
const LIVE: u64 = 0;
const RECYCLED: u64 = 1;
const RELEASED: u64 = 2;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Retired {
Recycled,
Released,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Retire {
Recycle,
Release,
}
#[derive(Debug)]
pub(crate) struct Gate {
active: AtomicU64,
state: AtomicU64,
lock: Mutex<()>,
idle: Condvar,
}
#[must_use]
pub(crate) struct Pass<'a> {
gate: &'a Gate,
}
impl Drop for Pass<'_> {
fn drop(&mut self) {
self.gate.leave();
}
}
pub(crate) trait Gated {
fn gate(&self) -> &Gate;
}
impl Gated for Gate {
fn gate(&self) -> &Gate {
self
}
}
#[must_use]
pub(crate) struct OwnedPass<T: Gated> {
held: Arc<T>,
}
impl<T: Gated> OwnedPass<T> {
pub(crate) fn enter(held: &Arc<T>) -> Result<Self, Retired> {
held.gate().admit()?;
Ok(Self {
held: Arc::clone(held),
})
}
pub(crate) fn get(&self) -> &Arc<T> {
&self.held
}
}
impl<T: Gated> Drop for OwnedPass<T> {
fn drop(&mut self) {
self.held.gate().leave();
}
}
fn retired(state: u64) -> Retired {
if state == RELEASED {
Retired::Released
} else {
Retired::Recycled
}
}
impl Gate {
pub(crate) fn new() -> Self {
Self {
active: AtomicU64::new(0),
state: AtomicU64::new(LIVE),
lock: Mutex::new(()),
idle: Condvar::new(),
}
}
pub(crate) fn enter(&self) -> Result<Pass<'_>, Retired> {
self.admit()?;
Ok(Pass { gate: self })
}
fn admit(&self) -> Result<(), Retired> {
let _was = self.active.fetch_add(1, Ordering::AcqRel);
match self.state.fetch_add(0, Ordering::AcqRel) {
LIVE => Ok(()),
s => {
self.leave();
Err(retired(s))
}
}
}
pub(crate) fn check(&self) -> Result<(), Retired> {
match self.state.load(Ordering::SeqCst) {
LIVE => Ok(()),
s => Err(retired(s)),
}
}
fn leave(&self) {
if self.active.fetch_sub(1, Ordering::AcqRel) == 1
&& self.state.fetch_add(0, Ordering::AcqRel) != LIVE
{
let _guard = self.lock.lock().unwrap_or_else(PoisonError::into_inner);
self.idle.notify_all();
}
}
pub(crate) fn retire(&self, how: Retire) -> Result<(), Retired> {
let to = match how {
Retire::Recycle => RECYCLED,
Retire::Release => RELEASED,
};
let _was_live = self
.state
.compare_exchange(LIVE, to, Ordering::AcqRel, Ordering::Acquire)
.map_err(retired)?;
let mut guard = self.lock.lock().unwrap_or_else(PoisonError::into_inner);
while self.active.fetch_add(0, Ordering::AcqRel) != 0 {
guard = self
.idle
.wait(guard)
.unwrap_or_else(PoisonError::into_inner);
}
Ok(())
}
pub(crate) fn restore(&self) {
self.state.store(LIVE, Ordering::SeqCst);
}
}
#[cfg(all(test, not(loom)))]
mod tests {
use super::*;
use std::sync::Arc;
#[test]
fn test_retire_waits_for_every_pass_and_refuses_new_ones() {
let gate = Arc::new(Gate::new());
let pass = gate.enter();
assert!(pass.is_ok());
let retirer = {
let gate = Arc::clone(&gate);
std::thread::spawn(move || gate.retire(Retire::Recycle))
};
while gate.check().is_ok() {
std::thread::yield_now();
}
assert_eq!(gate.enter().err(), Some(Retired::Recycled));
std::thread::sleep(std::time::Duration::from_millis(50));
assert!(!retirer.is_finished(), "retire returned with a pass held");
drop(pass);
assert_eq!(retirer.join().ok(), Some(Ok(())));
assert_eq!(gate.retire(Retire::Release), Err(Retired::Recycled));
gate.restore();
assert!(gate.enter().is_ok());
}
#[test]
fn test_an_owned_pass_holds_a_retirement_until_dropped() {
let gate = Arc::new(Gate::new());
let pass = OwnedPass::enter(&gate);
assert!(pass.is_ok());
let retirer = {
let gate = Arc::clone(&gate);
std::thread::spawn(move || gate.retire(Retire::Release))
};
while gate.check().is_ok() {
std::thread::yield_now();
}
assert!(OwnedPass::enter(&gate).is_err());
std::thread::sleep(std::time::Duration::from_millis(50));
assert!(
!retirer.is_finished(),
"retire returned with an owned pass held"
);
drop(pass);
assert_eq!(retirer.join().ok(), Some(Ok(())));
}
#[test]
fn test_released_gate_reports_release() {
let gate = Gate::new();
assert_eq!(gate.retire(Retire::Release), Ok(()));
assert_eq!(gate.enter().err(), Some(Retired::Released));
assert_eq!(gate.check(), Err(Retired::Released));
}
}
#[cfg(all(test, loom))]
mod loom_tests {
use super::*;
use loom::sync::Arc;
use loom::sync::atomic::AtomicBool;
#[test]
fn loom_no_operation_outlives_a_retirement() {
loom::model(|| {
let gate = Arc::new(Gate::new());
let retired = Arc::new(AtomicBool::new(false));
let op = {
let gate = Arc::clone(&gate);
let retired = Arc::clone(&retired);
loom::thread::spawn(move || {
if let Ok(pass) = gate.enter() {
assert!(!retired.load(Ordering::SeqCst), "ran after retirement");
drop(pass);
}
})
};
if gate.retire(Retire::Recycle).is_ok() {
retired.store(true, Ordering::SeqCst);
}
let _joined = op.join();
});
}
#[test]
fn loom_no_owned_pass_outlives_a_retirement() {
loom::model(|| {
let gate = std::sync::Arc::new(Gate::new());
let retired = Arc::new(AtomicBool::new(false));
let op = {
let gate = std::sync::Arc::clone(&gate);
let retired = Arc::clone(&retired);
loom::thread::spawn(move || {
let admitted = OwnedPass::enter(&gate);
let finisher = loom::thread::spawn(move || {
if let Ok(pass) = admitted {
assert!(!retired.load(Ordering::SeqCst), "ran after retirement");
drop(pass);
}
});
let _joined = finisher.join();
})
};
if gate.retire(Retire::Recycle).is_ok() {
retired.store(true, Ordering::SeqCst);
}
let _joined = op.join();
});
}
}