Rework ConcurrencyLimit to use upstream tokio Semaphore (#451)
This commit is contained in:
parent
a0a66b10a2
commit
98e0e41db1
|
@ -55,7 +55,7 @@ hdrhistogram = { version = "6.0", optional = true }
|
||||||
indexmap = { version = "1.0.2", optional = true }
|
indexmap = { version = "1.0.2", optional = true }
|
||||||
rand = { version = "0.7", features = ["small_rng"], optional = true }
|
rand = { version = "0.7", features = ["small_rng"], optional = true }
|
||||||
slab = { version = "0.4", optional = true }
|
slab = { version = "0.4", optional = true }
|
||||||
tokio = { version = "0.2", optional = true }
|
tokio = { version = "0.2", optional = true, features = ["sync"] }
|
||||||
|
|
||||||
[dev-dependencies]
|
[dev-dependencies]
|
||||||
futures-util = { version = "0.3", default-features = false, features = ["alloc", "async-await"] }
|
futures-util = { version = "0.3", default-features = false, features = ["alloc", "async-await"] }
|
||||||
|
|
|
@ -1,27 +1,27 @@
|
||||||
//! Future types
|
//! Future types
|
||||||
//!
|
//!
|
||||||
use super::sync::semaphore::Semaphore;
|
|
||||||
use futures_core::ready;
|
use futures_core::ready;
|
||||||
use pin_project::{pin_project, pinned_drop};
|
use pin_project::pin_project;
|
||||||
use std::sync::Arc;
|
|
||||||
use std::{
|
use std::{
|
||||||
future::Future,
|
future::Future,
|
||||||
pin::Pin,
|
pin::Pin,
|
||||||
task::{Context, Poll},
|
task::{Context, Poll},
|
||||||
};
|
};
|
||||||
|
use tokio::sync::OwnedSemaphorePermit;
|
||||||
|
|
||||||
/// Future for the `ConcurrencyLimit` service.
|
/// Future for the `ConcurrencyLimit` service.
|
||||||
#[pin_project(PinnedDrop)]
|
#[pin_project]
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct ResponseFuture<T> {
|
pub struct ResponseFuture<T> {
|
||||||
#[pin]
|
#[pin]
|
||||||
inner: T,
|
inner: T,
|
||||||
semaphore: Arc<Semaphore>,
|
// Keep this around so that it is dropped when the future completes
|
||||||
|
_permit: OwnedSemaphorePermit,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> ResponseFuture<T> {
|
impl<T> ResponseFuture<T> {
|
||||||
pub(crate) fn new(inner: T, semaphore: Arc<Semaphore>) -> ResponseFuture<T> {
|
pub(crate) fn new(inner: T, _permit: OwnedSemaphorePermit) -> ResponseFuture<T> {
|
||||||
ResponseFuture { inner, semaphore }
|
ResponseFuture { inner, _permit }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -35,10 +35,3 @@ where
|
||||||
Poll::Ready(ready!(self.project().inner.poll(cx)))
|
Poll::Ready(ready!(self.project().inner.poll(cx)))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[pinned_drop]
|
|
||||||
impl<T> PinnedDrop for ResponseFuture<T> {
|
|
||||||
fn drop(self: Pin<&mut Self>) {
|
|
||||||
self.project().semaphore.add_permits(1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -3,6 +3,5 @@
|
||||||
pub mod future;
|
pub mod future;
|
||||||
mod layer;
|
mod layer;
|
||||||
mod service;
|
mod service;
|
||||||
mod sync;
|
|
||||||
|
|
||||||
pub use self::{layer::ConcurrencyLimitLayer, service::ConcurrencyLimit};
|
pub use self::{layer::ConcurrencyLimitLayer, service::ConcurrencyLimit};
|
||||||
|
|
|
@ -2,34 +2,38 @@ use super::future::ResponseFuture;
|
||||||
|
|
||||||
use tower_service::Service;
|
use tower_service::Service;
|
||||||
|
|
||||||
use super::sync::semaphore::{self, Semaphore};
|
|
||||||
use futures_core::ready;
|
use futures_core::ready;
|
||||||
|
use std::fmt;
|
||||||
|
use std::future::Future;
|
||||||
|
use std::mem;
|
||||||
|
use std::pin::Pin;
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::task::{Context, Poll};
|
use std::task::{Context, Poll};
|
||||||
|
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
|
||||||
|
|
||||||
/// Enforces a limit on the concurrent number of requests the underlying
|
/// Enforces a limit on the concurrent number of requests the underlying
|
||||||
/// service can handle.
|
/// service can handle.
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct ConcurrencyLimit<T> {
|
pub struct ConcurrencyLimit<T> {
|
||||||
inner: T,
|
inner: T,
|
||||||
limit: Limit,
|
semaphore: Arc<Semaphore>,
|
||||||
|
state: State,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug)]
|
enum State {
|
||||||
struct Limit {
|
Waiting(Pin<Box<dyn Future<Output = OwnedSemaphorePermit> + Send + 'static>>),
|
||||||
semaphore: Arc<Semaphore>,
|
Ready(OwnedSemaphorePermit),
|
||||||
permit: semaphore::Permit,
|
Empty,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> ConcurrencyLimit<T> {
|
impl<T> ConcurrencyLimit<T> {
|
||||||
/// Create a new concurrency limiter.
|
/// Create a new concurrency limiter.
|
||||||
pub fn new(inner: T, max: usize) -> Self {
|
pub fn new(inner: T, max: usize) -> Self {
|
||||||
|
let semaphore = Arc::new(Semaphore::new(max));
|
||||||
ConcurrencyLimit {
|
ConcurrencyLimit {
|
||||||
inner,
|
inner,
|
||||||
limit: Limit {
|
semaphore,
|
||||||
semaphore: Arc::new(Semaphore::new(max)),
|
state: State::Empty,
|
||||||
permit: semaphore::Permit::new(),
|
|
||||||
},
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -58,31 +62,32 @@ where
|
||||||
type Future = ResponseFuture<S::Future>;
|
type Future = ResponseFuture<S::Future>;
|
||||||
|
|
||||||
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
||||||
ready!(self.limit.permit.poll_acquire(cx, &self.limit.semaphore))
|
loop {
|
||||||
.expect("poll_acquire after semaphore closed ");
|
self.state = match self.state {
|
||||||
|
State::Ready(_) => return self.inner.poll_ready(cx),
|
||||||
Poll::Ready(ready!(self.inner.poll_ready(cx)))
|
State::Waiting(ref mut fut) => {
|
||||||
|
tokio::pin!(fut);
|
||||||
|
let permit = ready!(fut.poll(cx));
|
||||||
|
State::Ready(permit)
|
||||||
|
}
|
||||||
|
State::Empty => State::Waiting(Box::pin(self.semaphore.clone().acquire_owned())),
|
||||||
|
};
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn call(&mut self, request: Request) -> Self::Future {
|
fn call(&mut self, request: Request) -> Self::Future {
|
||||||
// Make sure a permit has been acquired
|
// Make sure a permit has been acquired
|
||||||
if self
|
let permit = match mem::replace(&mut self.state, State::Empty) {
|
||||||
.limit
|
// Take the permit.
|
||||||
.permit
|
State::Ready(permit) => permit,
|
||||||
.try_acquire(&self.limit.semaphore)
|
// whoopsie!
|
||||||
.is_err()
|
_ => panic!("max requests in-flight; poll_ready must be called first"),
|
||||||
{
|
};
|
||||||
panic!("max requests in-flight; poll_ready must be called first");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Call the inner service
|
// Call the inner service
|
||||||
let future = self.inner.call(request);
|
let future = self.inner.call(request);
|
||||||
|
|
||||||
// Forget the permit, the permit will be returned when
|
ResponseFuture::new(future, permit)
|
||||||
// `future::ResponseFuture` is dropped.
|
|
||||||
self.limit.permit.forget();
|
|
||||||
|
|
||||||
ResponseFuture::new(future, self.limit.semaphore.clone())
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -104,16 +109,21 @@ where
|
||||||
fn clone(&self) -> ConcurrencyLimit<S> {
|
fn clone(&self) -> ConcurrencyLimit<S> {
|
||||||
ConcurrencyLimit {
|
ConcurrencyLimit {
|
||||||
inner: self.inner.clone(),
|
inner: self.inner.clone(),
|
||||||
limit: Limit {
|
semaphore: self.semaphore.clone(),
|
||||||
semaphore: self.limit.semaphore.clone(),
|
state: State::Empty,
|
||||||
permit: semaphore::Permit::new(),
|
|
||||||
},
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Drop for Limit {
|
impl fmt::Debug for State {
|
||||||
fn drop(&mut self) {
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
self.permit.release(&self.semaphore);
|
match self {
|
||||||
|
State::Waiting(_) => f
|
||||||
|
.debug_tuple("State::Waiting")
|
||||||
|
.field(&format_args!("..."))
|
||||||
|
.finish(),
|
||||||
|
State::Ready(ref r) => f.debug_tuple("State::Ready").field(&r).finish(),
|
||||||
|
State::Empty => f.debug_tuple("State::Empty").finish(),
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,51 +0,0 @@
|
||||||
#![allow(dead_code)]
|
|
||||||
|
|
||||||
use std::cell::UnsafeCell;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub(crate) struct CausalCell<T>(UnsafeCell<T>);
|
|
||||||
|
|
||||||
#[derive(Default)]
|
|
||||||
pub(crate) struct CausalCheck(());
|
|
||||||
|
|
||||||
impl<T> CausalCell<T> {
|
|
||||||
pub(crate) fn new(data: T) -> CausalCell<T> {
|
|
||||||
CausalCell(UnsafeCell::new(data))
|
|
||||||
}
|
|
||||||
|
|
||||||
pub(crate) fn with<F, R>(&self, f: F) -> R
|
|
||||||
where
|
|
||||||
F: FnOnce(*const T) -> R,
|
|
||||||
{
|
|
||||||
f(self.0.get())
|
|
||||||
}
|
|
||||||
|
|
||||||
pub(crate) fn with_unchecked<F, R>(&self, f: F) -> R
|
|
||||||
where
|
|
||||||
F: FnOnce(*const T) -> R,
|
|
||||||
{
|
|
||||||
f(self.0.get())
|
|
||||||
}
|
|
||||||
|
|
||||||
pub(crate) fn check(&self) {}
|
|
||||||
|
|
||||||
pub(crate) fn with_deferred<F, R>(&self, f: F) -> (R, CausalCheck)
|
|
||||||
where
|
|
||||||
F: FnOnce(*const T) -> R,
|
|
||||||
{
|
|
||||||
(f(self.0.get()), CausalCheck::default())
|
|
||||||
}
|
|
||||||
|
|
||||||
pub(crate) fn with_mut<F, R>(&self, f: F) -> R
|
|
||||||
where
|
|
||||||
F: FnOnce(*mut T) -> R,
|
|
||||||
{
|
|
||||||
f(self.0.get())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CausalCheck {
|
|
||||||
pub(crate) fn check(self) {}
|
|
||||||
|
|
||||||
pub(crate) fn join(&mut self, _other: CausalCheck) {}
|
|
||||||
}
|
|
|
@ -1,7 +0,0 @@
|
||||||
// Vendored `tokio/src/sync/semaphore.rs` and `tokio/src/sync/task/atomic_waker.rs`
|
|
||||||
// Commit sha: 24cd6d67f76f122f67cbbb101d555018fc27820b
|
|
||||||
|
|
||||||
mod cell;
|
|
||||||
mod waker;
|
|
||||||
|
|
||||||
pub(super) mod semaphore;
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,316 +0,0 @@
|
||||||
use super::cell::CausalCell;
|
|
||||||
use std::sync::atomic::{self, AtomicUsize};
|
|
||||||
|
|
||||||
use std::fmt;
|
|
||||||
use std::sync::atomic::Ordering::{AcqRel, Acquire, Release};
|
|
||||||
use std::task::Waker;
|
|
||||||
|
|
||||||
/// A synchronization primitive for task waking.
|
|
||||||
///
|
|
||||||
/// `AtomicWaker` will coordinate concurrent wakes with the consumer
|
|
||||||
/// potentially "waking" the underlying task. This is useful in scenarios
|
|
||||||
/// where a computation completes in another thread and wants to wake the
|
|
||||||
/// consumer, but the consumer is in the process of being migrated to a new
|
|
||||||
/// logical task.
|
|
||||||
///
|
|
||||||
/// Consumers should call `register` before checking the result of a computation
|
|
||||||
/// and producers should call `wake` after producing the computation (this
|
|
||||||
/// differs from the usual `thread::park` pattern). It is also permitted for
|
|
||||||
/// `wake` to be called **before** `register`. This results in a no-op.
|
|
||||||
///
|
|
||||||
/// A single `AtomicWaker` may be reused for any number of calls to `register` or
|
|
||||||
/// `wake`.
|
|
||||||
pub(crate) struct AtomicWaker {
|
|
||||||
state: AtomicUsize,
|
|
||||||
waker: CausalCell<Option<Waker>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
// `AtomicWaker` is a multi-consumer, single-producer transfer cell. The cell
|
|
||||||
// stores a `Waker` value produced by calls to `register` and many threads can
|
|
||||||
// race to take the waker by calling `wake.
|
|
||||||
//
|
|
||||||
// If a new `Waker` instance is produced by calling `register` before an existing
|
|
||||||
// one is consumed, then the existing one is overwritten.
|
|
||||||
//
|
|
||||||
// While `AtomicWaker` is single-producer, the implementation ensures memory
|
|
||||||
// safety. In the event of concurrent calls to `register`, there will be a
|
|
||||||
// single winner whose waker will get stored in the cell. The losers will not
|
|
||||||
// have their tasks woken. As such, callers should ensure to add synchronization
|
|
||||||
// to calls to `register`.
|
|
||||||
//
|
|
||||||
// The implementation uses a single `AtomicUsize` value to coordinate access to
|
|
||||||
// the `Waker` cell. There are two bits that are operated on independently. These
|
|
||||||
// are represented by `REGISTERING` and `WAKING`.
|
|
||||||
//
|
|
||||||
// The `REGISTERING` bit is set when a producer enters the critical section. The
|
|
||||||
// `WAKING` bit is set when a consumer enters the critical section. Neither
|
|
||||||
// bit being set is represented by `WAITING`.
|
|
||||||
//
|
|
||||||
// A thread obtains an exclusive lock on the waker cell by transitioning the
|
|
||||||
// state from `WAITING` to `REGISTERING` or `WAKING`, depending on the
|
|
||||||
// operation the thread wishes to perform. When this transition is made, it is
|
|
||||||
// guaranteed that no other thread will access the waker cell.
|
|
||||||
//
|
|
||||||
// # Registering
|
|
||||||
//
|
|
||||||
// On a call to `register`, an attempt to transition the state from WAITING to
|
|
||||||
// REGISTERING is made. On success, the caller obtains a lock on the waker cell.
|
|
||||||
//
|
|
||||||
// If the lock is obtained, then the thread sets the waker cell to the waker
|
|
||||||
// provided as an argument. Then it attempts to transition the state back from
|
|
||||||
// `REGISTERING` -> `WAITING`.
|
|
||||||
//
|
|
||||||
// If this transition is successful, then the registering process is complete
|
|
||||||
// and the next call to `wake` will observe the waker.
|
|
||||||
//
|
|
||||||
// If the transition fails, then there was a concurrent call to `wake` that
|
|
||||||
// was unable to access the waker cell (due to the registering thread holding the
|
|
||||||
// lock). To handle this, the registering thread removes the waker it just set
|
|
||||||
// from the cell and calls `wake` on it. This call to wake represents the
|
|
||||||
// attempt to wake by the other thread (that set the `WAKING` bit). The
|
|
||||||
// state is then transitioned from `REGISTERING | WAKING` back to `WAITING`.
|
|
||||||
// This transition must succeed because, at this point, the state cannot be
|
|
||||||
// transitioned by another thread.
|
|
||||||
//
|
|
||||||
// # Waking
|
|
||||||
//
|
|
||||||
// On a call to `wake`, an attempt to transition the state from `WAITING` to
|
|
||||||
// `WAKING` is made. On success, the caller obtains a lock on the waker cell.
|
|
||||||
//
|
|
||||||
// If the lock is obtained, then the thread takes ownership of the current value
|
|
||||||
// in the waker cell, and calls `wake` on it. The state is then transitioned
|
|
||||||
// back to `WAITING`. This transition must succeed as, at this point, the state
|
|
||||||
// cannot be transitioned by another thread.
|
|
||||||
//
|
|
||||||
// If the thread is unable to obtain the lock, the `WAKING` bit is still.
|
|
||||||
// This is because it has either been set by the current thread but the previous
|
|
||||||
// value included the `REGISTERING` bit **or** a concurrent thread is in the
|
|
||||||
// `WAKING` critical section. Either way, no action must be taken.
|
|
||||||
//
|
|
||||||
// If the current thread is the only concurrent call to `wake` and another
|
|
||||||
// thread is in the `register` critical section, when the other thread **exits**
|
|
||||||
// the `register` critical section, it will observe the `WAKING` bit and
|
|
||||||
// handle the waker itself.
|
|
||||||
//
|
|
||||||
// If another thread is in the `waker` critical section, then it will handle
|
|
||||||
// waking the caller task.
|
|
||||||
//
|
|
||||||
// # A potential race (is safely handled).
|
|
||||||
//
|
|
||||||
// Imagine the following situation:
|
|
||||||
//
|
|
||||||
// * Thread A obtains the `wake` lock and wakes a task.
|
|
||||||
//
|
|
||||||
// * Before thread A releases the `wake` lock, the woken task is scheduled.
|
|
||||||
//
|
|
||||||
// * Thread B attempts to wake the task. In theory this should result in the
|
|
||||||
// task being woken, but it cannot because thread A still holds the wake
|
|
||||||
// lock.
|
|
||||||
//
|
|
||||||
// This case is handled by requiring users of `AtomicWaker` to call `register`
|
|
||||||
// **before** attempting to observe the application state change that resulted
|
|
||||||
// in the task being woken. The wakers also change the application state
|
|
||||||
// before calling wake.
|
|
||||||
//
|
|
||||||
// Because of this, the task will do one of two things.
|
|
||||||
//
|
|
||||||
// 1) Observe the application state change that Thread B is waking on. In
|
|
||||||
// this case, it is OK for Thread B's wake to be lost.
|
|
||||||
//
|
|
||||||
// 2) Call register before attempting to observe the application state. Since
|
|
||||||
// Thread A still holds the `wake` lock, the call to `register` will result
|
|
||||||
// in the task waking itself and get scheduled again.
|
|
||||||
|
|
||||||
/// Idle state
|
|
||||||
const WAITING: usize = 0;
|
|
||||||
|
|
||||||
/// A new waker value is being registered with the `AtomicWaker` cell.
|
|
||||||
const REGISTERING: usize = 0b01;
|
|
||||||
|
|
||||||
/// The task currently registered with the `AtomicWaker` cell is being woken.
|
|
||||||
const WAKING: usize = 0b10;
|
|
||||||
|
|
||||||
impl AtomicWaker {
|
|
||||||
/// Create an `AtomicWaker`
|
|
||||||
pub(crate) fn new() -> AtomicWaker {
|
|
||||||
AtomicWaker {
|
|
||||||
state: AtomicUsize::new(WAITING),
|
|
||||||
waker: CausalCell::new(None),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Registers the current waker to be notified on calls to `wake`.
|
|
||||||
///
|
|
||||||
/// This is the same as calling `register_task` with `task::current()`.
|
|
||||||
#[cfg(feature = "io-driver")]
|
|
||||||
pub(crate) fn register(&self, waker: Waker) {
|
|
||||||
self.do_register(waker);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Registers the provided waker to be notified on calls to `wake`.
|
|
||||||
///
|
|
||||||
/// The new waker will take place of any previous wakers that were registered
|
|
||||||
/// by previous calls to `register`. Any calls to `wake` that happen after
|
|
||||||
/// a call to `register` (as defined by the memory ordering rules), will
|
|
||||||
/// wake the `register` caller's task.
|
|
||||||
///
|
|
||||||
/// It is safe to call `register` with multiple other threads concurrently
|
|
||||||
/// calling `wake`. This will result in the `register` caller's current
|
|
||||||
/// task being woken once.
|
|
||||||
///
|
|
||||||
/// This function is safe to call concurrently, but this is generally a bad
|
|
||||||
/// idea. Concurrent calls to `register` will attempt to register different
|
|
||||||
/// tasks to be woken. One of the callers will win and have its task set,
|
|
||||||
/// but there is no guarantee as to which caller will succeed.
|
|
||||||
pub(crate) fn register_by_ref(&self, waker: &Waker) {
|
|
||||||
self.do_register(waker);
|
|
||||||
}
|
|
||||||
|
|
||||||
fn do_register<W>(&self, waker: W)
|
|
||||||
where
|
|
||||||
W: WakerRef,
|
|
||||||
{
|
|
||||||
match self.state.compare_and_swap(WAITING, REGISTERING, Acquire) {
|
|
||||||
WAITING => {
|
|
||||||
unsafe {
|
|
||||||
// Locked acquired, update the waker cell
|
|
||||||
self.waker.with_mut(|t| *t = Some(waker.into_waker()));
|
|
||||||
|
|
||||||
// Release the lock. If the state transitioned to include
|
|
||||||
// the `WAKING` bit, this means that a wake has been
|
|
||||||
// called concurrently, so we have to remove the waker and
|
|
||||||
// wake it.`
|
|
||||||
//
|
|
||||||
// Start by assuming that the state is `REGISTERING` as this
|
|
||||||
// is what we jut set it to.
|
|
||||||
let res = self
|
|
||||||
.state
|
|
||||||
.compare_exchange(REGISTERING, WAITING, AcqRel, Acquire);
|
|
||||||
|
|
||||||
match res {
|
|
||||||
Ok(_) => {}
|
|
||||||
Err(actual) => {
|
|
||||||
// This branch can only be reached if a
|
|
||||||
// concurrent thread called `wake`. In this
|
|
||||||
// case, `actual` **must** be `REGISTERING |
|
|
||||||
// `WAKING`.
|
|
||||||
debug_assert_eq!(actual, REGISTERING | WAKING);
|
|
||||||
|
|
||||||
// Take the waker to wake once the atomic operation has
|
|
||||||
// completed.
|
|
||||||
let waker = self.waker.with_mut(|t| (*t).take()).unwrap();
|
|
||||||
|
|
||||||
// Just swap, because no one could change state
|
|
||||||
// while state == `Registering | `Waking`
|
|
||||||
self.state.swap(WAITING, AcqRel);
|
|
||||||
|
|
||||||
// The atomic swap was complete, now
|
|
||||||
// wake the waker and return.
|
|
||||||
waker.wake();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
WAKING => {
|
|
||||||
// Currently in the process of waking the task, i.e.,
|
|
||||||
// `wake` is currently being called on the old waker.
|
|
||||||
// So, we call wake on the new waker.
|
|
||||||
waker.wake();
|
|
||||||
|
|
||||||
// This is equivalent to a spin lock, so use a spin hint.
|
|
||||||
atomic::spin_loop_hint();
|
|
||||||
}
|
|
||||||
state => {
|
|
||||||
// In this case, a concurrent thread is holding the
|
|
||||||
// "registering" lock. This probably indicates a bug in the
|
|
||||||
// caller's code as racing to call `register` doesn't make much
|
|
||||||
// sense.
|
|
||||||
//
|
|
||||||
// We just want to maintain memory safety. It is ok to drop the
|
|
||||||
// call to `register`.
|
|
||||||
debug_assert!(state == REGISTERING || state == REGISTERING | WAKING);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Wakes the task that last called `register`.
|
|
||||||
///
|
|
||||||
/// If `register` has not been called yet, then this does nothing.
|
|
||||||
pub(crate) fn wake(&self) {
|
|
||||||
if let Some(waker) = self.take_waker() {
|
|
||||||
waker.wake();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Attempts to take the `Waker` value out of the `AtomicWaker` with the
|
|
||||||
/// intention that the caller will wake the task later.
|
|
||||||
pub(crate) fn take_waker(&self) -> Option<Waker> {
|
|
||||||
// AcqRel ordering is used in order to acquire the value of the `waker`
|
|
||||||
// cell as well as to establish a `release` ordering with whatever
|
|
||||||
// memory the `AtomicWaker` is associated with.
|
|
||||||
match self.state.fetch_or(WAKING, AcqRel) {
|
|
||||||
WAITING => {
|
|
||||||
// The waking lock has been acquired.
|
|
||||||
let waker = unsafe { self.waker.with_mut(|t| (*t).take()) };
|
|
||||||
|
|
||||||
// Release the lock
|
|
||||||
self.state.fetch_and(!WAKING, Release);
|
|
||||||
|
|
||||||
waker
|
|
||||||
}
|
|
||||||
state => {
|
|
||||||
// There is a concurrent thread currently updating the
|
|
||||||
// associated waker.
|
|
||||||
//
|
|
||||||
// Nothing more to do as the `WAKING` bit has been set. It
|
|
||||||
// doesn't matter if there are concurrent registering threads or
|
|
||||||
// not.
|
|
||||||
//
|
|
||||||
debug_assert!(
|
|
||||||
state == REGISTERING || state == REGISTERING | WAKING || state == WAKING
|
|
||||||
);
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for AtomicWaker {
|
|
||||||
fn default() -> Self {
|
|
||||||
AtomicWaker::new()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Debug for AtomicWaker {
|
|
||||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
write!(fmt, "AtomicWaker")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
unsafe impl Send for AtomicWaker {}
|
|
||||||
unsafe impl Sync for AtomicWaker {}
|
|
||||||
|
|
||||||
trait WakerRef {
|
|
||||||
fn wake(self);
|
|
||||||
fn into_waker(self) -> Waker;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl WakerRef for Waker {
|
|
||||||
fn wake(self) {
|
|
||||||
self.wake()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_waker(self) -> Waker {
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl WakerRef for &Waker {
|
|
||||||
fn wake(self) {
|
|
||||||
self.wake_by_ref()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn into_waker(self) -> Waker {
|
|
||||||
self.clone()
|
|
||||||
}
|
|
||||||
}
|
|
Loading…
Reference in New Issue