Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
53 changes: 28 additions & 25 deletions asyncband/src/condvar/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -66,6 +66,7 @@ use std::task::Poll;
use std::task::Waker;

use crate::internal::mutex::Mutex;
use crate::internal::update_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;
use crate::internal::waker_batch::WakerBatch;
Expand Down Expand Up @@ -181,8 +182,7 @@ impl Condvar {
let mutex = mutex::guard_lock(&guard);
let notify_one_baton = Wait {
condvar: self,
guard: Some(guard),
index: None,
phase: WaitPhase::Holding(guard),
}
.await;
let guard = mutex.lock().await;
Expand All @@ -206,8 +206,7 @@ impl Condvar {
let mutex = mutex::owned_guard_lock(&guard);
let notify_one_baton = Wait {
condvar: self,
guard: Some(guard),
index: None,
phase: WaitPhase::Holding(guard),
}
.await;
let guard = mutex.lock_owned().await;
Expand Down Expand Up @@ -339,8 +338,13 @@ impl Condvar {

struct Wait<'a, G> {
condvar: &'a Condvar,
guard: Option<G>,
index: Option<WaiterId>,
phase: WaitPhase<G>,
}

enum WaitPhase<G> {
Holding(G),
Registered(WaiterId),
Done,
}

impl<'a, G> Future for Wait<'a, G>
Expand All @@ -352,26 +356,25 @@ where
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.get_mut();

if this.guard.is_some() {
let mut waiters = this.condvar.waiters.lock();
this.index = Some(waiters.push_back(WaitState::Waiting(cx.waker().clone())));
let guard = this.guard.take().unwrap();

// Registration must happen before unlocking the associated mutex. A notifier that
// acquires the mutex after this point will therefore observe this waiter.
drop(waiters);
drop(guard);
return Poll::Pending;
}

let index = this.index.expect("wait future polled after completion");
let index = match this.phase {
WaitPhase::Holding(_) => {
let index = this
.condvar
.waiters
.lock()
.push_back(WaitState::Waiting(cx.waker().clone()));
// Replacing Holding unlocks the associated mutex. A notifier that subsequently
// acquires it must already be able to find this registration.
this.phase = WaitPhase::Registered(index);
return Poll::Pending;
}
WaitPhase::Registered(index) => index,
WaitPhase::Done => panic!("wait future polled after completion"),
};
let mut waiters = this.condvar.waiters.lock();
let mut old_waker = None;
let notify_one_baton = match waiters.waiter_mut(index) {
WaitState::Waiting(waker) => {
if !waker.will_wake(cx.waker()) {
old_waker = Some(mem::replace(waker, cx.waker().clone()));
}
let old_waker = update_waker(waker, cx.waker());
drop(waiters);
drop(old_waker);
return Poll::Pending;
Expand All @@ -381,7 +384,7 @@ where
};

let waiter = waiters.remove_unlinked_waiter(index);
this.index = None;
this.phase = WaitPhase::Done;
drop(waiters);
drop(waiter);
Poll::Ready(notify_one_baton)
Expand All @@ -390,7 +393,7 @@ where

impl<G> Drop for Wait<'_, G> {
fn drop(&mut self) {
let Some(index) = self.index.take() else {
let WaitPhase::Registered(index) = self.phase else {
return;
};

Expand Down
7 changes: 2 additions & 5 deletions asyncband/src/event/auto_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@ use std::task::Waker;

use crate::event::Waiter;
use crate::internal::mutex::Mutex;
use crate::internal::update_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;

Expand Down Expand Up @@ -216,11 +217,7 @@ impl AutoResetEvent {
*waiter_id = None;
(Poll::Ready(()), None)
}
Waiter::Waiting(waker) => {
let retired = (!waker.will_wake(cx.waker()))
.then(|| mem::replace(waker, cx.waker().clone()));
(Poll::Pending, retired)
}
Waiter::Waiting(waker) => (Poll::Pending, update_waker(waker, cx.waker())),
},
None if state.is_set => {
state.is_set = false;
Expand Down
6 changes: 2 additions & 4 deletions asyncband/src/event/manual_reset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,6 @@

use std::fmt;
use std::future::Future;
use std::mem;
use std::pin::Pin;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
Expand All @@ -27,6 +26,7 @@ use std::task::Poll;

use crate::event::Waiter;
use crate::internal::mutex::Mutex;
use crate::internal::update_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;
use crate::internal::waker_batch::WakerBatch;
Expand Down Expand Up @@ -234,9 +234,7 @@ impl ManualResetEvent {
!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)
(Poll::Pending, update_waker(waker, cx.waker()))
}
},
// A set after the false fast probe must either be observed here or release
Expand Down
22 changes: 15 additions & 7 deletions asyncband/src/internal/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -15,21 +15,29 @@
// specific language governing permissions and limitations
// under the License.

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

/// Refreshes an occupied registration unless both wakers are known to wake the same task.
#[inline]
#[must_use = "drop the replaced waker after releasing the state lock"]
pub fn update_waker(current: &mut Waker, waker: &Waker) -> Option<Waker> {
if current.will_wake(waker) {
None
} else {
Some(mem::replace(current, waker.clone()))
}
}

/// Retains the current task waker, returning any replaced registration for unlocked destruction.
#[inline]
#[must_use = "drop the replaced waker after releasing the state lock"]
// Some feature subsets have no primitive that registers a single waker slot.
#[allow(dead_code)]
pub fn register_waker(slot: &mut Option<Waker>, waker: &Waker) -> Option<Waker> {
if slot
.as_ref()
.is_some_and(|current| current.will_wake(waker))
{
None
} else {
slot.replace(waker.clone())
match slot {
Some(current) => update_waker(current, waker),
None => slot.replace(waker.clone()),
}
}

Expand Down
6 changes: 2 additions & 4 deletions asyncband/src/internal/retry_waiter.rs
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@
use std::mem;
use std::task::Waker;

use crate::internal::update_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;

Expand Down Expand Up @@ -47,10 +48,7 @@ impl WaitList<RetryWaiter> {
pub fn register(&mut self, id: &mut Option<WaiterId>, current: &Waker) -> Option<Waker> {
if let Some(queued) = *id {
if let RetryWaiter::Waiting(waker) = self.waiter_mut(queued) {
if waker.will_wake(current) {
return None;
}
return Some(mem::replace(waker, current.clone()));
return update_waker(waker, current);
}
}
if let Some(notified) = id.take() {
Expand Down
44 changes: 28 additions & 16 deletions asyncband/src/internal/semaphore.rs
Original file line number Diff line number Diff line change
Expand Up @@ -279,31 +279,43 @@ pub struct Acquire<'a> {
impl Drop for Acquire<'_> {
fn drop(&mut self) {
if let Some(id) = self.waiter_id.take() {
let mut waiters = self.semaphore.waiters.lock();
let waiter = waiters.remove(id);
let acquired = self.requested_permits - waiter.needed_permits;
if acquired > 0 {
self.semaphore.distribute_permits(acquired, waiters);
} else {
drop(waiters);
}
drop(waiter);
self.semaphore.cancel_acquire(self.requested_permits, id);
}
}
}

impl Acquire<'_> {
pub fn poll_once(&mut self, waker: &Waker) -> Poll<()> {
let Self {
requested_permits,
waiter_id,
semaphore,
} = self;
self.semaphore
.poll_acquire(self.requested_permits, &mut self.waiter_id, waker)
}
}

impl Semaphore {
/// Cancels a queued acquisition and returns any permits already assigned to it.
pub fn cancel_acquire(&self, requested: usize, id: WaiterId) {
let mut waiters = self.waiters.lock();
let waiter = waiters.remove(id);
let acquired = requested - waiter.needed_permits;
if acquired > 0 {
self.distribute_permits(acquired, waiters);
} else {
drop(waiters);
}
drop(waiter);
}

/// Reuse the same count and registration until ready or cancelled.
pub fn poll_acquire(
&self,
requested: usize,
waiter_id: &mut Option<WaiterId>,
waker: &Waker,
) -> Poll<()> {
let mut old_waker = None;
match waiter_id {
Some(id) => {
let mut waiters = semaphore.waiters.lock();
let mut waiters = self.waiters.lock();
let ready = {
let node = waiters.waiter_mut(*id);
if node.needed_permits > 0 {
Expand All @@ -321,7 +333,7 @@ impl Acquire<'_> {
}
None => {
let request = PermitRequest::Acquire { waiter_id, waker };
if acquire_or_enqueue(semaphore, *requested_permits, request) {
if acquire_or_enqueue(self, requested, request) {
return Poll::Ready(());
}
}
Expand Down
8 changes: 2 additions & 6 deletions asyncband/src/internal/wakerset.rs
Original file line number Diff line number Diff line change
Expand Up @@ -21,11 +21,11 @@
//! their tokens must be cleared rather than passed back to the set. Returned wakers must be woken
//! or dropped after releasing the lock.

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

use crate::internal::arena::Arena;
use crate::internal::arena::SlotId;
use crate::internal::update_waker;
use crate::internal::waker_batch::WakerBatch;

/// An exclusive handle to one waker slot in a [`WakerSet`].
Expand Down Expand Up @@ -94,11 +94,7 @@ impl WakerSet {
.wakers
.get_mut(token.0)
.expect("waker token must refer to an occupied slot");
if current.will_wake(waker) {
None
} else {
Some(mem::replace(current, waker.clone()))
}
update_waker(current, waker)
}

/// Removes and returns the waker identified by `token`.
Expand Down
6 changes: 2 additions & 4 deletions asyncband/src/mpmc/queue.rs
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ use std::task::Waker;

use crate::internal::mutex::Mutex;
use crate::internal::retry_waiter::RetryWaiter;
use crate::internal::update_waker;
use crate::internal::waitlist::WaitList;
use crate::internal::waitlist::WaiterId;
use crate::mpmc::RecvError;
Expand Down Expand Up @@ -114,10 +115,7 @@ impl WaitList<SendWaiter> {
let SendWaiter::Waiting(waker) = self.waiter_mut(queued) else {
unreachable!("a granted waiter must be claimed before registration");
};
if waker.will_wake(current) {
return None;
}
return Some(mem::replace(waker, current.clone()));
return update_waker(waker, current);
}
*id = Some(self.push_back(SendWaiter::Waiting(current.clone())));
None
Expand Down
9 changes: 4 additions & 5 deletions asyncband/src/mpsc/bounded/sender.rs
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@ use std::task::Context;
use std::task::Poll;

use crate::internal::mutex::Mutex;
use crate::internal::update_waker;
use crate::internal::waitlist::WaiterId;
use crate::mpsc::SendError;
use crate::mpsc::TrySendError;
Expand Down Expand Up @@ -283,11 +284,9 @@ impl<'a, T> Reserve<'a, T> {
if let Some(index) = self.waiter {
let waiter = state.send_waiters.waiter_mut(index);
if let Waiter::Waiting(waker) = waiter {
if !waker.will_wake(cx.waker()) {
let old = mem::replace(waker, cx.waker().clone());
drop(state);
drop(old);
}
let old = update_waker(waker, cx.waker());
drop(state);
drop(old);
return Poll::Pending;
}
state.send_waiters.remove_unlinked_waiter(index);
Expand Down
15 changes: 7 additions & 8 deletions asyncband/src/once/once_map/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,7 @@
// under the License.

use std::borrow::Borrow;
use std::convert::Infallible;
use std::fmt;
use std::hash::BuildHasher;
use std::hash::Hash;
Expand Down Expand Up @@ -313,14 +314,12 @@ where
where
F: AsyncFnOnce() -> V,
{
let guard = match self.get_or_insert(key) {
Lookup::Ready(value) => return value,
Lookup::Pending(guard) => guard,
};

let result = guard.entry().cell.get_or_init(func).await.clone();
guard.dismiss();
result
match self
.try_compute(key, async || Ok::<V, Infallible>(func().await))
.await
{
Ok(value) => value,
}
}

/// Returns a clone of the stored or newly computed value for `key`.
Expand Down
Loading
Loading