Skip to content
11 changes: 2 additions & 9 deletions asyncband/src/event/auto_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@ use std::task::Context;
use std::task::Poll;
use std::task::Waker;

use crate::event::Waiter;
use crate::internal::mutex::Mutex;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;
Expand Down Expand Up @@ -278,22 +279,14 @@ struct State {
impl State {
fn signal(&mut self) -> Option<Waker> {
if let Some((_, waiter)) = self.waiters.unlink_first_waiter(|_| true) {
let Waiter::Waiting(waker) = mem::replace(waiter, Waiter::Notified) else {
unreachable!("only unselected waits remain queued")
};
Some(waker)
Some(waiter.mark_notified())
} else {
self.is_set = true;
None
}
}
}

enum Waiter {
Waiting(Waker),
Notified,
}

#[must_use = "futures do nothing unless you `.await` or poll them"]
struct Wait<'a> {
event: &'a AutoResetEvent,
Expand Down
55 changes: 22 additions & 33 deletions asyncband/src/event/manual_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,16 +17,16 @@

use std::fmt;
use std::future::Future;
use std::mem;
use std::pin::Pin;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::task::Context;
use std::task::Poll;
use std::task::Waker;

use crate::event::Waiter;
use crate::internal::mutex::Mutex;
use crate::internal::register_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;
use crate::internal::waker_batch::WakerBatch;
Expand Down Expand Up @@ -110,13 +110,8 @@ impl ManualResetEvent {
self.is_set.store(true, Ordering::Release);
// Detach the complete cohort before invoking any waker. A wake callback may reset the
// event and register a new wait, which must belong to the state current at that point.
while let Some((_id, waiter)) = waiters.unlink_first_waiter(|waiter| {
waiter.notified = true;
true
}) {
if let Some(waker) = waiter.waker.take() {
wakers.push(waker);
}
while let Some((_, waiter)) = waiters.unlink_first_waiter(|_| true) {
wakers.push(waiter.mark_notified());
}
}
wakers.wake_all();
Expand Down Expand Up @@ -218,7 +213,7 @@ impl ManualResetEvent {
///
/// `set` unlinks every queued waiter and marks it notified, and a wait that starts while the
/// event is set never enqueues. A linked waiter therefore always belongs to an unset event, so
/// `notified` alone decides whether a registered waiter is already committed.
/// a notified waiter remains ready even if the event is reset.
fn poll_wait(&self, waiter_id: &mut Option<WaiterId>, cx: &mut Context<'_>) -> Poll<()> {
// Only an unregistered wait can skip the lock: a released waiter still owns a node.
if waiter_id.is_none() && self.is_set() {
Expand All @@ -228,27 +223,27 @@ impl ManualResetEvent {
let (poll, retired_waker) = {
let mut waiters = self.waiters.lock();
match *waiter_id {
Some(id) if waiters.waiter_mut(id).notified => {
let waiter = waiters.remove_unlinked_waiter(id);
*waiter_id = None;
(Poll::Ready(()), waiter.waker)
}
Some(id) => {
debug_assert!(
!self.is_set.load(Ordering::Relaxed),
"a linked waiter must belong to an unset event"
);
let waiter = waiters.waiter_mut(id);
(Poll::Pending, register_waker(&mut waiter.waker, cx.waker()))
}
Some(id) => match waiters.waiter_mut(id) {
Waiter::Notified => {
waiters.remove_unlinked_waiter(id);
*waiter_id = None;
(Poll::Ready(()), None)
}
Waiter::Waiting(waker) => {
debug_assert!(
!self.is_set.load(Ordering::Relaxed),
"a linked waiter must belong to an unset event"
);
let retired = (!waker.will_wake(cx.waker()))
.then(|| mem::replace(waker, cx.waker().clone()));
(Poll::Pending, retired)
}
},
// A set after the false fast probe must either be observed here or release
// the node that we register while holding this same lock.
None if self.is_set.load(Ordering::Relaxed) => (Poll::Ready(()), None),
None => {
*waiter_id = Some(waiters.push_back(Waiter {
notified: false,
waker: Some(cx.waker().clone()),
}));
*waiter_id = Some(waiters.push_back(Waiter::Waiting(cx.waker().clone())));
(Poll::Pending, None)
}
}
Expand Down Expand Up @@ -283,12 +278,6 @@ impl fmt::Debug for ManualResetEvent {
}
}

#[derive(Debug)]
struct Waiter {
notified: bool,
waker: Option<Waker>,
}

#[must_use = "futures do nothing unless you `.await` or poll them"]
struct Wait<'a> {
event: &'a ManualResetEvent,
Expand Down
17 changes: 17 additions & 0 deletions asyncband/src/event/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -31,5 +31,22 @@
mod auto_reset;
mod manual_reset;

use std::mem;
use std::task::Waker;

pub use self::auto_reset::AutoResetEvent;
pub use self::manual_reset::ManualResetEvent;

enum Waiter {
Waiting(Waker),
Notified,
}

impl Waiter {
fn mark_notified(&mut self) -> Waker {
let Self::Waiting(waker) = mem::replace(self, Self::Notified) else {
unreachable!("only waiting nodes remain queued");
};
waker
}
}
34 changes: 30 additions & 4 deletions asyncband/src/internal/value_cell.rs
Original file line number Diff line number Diff line change
Expand Up @@ -97,12 +97,16 @@ impl<T> ValueCell<T> {
}

pub fn write_mut(&mut self, value: T) -> &mut T {
if *self.published.get_mut() {
// SAFETY: `published` indicates an initialized value in `slot`.
let published = self.published.get_mut();
if *published {
*published = false;
// SAFETY: The slot held a live value. Clear the flag before dropping it so an
// unwinding destructor leaves the cell empty.
unsafe { self.slot.get_mut().assume_init_drop() };
}
*self.published.get_mut() = true;
self.slot.get_mut().write(value)
let stored = self.slot.get_mut().write(value);
*published = true;
stored
}

pub fn take(&mut self) -> Option<T> {
Expand Down Expand Up @@ -136,6 +140,8 @@ impl<T> Drop for ValueCell<T> {
#[cfg(test)]
mod tests {
use std::cell::Cell;
use std::panic::AssertUnwindSafe;
use std::panic::catch_unwind;
use std::thread;

use super::*;
Expand Down Expand Up @@ -217,4 +223,24 @@ mod tests {
drop(cell);
assert_eq!(drops.get(), 4);
}

#[test]
fn overwrite_leaves_cell_empty_if_dropping_the_old_value_panics() {
struct PanicOnDrop;

impl Drop for PanicOnDrop {
fn drop(&mut self) {
panic!("old value dropped");
}
}

// Only drop the cell after verifying that it no longer claims to own the old value.
let mut cell = ManuallyDrop::new(ValueCell::with_value(Some(PanicOnDrop)));
let result = catch_unwind(AssertUnwindSafe(|| {
cell.write_mut(None);
}));
assert!(result.is_err());
assert!(!cell.is_published());
drop(ManuallyDrop::into_inner(cell));
}
}
11 changes: 3 additions & 8 deletions asyncband/src/once/lazy_cell/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -408,10 +408,7 @@ where
initializer()
};

// SAFETY: The current variant contains no structurally pinned future, and its initializer
// slot is empty. The newly created future is written directly into its final pinned
// location before it is polled.
*unsafe { state.as_mut().get_unchecked_mut() } = State::Attempt(future);
state.set(State::Attempt(future));
}

let value = poll_fn(|cx| {
Expand All @@ -427,11 +424,9 @@ where
})
.await;

// Assignment drops the completed future in place before changing the phase. Treat a panic
// from that destructor as an initializer panic as well.
// A panic while dropping the completed future also poisons the cell.
let _poison = PoisonOnPanic(poisoned);
// SAFETY: Dropping a pinned value in place is permitted, and no value is moved out.
*unsafe { state.as_mut().get_unchecked_mut() } = State::Complete;
state.set(State::Complete);
value
}

Expand Down
16 changes: 8 additions & 8 deletions asyncband/src/phaser/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -419,16 +419,16 @@ impl Drop for PhaserParticipants {
#[derive(Debug)]
pub struct PhaserParticipant {
phaser: Phaser,
// Cleared only after advancement, so a pending current phase also records arrival.
pending: Option<u64>,
// Retain the arrival across cancellation so a retry can observe the same phase.
arrived_phase: Option<u64>,
registered: bool,
}

impl PhaserParticipant {
fn new(phaser: Phaser) -> Self {
Self {
phaser,
pending: None,
arrived_phase: None,
registered: true,
}
}
Expand All @@ -453,10 +453,10 @@ impl PhaserParticipant {
return Err(Closed(()));
}
let phase = state.phase;
if self.pending != Some(phase) {
if self.arrived_phase != Some(phase) {
state.unarrived -= 1;
}
self.pending = Some(phase);
self.arrived_phase = Some(phase);
let mut wakers = state.advance_if_ready();
drop(state);
wakers.wake_all();
Expand All @@ -480,12 +480,12 @@ impl PhaserParticipant {
/// the pending observation, so retrying this method waits for the same phase without
/// counting another arrival. An explicit new `arrive` replaces that pending observation.
pub async fn wait(&mut self) -> Result<u64, Closed> {
let observed = match self.pending {
let observed = match self.arrived_phase {
Some(phase) => phase,
None => self.arrive()?,
};
let next = self.phaser.wait(observed).await?;
self.pending = None;
self.arrived_phase = None;
Ok(next)
}

Expand All @@ -506,7 +506,7 @@ impl PhaserParticipant {
let mut state = self.phaser.state.lock();
self.registered = false;
state.registered -= 1;
if self.pending != Some(state.phase) {
if self.arrived_phase != Some(state.phase) {
state.unarrived -= 1;
}
let result = if state.closed {
Expand Down
52 changes: 25 additions & 27 deletions asyncband/src/watch/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -74,6 +74,7 @@ use std::task::Poll;
pub use self::error::RecvError;
pub use self::error::SendError;
use crate::internal::mutex::Mutex;
use crate::internal::waker_batch::WakerBatch;
use crate::internal::wakerset::WakerSet;
use crate::internal::wakerset::WakerToken;

Expand Down Expand Up @@ -118,6 +119,19 @@ struct State<T> {
waiters: WakerSet,
}

impl<T> State<T> {
// Leave the old value with the caller so it can be dropped after unlocking. Borrowing the
// input also keeps its destructor outside the lock if the version counter overflows.
fn publish(&mut self, value: &mut T) -> WakerBatch {
self.version = self
.version
.checked_add(1)
.expect("watch channel version counter overflowed");
mem::swap(&mut self.value, value);
self.waiters.take_all()
}
}

/// The sending side of a watch channel.
pub struct Sender<T> {
shared: Arc<Shared<T>>,
Expand Down Expand Up @@ -168,23 +182,15 @@ impl<T> Sender<T> {
/// # Panics
///
/// Panics if the channel has already published `u64::MAX` updates.
pub fn send(&self, value: T) -> Result<(), SendError<T>> {
let mut state = self.shared.state.lock();
if state.receivers == 0 {
return Err(SendError::new(value));
}
let version = state
.version
.checked_add(1)
.expect("watch channel version counter overflowed");
let replaced = mem::replace(&mut state.value, value);
state.version = version;
let mut wakers = state.waiters.take_all();
drop(state);

// Waker callbacks and the replaced value's destructor may reenter this channel.
pub fn send(&self, mut value: T) -> Result<(), SendError<T>> {
let mut wakers = {
let mut state = self.shared.state.lock();
if state.receivers == 0 {
return Err(SendError::new(value));
}
state.publish(&mut value)
};
wakers.wake_all();
drop(replaced);
Ok(())
}

Expand All @@ -196,18 +202,10 @@ impl<T> Sender<T> {
/// # Panics
///
/// Panics if the channel has already published `u64::MAX` updates.
pub fn send_replace(&self, value: T) -> T {
let mut state = self.shared.state.lock();
let version = state
.version
.checked_add(1)
.expect("watch channel version counter overflowed");
let replaced = mem::replace(&mut state.value, value);
state.version = version;
let mut wakers = state.waiters.take_all();
drop(state);
pub fn send_replace(&self, mut value: T) -> T {
let mut wakers = self.shared.state.lock().publish(&mut value);
wakers.wake_all();
replaced
value
}

/// Creates a receiver that considers the current value already observed.
Expand Down
Loading
Loading