Skip to content
Merged
3 changes: 1 addition & 2 deletions asyncband/src/condvar/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -396,8 +396,7 @@ impl<G> Drop for Wait<'_, G> {

let (waiter, waker) = {
let mut waiters = self.condvar.waiters.lock();
waiters.unlink_waiter(index, |_| true);
let waiter = waiters.remove_unlinked_waiter(index);
let waiter = waiters.remove(index);

let waker = match &waiter {
WaitState::NotifiedOne => notify_one_locked(&mut waiters),
Expand Down
3 changes: 1 addition & 2 deletions asyncband/src/event/auto_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -239,8 +239,7 @@ impl AutoResetEvent {
let (waiter, waker) = {
let mut state = self.state.lock();
// A selected waiter is already detached, but still owns its signal until removal.
state.waiters.unlink_waiter(id, |_| true);
let waiter = state.waiters.remove_unlinked_waiter(id);
let waiter = state.waiters.remove(id);
let waker = match &waiter {
Waiter::Notified => state.signal(),
Waiter::Waiting(_) => None,
Expand Down
3 changes: 1 addition & 2 deletions asyncband/src/event/manual_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -262,8 +262,7 @@ impl ManualResetEvent {
let waiter = {
let mut waiters = self.waiters.lock();
// Released waits retain their detached nodes until repolled or cancelled.
waiters.unlink_waiter(id, |_| true);
waiters.remove_unlinked_waiter(id)
waiters.remove(id)
};
drop(waiter);
}
Expand Down
2 changes: 0 additions & 2 deletions asyncband/src/internal/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -83,8 +83,6 @@ pub(crate) mod value_cell;
pub(crate) mod mutex;

#[cfg(feature = "waitgroup")]
// Some primitives use only exclusive access, leaving `read` and `get_mut` unused.
#[allow(dead_code)]
pub(crate) mod rwlock;

#[cfg(any(
Expand Down
8 changes: 0 additions & 8 deletions asyncband/src/internal/rwlock.rs
Original file line number Diff line number Diff line change
Expand Up @@ -31,15 +31,7 @@ impl<T> RwLock<T> {
Self(std::sync::RwLock::new(t))
}

pub fn read(&self) -> std::sync::RwLockReadGuard<'_, T> {
self.0.read().unwrap_or_else(PoisonError::into_inner)
}

pub fn write(&self) -> std::sync::RwLockWriteGuard<'_, T> {
self.0.write().unwrap_or_else(PoisonError::into_inner)
}

pub fn get_mut(&mut self) -> &mut T {
self.0.get_mut().unwrap_or_else(PoisonError::into_inner)
}
}
88 changes: 41 additions & 47 deletions asyncband/src/internal/semaphore.rs
Original file line number Diff line number Diff line change
Expand Up @@ -123,14 +123,14 @@ impl Semaphore {
///
/// If fewer than `n` permits are available, a queue-head debt node consumes future releases.
pub fn reduce_permits(&self, n: usize) {
acquired_or_enqueue(self, n, None, None, false);
acquire_or_enqueue(self, n, PermitRequest::Debt);
}

/// Returns a future that acquires `n` permits from the semaphore.
pub fn acquire(&self, n: usize) -> Acquire<'_> {
Acquire {
requested_permits: n,
index: None,
waiter_id: None,
semaphore: self,
}
}
Expand Down Expand Up @@ -272,21 +272,16 @@ impl Semaphore {
#[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct Acquire<'a> {
requested_permits: usize,
index: Option<WaiterId>,
waiter_id: Option<WaiterId>,
semaphore: &'a Semaphore,
}

impl Drop for Acquire<'_> {
fn drop(&mut self) {
if let Some(index) = self.index.take() {
if let Some(id) = self.waiter_id.take() {
let mut waiters = self.semaphore.waiters.lock();
let mut acquired = 0;
waiters.unlink_waiter(index, |node| {
acquired = self.requested_permits - node.needed_permits;
node.needed_permits = 0;
true
});
let waiter = waiters.remove_unlinked_waiter(index);
let waiter = waiters.remove(id);
let acquired = self.requested_permits - waiter.needed_permits;
if acquired > 0 {
self.semaphore.distribute_permits(acquired, waiters);
} else {
Expand All @@ -301,16 +296,16 @@ impl Acquire<'_> {
pub fn poll_once(&mut self, waker: &Waker) -> Poll<()> {
let Self {
requested_permits,
index,
waiter_id,
semaphore,
} = self;

let mut old_waker = None;
match index {
Some(idx) => {
match waiter_id {
Some(id) => {
let mut waiters = semaphore.waiters.lock();
let ready = {
let node = waiters.waiter_mut(*idx);
let node = waiters.waiter_mut(*id);
if node.needed_permits > 0 {
old_waker = register_waker(&mut node.waker, waker);
false
Expand All @@ -319,15 +314,14 @@ impl Acquire<'_> {
}
};
if ready {
waiters.remove_unlinked_waiter(*idx);
*index = None;
waiters.remove_unlinked_waiter(*id);
*waiter_id = None;
return Poll::Ready(());
}
}
None => {
let requested = *requested_permits;

if acquired_or_enqueue(semaphore, requested, Some(index), Some(waker), true) {
let request = PermitRequest::Acquire { waiter_id, waker };
if acquire_or_enqueue(semaphore, *requested_permits, request) {
return Poll::Ready(());
}
}
Expand All @@ -347,19 +341,16 @@ impl Future for Acquire<'_> {
}
}

/// Returns `true` if successfully acquired the semaphore; `false` otherwise.
fn acquired_or_enqueue(
sem: &Semaphore,
requested: usize,
index: Option<&mut Option<WaiterId>>,
waker: Option<&Waker>,
enqueue_last: bool,
) -> bool {
assert_eq!(
index.is_some(),
waker.is_some(),
"only acquire waiters have a future owner"
);
enum PermitRequest<'a> {
Debt,
Acquire {
waiter_id: &'a mut Option<WaiterId>,
waker: &'a Waker,
},
}

/// Returns true when all permits were available and no node was queued.
fn acquire_or_enqueue(sem: &Semaphore, requested: usize, request: PermitRequest<'_>) -> bool {
let mut available = sem.available_permits.load(Ordering::Acquire);
let mut lock = None;

Expand Down Expand Up @@ -396,20 +387,23 @@ fn acquired_or_enqueue(
unreachable!("lock must be acquired when needed {needed} > 0");
});

let node = WaitNode {
needed_permits: needed,
waker: waker.cloned(),
};
let id = if enqueue_last {
waiters.push_back(node)
} else {
waiters.push_front(node)
};
if let Some(index) = index {
assert!(
index.replace(id).is_none(),
"waiter must not be registered twice"
);
match request {
PermitRequest::Debt => {
waiters.push_front(WaitNode {
needed_permits: needed,
waker: None,
});
}
PermitRequest::Acquire { waiter_id, waker } => {
let id = waiters.push_back(WaitNode {
needed_permits: needed,
waker: Some(waker.clone()),
});
assert!(
waiter_id.replace(id).is_none(),
"waiter must not be registered twice"
);
}
}

return false;
Expand Down
8 changes: 7 additions & 1 deletion asyncband/src/internal/waitlist.rs
Original file line number Diff line number Diff line change
Expand Up @@ -100,7 +100,7 @@ impl<T> WaitList<T> {
/// The node and its value remain available until
/// [`remove_unlinked_waiter`](Self::remove_unlinked_waiter) is called. If the waiter is already
/// detached, the predicate still runs but the list links are unchanged.
pub fn unlink_waiter(
fn unlink_waiter(
&mut self,
id: WaiterId,
should_unlink: impl FnOnce(&mut T) -> bool,
Expand Down Expand Up @@ -150,6 +150,12 @@ impl<T> WaitList<T> {
&mut self.node_mut(id).value
}

/// Removes a waiter by ID, whether it is still linked or already detached.
pub fn remove(&mut self, id: WaiterId) -> T {
self.unlink_waiter(id, |_| true);
self.remove_unlinked_waiter(id)
}

pub fn remove_unlinked_waiter(&mut self, id: WaiterId) -> T {
assert!(
self.node(id).links.is_none(),
Expand Down
17 changes: 4 additions & 13 deletions asyncband/src/mpmc/queue.rs
Original file line number Diff line number Diff line change
Expand Up @@ -111,12 +111,6 @@ enum SendWaiter {
Granted,
}

fn remove_waiter<W>(waiters: &mut WaitList<W>, id: WaiterId) -> W {
// Unlinking is idempotent, so detached waiters are removed the same way as linked ones.
waiters.unlink_waiter(id, |_| true);
waiters.remove_unlinked_waiter(id)
}

impl WaitList<RecvWaiter> {
fn notify_one(&mut self) -> Option<Waker> {
let (_, waiter) = self.unlink_first_waiter(|_| true)?;
Expand All @@ -141,7 +135,7 @@ impl WaitList<RecvWaiter> {
}
if let Some(notified) = id.take() {
// The notification already took this node's waker, so nothing is retired.
remove_waiter(self, notified);
self.remove_unlinked_waiter(notified);
}
*id = Some(self.push_back(RecvWaiter::Waiting(current.clone())));
None
Expand Down Expand Up @@ -428,7 +422,7 @@ impl<T> Drop for Reserve<'_, T> {
if state.receivers == 0 {
return;
}
let retired = remove_waiter(&mut state.send_waiters, id);
let retired = state.send_waiters.remove(id);
// A grant already owns a slot, so returning it does not require a capacity check.
let waker = if matches!(retired, SendWaiter::Granted) {
state.release()
Expand Down Expand Up @@ -466,10 +460,7 @@ impl<T> Recv<'_, T> {
return Poll::Pending;
}
};
let retired = self
.waiter
.take()
.map(|id| remove_waiter(&mut state.recv_waiters, id));
let retired = self.waiter.take().map(|id| state.recv_waiters.remove(id));
drop(state);
let result = outcome.map(|(value, waker)| {
if let Some(waker) = waker {
Expand All @@ -492,7 +483,7 @@ impl<T> Drop for Recv<'_, T> {
if state.senders == 0 {
return;
}
let retired = remove_waiter(&mut state.recv_waiters, id);
let retired = state.recv_waiters.remove(id);
// Hand an unconsumed notification to the next receiver while a value still waits.
let waker = if matches!(retired, RecvWaiter::Notified) && !state.values.is_empty() {
state.recv_waiters.notify_one()
Expand Down
13 changes: 8 additions & 5 deletions asyncband/src/mpsc/bounded/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@
//! Bounded multi-producer, single-consumer channel with capacity backpressure.

use std::collections::VecDeque;
use std::mem;
use std::sync::Arc;
use std::task::Waker;

Expand Down Expand Up @@ -98,15 +99,17 @@ impl<T> State<T> {
}
if let Some((_, waiter)) = self.send_waiters.unlink_first_waiter(|_| true) {
// The detached node owns capacity until its future claims or cancels the grant.
waiter.grant = true;
return waiter.waker.take();
let Waiter::Waiting(waker) = mem::replace(waiter, Waiter::Granted) else {
unreachable!("only waiting senders remain linked");
};
return Some(waker);
}
self.available += 1;
None
}
}

struct Waiter {
grant: bool,
waker: Option<Waker>,
enum Waiter {
Waiting(Waker),
Granted,
}
10 changes: 6 additions & 4 deletions asyncband/src/mpsc/bounded/receiver.rs
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,7 @@ use crate::internal::waitlist::WaitList;
use crate::mpsc::RecvError;
use crate::mpsc::TryRecvError;
use crate::mpsc::bounded::State;
use crate::mpsc::bounded::Waiter;

/// The receiving endpoint of a bounded mpsc channel.
///
Expand Down Expand Up @@ -55,10 +56,11 @@ impl<T> Drop for BoundedReceiver<T> {
(queue, recv_waker, waiters)
};
// Notify blocked senders before destroying buffered values, whose destructors may panic.
while let Some((_, waiter)) = waiters.unlink_first_waiter(|_| true) {
if let Some(waker) = waiter.waker.take() {
waker.wake();
}
while let Some((id, _)) = waiters.unlink_first_waiter(|_| true) {
let Waiter::Waiting(waker) = waiters.remove_unlinked_waiter(id) else {
unreachable!("only waiting senders remain linked");
};
waker.wake();
}
drop(recv_waker);
drop(queue);
Expand Down
Loading
Loading