forked from mirror/async-std
Merge branch 'master' into fix_doc_test
k-nasa
5 years ago
commit
d30603affe
@ -1,380 +0,0 @@
|
|||||||
use std::fmt;
|
|
||||||
use std::sync::{Arc, Mutex};
|
|
||||||
|
|
||||||
use mio::{self, Evented};
|
|
||||||
use once_cell::sync::Lazy;
|
|
||||||
use slab::Slab;
|
|
||||||
|
|
||||||
use crate::io;
|
|
||||||
use crate::task::{Context, Poll, Waker};
|
|
||||||
use crate::utils::abort_on_panic;
|
|
||||||
|
|
||||||
/// Data associated with a registered I/O handle.
|
|
||||||
#[derive(Debug)]
|
|
||||||
struct Entry {
|
|
||||||
/// A unique identifier.
|
|
||||||
token: mio::Token,
|
|
||||||
|
|
||||||
/// Tasks that are blocked on reading from this I/O handle.
|
|
||||||
readers: Mutex<Readers>,
|
|
||||||
|
|
||||||
/// Thasks that are blocked on writing to this I/O handle.
|
|
||||||
writers: Mutex<Writers>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The set of `Waker`s interested in read readiness.
|
|
||||||
#[derive(Debug)]
|
|
||||||
struct Readers {
|
|
||||||
/// Flag indicating read readiness.
|
|
||||||
/// (cf. `Watcher::poll_read_ready`)
|
|
||||||
ready: bool,
|
|
||||||
/// The `Waker`s blocked on reading.
|
|
||||||
wakers: Vec<Waker>
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The set of `Waker`s interested in write readiness.
|
|
||||||
#[derive(Debug)]
|
|
||||||
struct Writers {
|
|
||||||
/// Flag indicating write readiness.
|
|
||||||
/// (cf. `Watcher::poll_write_ready`)
|
|
||||||
ready: bool,
|
|
||||||
/// The `Waker`s blocked on writing.
|
|
||||||
wakers: Vec<Waker>
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The state of a networking driver.
|
|
||||||
struct Reactor {
|
|
||||||
/// A mio instance that polls for new events.
|
|
||||||
poller: mio::Poll,
|
|
||||||
|
|
||||||
/// A collection of registered I/O handles.
|
|
||||||
entries: Mutex<Slab<Arc<Entry>>>,
|
|
||||||
|
|
||||||
/// Dummy I/O handle that is only used to wake up the polling thread.
|
|
||||||
notify_reg: (mio::Registration, mio::SetReadiness),
|
|
||||||
|
|
||||||
/// An identifier for the notification handle.
|
|
||||||
notify_token: mio::Token,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Reactor {
|
|
||||||
/// Creates a new reactor for polling I/O events.
|
|
||||||
fn new() -> io::Result<Reactor> {
|
|
||||||
let poller = mio::Poll::new()?;
|
|
||||||
let notify_reg = mio::Registration::new2();
|
|
||||||
|
|
||||||
let mut reactor = Reactor {
|
|
||||||
poller,
|
|
||||||
entries: Mutex::new(Slab::new()),
|
|
||||||
notify_reg,
|
|
||||||
notify_token: mio::Token(0),
|
|
||||||
};
|
|
||||||
|
|
||||||
// Register a dummy I/O handle for waking up the polling thread.
|
|
||||||
let entry = reactor.register(&reactor.notify_reg.0)?;
|
|
||||||
reactor.notify_token = entry.token;
|
|
||||||
|
|
||||||
Ok(reactor)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Registers an I/O event source and returns its associated entry.
|
|
||||||
fn register(&self, source: &dyn Evented) -> io::Result<Arc<Entry>> {
|
|
||||||
let mut entries = self.entries.lock().unwrap();
|
|
||||||
|
|
||||||
// Reserve a vacant spot in the slab and use its key as the token value.
|
|
||||||
let vacant = entries.vacant_entry();
|
|
||||||
let token = mio::Token(vacant.key());
|
|
||||||
|
|
||||||
// Allocate an entry and insert it into the slab.
|
|
||||||
let entry = Arc::new(Entry {
|
|
||||||
token,
|
|
||||||
readers: Mutex::new(Readers { ready: false, wakers: Vec::new() }),
|
|
||||||
writers: Mutex::new(Writers { ready: false, wakers: Vec::new() }),
|
|
||||||
});
|
|
||||||
vacant.insert(entry.clone());
|
|
||||||
|
|
||||||
// Register the I/O event source in the poller.
|
|
||||||
let interest = mio::Ready::all();
|
|
||||||
let opts = mio::PollOpt::edge();
|
|
||||||
self.poller.register(source, token, interest, opts)?;
|
|
||||||
|
|
||||||
Ok(entry)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Deregisters an I/O event source associated with an entry.
|
|
||||||
fn deregister(&self, source: &dyn Evented, entry: &Entry) -> io::Result<()> {
|
|
||||||
// Deregister the I/O object from the mio instance.
|
|
||||||
self.poller.deregister(source)?;
|
|
||||||
|
|
||||||
// Remove the entry associated with the I/O object.
|
|
||||||
self.entries.lock().unwrap().remove(entry.token.0);
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
|
|
||||||
// fn notify(&self) {
|
|
||||||
// self.notify_reg
|
|
||||||
// .1
|
|
||||||
// .set_readiness(mio::Ready::readable())
|
|
||||||
// .unwrap();
|
|
||||||
// }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The state of the global networking driver.
|
|
||||||
static REACTOR: Lazy<Reactor> = Lazy::new(|| {
|
|
||||||
// Spawn a thread that waits on the poller for new events and wakes up tasks blocked on I/O
|
|
||||||
// handles.
|
|
||||||
std::thread::Builder::new()
|
|
||||||
.name("async-std/net".to_string())
|
|
||||||
.spawn(move || {
|
|
||||||
// If the driver thread panics, there's not much we can do. It is not a
|
|
||||||
// recoverable error and there is no place to propagate it into so we just abort.
|
|
||||||
abort_on_panic(|| {
|
|
||||||
main_loop().expect("async networking thread has panicked");
|
|
||||||
})
|
|
||||||
})
|
|
||||||
.expect("cannot start a thread driving blocking tasks");
|
|
||||||
|
|
||||||
Reactor::new().expect("cannot initialize reactor")
|
|
||||||
});
|
|
||||||
|
|
||||||
/// Waits on the poller for new events and wakes up tasks blocked on I/O handles.
|
|
||||||
fn main_loop() -> io::Result<()> {
|
|
||||||
let reactor = &REACTOR;
|
|
||||||
let mut events = mio::Events::with_capacity(1000);
|
|
||||||
|
|
||||||
loop {
|
|
||||||
// Block on the poller until at least one new event comes in.
|
|
||||||
reactor.poller.poll(&mut events, None)?;
|
|
||||||
|
|
||||||
// Lock the entire entry table while we're processing new events.
|
|
||||||
let entries = reactor.entries.lock().unwrap();
|
|
||||||
|
|
||||||
for event in events.iter() {
|
|
||||||
let token = event.token();
|
|
||||||
|
|
||||||
if token == reactor.notify_token {
|
|
||||||
// If this is the notification token, we just need the notification state.
|
|
||||||
reactor.notify_reg.1.set_readiness(mio::Ready::empty())?;
|
|
||||||
} else {
|
|
||||||
// Otherwise, look for the entry associated with this token.
|
|
||||||
if let Some(entry) = entries.get(token.0) {
|
|
||||||
// Set the readiness flags from this I/O event.
|
|
||||||
let readiness = event.readiness();
|
|
||||||
|
|
||||||
// Wake up reader tasks blocked on this I/O handle.
|
|
||||||
if !(readiness & reader_interests()).is_empty() {
|
|
||||||
let mut readers = entry.readers.lock().unwrap();
|
|
||||||
readers.ready = true;
|
|
||||||
for w in readers.wakers.drain(..) {
|
|
||||||
w.wake();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Wake up writer tasks blocked on this I/O handle.
|
|
||||||
if !(readiness & writer_interests()).is_empty() {
|
|
||||||
let mut writers = entry.writers.lock().unwrap();
|
|
||||||
writers.ready = true;
|
|
||||||
for w in writers.wakers.drain(..) {
|
|
||||||
w.wake();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// An I/O handle powered by the networking driver.
|
|
||||||
///
|
|
||||||
/// This handle wraps an I/O event source and exposes a "futurized" interface on top of it,
|
|
||||||
/// implementing traits `AsyncRead` and `AsyncWrite`.
|
|
||||||
pub struct Watcher<T: Evented> {
|
|
||||||
/// Data associated with the I/O handle.
|
|
||||||
entry: Arc<Entry>,
|
|
||||||
|
|
||||||
/// The I/O event source.
|
|
||||||
source: Option<T>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Evented> Watcher<T> {
|
|
||||||
/// Creates a new I/O handle.
|
|
||||||
///
|
|
||||||
/// The provided I/O event source will be kept registered inside the reactor's poller for the
|
|
||||||
/// lifetime of the returned I/O handle.
|
|
||||||
pub fn new(source: T) -> Watcher<T> {
|
|
||||||
Watcher {
|
|
||||||
entry: REACTOR
|
|
||||||
.register(&source)
|
|
||||||
.expect("cannot register an I/O event source"),
|
|
||||||
source: Some(source),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a reference to the inner I/O event source.
|
|
||||||
pub fn get_ref(&self) -> &T {
|
|
||||||
self.source.as_ref().unwrap()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Polls the inner I/O source for a non-blocking read operation.
|
|
||||||
///
|
|
||||||
/// If the operation returns an error of the `io::ErrorKind::WouldBlock` kind, the current task
|
|
||||||
/// will be registered for wakeup when the I/O source becomes readable.
|
|
||||||
pub fn poll_read_with<'a, F, R>(&'a self, cx: &mut Context<'_>, mut f: F) -> Poll<io::Result<R>>
|
|
||||||
where
|
|
||||||
F: FnMut(&'a T) -> io::Result<R>,
|
|
||||||
{
|
|
||||||
// If the operation isn't blocked, return its result.
|
|
||||||
match f(self.source.as_ref().unwrap()) {
|
|
||||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}
|
|
||||||
res => return Poll::Ready(res),
|
|
||||||
}
|
|
||||||
|
|
||||||
// Lock the waker list.
|
|
||||||
let mut readers = self.entry.readers.lock().unwrap();
|
|
||||||
|
|
||||||
// Try running the operation again.
|
|
||||||
match f(self.source.as_ref().unwrap()) {
|
|
||||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}
|
|
||||||
res => return Poll::Ready(res),
|
|
||||||
}
|
|
||||||
|
|
||||||
// Register the task if it isn't registered already.
|
|
||||||
if readers.wakers.iter().all(|w| !w.will_wake(cx.waker())) {
|
|
||||||
readers.wakers.push(cx.waker().clone());
|
|
||||||
}
|
|
||||||
|
|
||||||
readers.ready = false;
|
|
||||||
|
|
||||||
Poll::Pending
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Polls the inner I/O source for a non-blocking write operation.
|
|
||||||
///
|
|
||||||
/// If the operation returns an error of the `io::ErrorKind::WouldBlock` kind, the current task
|
|
||||||
/// will be registered for wakeup when the I/O source becomes writable.
|
|
||||||
pub fn poll_write_with<'a, F, R>(
|
|
||||||
&'a self,
|
|
||||||
cx: &mut Context<'_>,
|
|
||||||
mut f: F,
|
|
||||||
) -> Poll<io::Result<R>>
|
|
||||||
where
|
|
||||||
F: FnMut(&'a T) -> io::Result<R>,
|
|
||||||
{
|
|
||||||
// If the operation isn't blocked, return its result.
|
|
||||||
match f(self.source.as_ref().unwrap()) {
|
|
||||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}
|
|
||||||
res => return Poll::Ready(res),
|
|
||||||
}
|
|
||||||
|
|
||||||
// Lock the waker list.
|
|
||||||
let mut writers = self.entry.writers.lock().unwrap();
|
|
||||||
|
|
||||||
// Try running the operation again.
|
|
||||||
match f(self.source.as_ref().unwrap()) {
|
|
||||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}
|
|
||||||
res => return Poll::Ready(res),
|
|
||||||
}
|
|
||||||
|
|
||||||
// Register the task if it isn't registered already.
|
|
||||||
if writers.wakers.iter().all(|w| !w.will_wake(cx.waker())) {
|
|
||||||
writers.wakers.push(cx.waker().clone());
|
|
||||||
}
|
|
||||||
|
|
||||||
writers.ready = false;
|
|
||||||
|
|
||||||
Poll::Pending
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Polls the inner I/O source until a non-blocking read can be performed.
|
|
||||||
///
|
|
||||||
/// If non-blocking reads are currently not possible, the `Waker`
|
|
||||||
/// will be saved and notified when it can read non-blocking
|
|
||||||
/// again.
|
|
||||||
#[allow(dead_code)]
|
|
||||||
pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<()> {
|
|
||||||
// Lock the waker list.
|
|
||||||
let mut readers = self.entry.readers.lock().unwrap();
|
|
||||||
if readers.ready {
|
|
||||||
return Poll::Ready(())
|
|
||||||
}
|
|
||||||
// Register the task if it isn't registered already.
|
|
||||||
if readers.wakers.iter().all(|w| !w.will_wake(cx.waker())) {
|
|
||||||
readers.wakers.push(cx.waker().clone());
|
|
||||||
}
|
|
||||||
Poll::Pending
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Polls the inner I/O source until a non-blocking write can be performed.
|
|
||||||
///
|
|
||||||
/// If non-blocking writes are currently not possible, the `Waker`
|
|
||||||
/// will be saved and notified when it can write non-blocking
|
|
||||||
/// again.
|
|
||||||
pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<()> {
|
|
||||||
// Lock the waker list.
|
|
||||||
let mut writers = self.entry.writers.lock().unwrap();
|
|
||||||
if writers.ready {
|
|
||||||
return Poll::Ready(())
|
|
||||||
}
|
|
||||||
// Register the task if it isn't registered already.
|
|
||||||
if writers.wakers.iter().all(|w| !w.will_wake(cx.waker())) {
|
|
||||||
writers.wakers.push(cx.waker().clone());
|
|
||||||
}
|
|
||||||
Poll::Pending
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Deregisters and returns the inner I/O source.
|
|
||||||
///
|
|
||||||
/// This method is typically used to convert `Watcher`s to raw file descriptors/handles.
|
|
||||||
#[allow(dead_code)]
|
|
||||||
pub fn into_inner(mut self) -> T {
|
|
||||||
let source = self.source.take().unwrap();
|
|
||||||
REACTOR
|
|
||||||
.deregister(&source, &self.entry)
|
|
||||||
.expect("cannot deregister I/O event source");
|
|
||||||
source
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Evented> Drop for Watcher<T> {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
if let Some(ref source) = self.source {
|
|
||||||
REACTOR
|
|
||||||
.deregister(source, &self.entry)
|
|
||||||
.expect("cannot deregister I/O event source");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Evented + fmt::Debug> fmt::Debug for Watcher<T> {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
f.debug_struct("Watcher")
|
|
||||||
.field("entry", &self.entry)
|
|
||||||
.field("source", &self.source)
|
|
||||||
.finish()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a mask containing flags that interest tasks reading from I/O handles.
|
|
||||||
#[inline]
|
|
||||||
fn reader_interests() -> mio::Ready {
|
|
||||||
mio::Ready::all() - mio::Ready::writable()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a mask containing flags that interest tasks writing into I/O handles.
|
|
||||||
#[inline]
|
|
||||||
fn writer_interests() -> mio::Ready {
|
|
||||||
mio::Ready::writable() | hup()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a flag containing the hangup status.
|
|
||||||
#[inline]
|
|
||||||
fn hup() -> mio::Ready {
|
|
||||||
#[cfg(unix)]
|
|
||||||
let ready = mio::unix::UnixReady::hup().into();
|
|
||||||
|
|
||||||
#[cfg(not(unix))]
|
|
||||||
let ready = mio::Ready::empty();
|
|
||||||
|
|
||||||
ready
|
|
||||||
}
|
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
//! The runtime.
|
||||||
|
|
||||||
|
use std::env;
|
||||||
|
use std::thread;
|
||||||
|
|
||||||
|
use once_cell::sync::Lazy;
|
||||||
|
|
||||||
|
use crate::future;
|
||||||
|
|
||||||
|
/// Dummy runtime struct.
|
||||||
|
pub struct Runtime {}
|
||||||
|
|
||||||
|
/// The global runtime.
|
||||||
|
pub static RUNTIME: Lazy<Runtime> = Lazy::new(|| {
|
||||||
|
// Create an executor thread pool.
|
||||||
|
|
||||||
|
let thread_count = env::var("ASYNC_STD_THREAD_COUNT")
|
||||||
|
.map(|env| {
|
||||||
|
env.parse()
|
||||||
|
.expect("ASYNC_STD_THREAD_COUNT must be a number")
|
||||||
|
})
|
||||||
|
.unwrap_or_else(|_| num_cpus::get())
|
||||||
|
.max(1);
|
||||||
|
|
||||||
|
let thread_name = env::var("ASYNC_STD_THREAD_NAME").unwrap_or("async-std/runtime".to_string());
|
||||||
|
|
||||||
|
for _ in 0..thread_count {
|
||||||
|
thread::Builder::new()
|
||||||
|
.name(thread_name.clone())
|
||||||
|
.spawn(|| smol::run(future::pending::<()>()))
|
||||||
|
.expect("cannot start a runtime thread");
|
||||||
|
}
|
||||||
|
Runtime {}
|
||||||
|
});
|
||||||
@ -0,0 +1,417 @@
|
|||||||
|
use std::fmt;
|
||||||
|
use std::pin::Pin;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use super::mutex::{guard_lock, MutexGuard};
|
||||||
|
use crate::future::{timeout, Future};
|
||||||
|
use crate::sync::WakerSet;
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||||
|
pub struct WaitTimeoutResult(bool);
|
||||||
|
|
||||||
|
/// A type indicating whether a timed wait on a condition variable returned due to a time out or
|
||||||
|
/// not
|
||||||
|
impl WaitTimeoutResult {
|
||||||
|
/// Returns `true` if the wait was known to have timed out.
|
||||||
|
pub fn timed_out(self) -> bool {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A Condition Variable
|
||||||
|
///
|
||||||
|
/// This type is an async version of [`std::sync::Mutex`].
|
||||||
|
///
|
||||||
|
/// [`std::sync::Condvar`]: https://doc.rust-lang.org/std/sync/struct.Condvar.html
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// #
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// // Inside of our lock, spawn a new thread, and then wait for it to start.
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // Wait for the thread to start up.
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// while !*started {
|
||||||
|
/// started = cvar.wait(started).await;
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
pub struct Condvar {
|
||||||
|
wakers: WakerSet,
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe impl Send for Condvar {}
|
||||||
|
unsafe impl Sync for Condvar {}
|
||||||
|
|
||||||
|
impl Default for Condvar {
|
||||||
|
fn default() -> Self {
|
||||||
|
Condvar::new()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Condvar {
|
||||||
|
/// Creates a new condition variable
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use async_std::sync::Condvar;
|
||||||
|
///
|
||||||
|
/// let cvar = Condvar::new();
|
||||||
|
/// ```
|
||||||
|
pub fn new() -> Self {
|
||||||
|
Condvar {
|
||||||
|
wakers: WakerSet::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Blocks the current task until this condition variable receives a notification.
|
||||||
|
///
|
||||||
|
/// Unlike the std equivalent, this does not check that a single mutex is used at runtime.
|
||||||
|
/// However, as a best practice avoid using with multiple mutexes.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // Wait for the thread to start up.
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// while !*started {
|
||||||
|
/// started = cvar.wait(started).await;
|
||||||
|
/// }
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
#[allow(clippy::needless_lifetimes)]
|
||||||
|
pub async fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> MutexGuard<'a, T> {
|
||||||
|
let mutex = guard_lock(&guard);
|
||||||
|
|
||||||
|
self.await_notify(guard).await;
|
||||||
|
|
||||||
|
mutex.lock().await
|
||||||
|
}
|
||||||
|
|
||||||
|
fn await_notify<'a, T>(&self, guard: MutexGuard<'a, T>) -> AwaitNotify<'_, 'a, T> {
|
||||||
|
AwaitNotify {
|
||||||
|
cond: self,
|
||||||
|
guard: Some(guard),
|
||||||
|
key: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Blocks the current taks until this condition variable receives a notification and the
|
||||||
|
/// required condition is met. Spurious wakeups are ignored and this function will only
|
||||||
|
/// return once the condition has been met.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// #
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // Wait for the thread to start up.
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
|
||||||
|
/// let _guard = cvar.wait_until(lock.lock().await, |started| { *started }).await;
|
||||||
|
/// #
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
#[allow(clippy::needless_lifetimes)]
|
||||||
|
pub async fn wait_until<'a, T, F>(
|
||||||
|
&self,
|
||||||
|
mut guard: MutexGuard<'a, T>,
|
||||||
|
mut condition: F,
|
||||||
|
) -> MutexGuard<'a, T>
|
||||||
|
where
|
||||||
|
F: FnMut(&mut T) -> bool,
|
||||||
|
{
|
||||||
|
while !condition(&mut *guard) {
|
||||||
|
guard = self.wait(guard).await;
|
||||||
|
}
|
||||||
|
guard
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Waits on this condition variable for a notification, timing out after a specified duration.
|
||||||
|
///
|
||||||
|
/// For these reasons `Condvar::wait_timeout_until` is recommended in most cases.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// #
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
/// use std::time::Duration;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // wait for the thread to start up
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// loop {
|
||||||
|
/// let result = cvar.wait_timeout(started, Duration::from_millis(10)).await;
|
||||||
|
/// started = result.0;
|
||||||
|
/// if *started == true {
|
||||||
|
/// // We received the notification and the value has been updated, we can leave.
|
||||||
|
/// break
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// #
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
#[allow(clippy::needless_lifetimes)]
|
||||||
|
pub async fn wait_timeout<'a, T>(
|
||||||
|
&self,
|
||||||
|
guard: MutexGuard<'a, T>,
|
||||||
|
dur: Duration,
|
||||||
|
) -> (MutexGuard<'a, T>, WaitTimeoutResult) {
|
||||||
|
let mutex = guard_lock(&guard);
|
||||||
|
match timeout(dur, self.wait(guard)).await {
|
||||||
|
Ok(guard) => (guard, WaitTimeoutResult(false)),
|
||||||
|
Err(_) => (mutex.lock().await, WaitTimeoutResult(true)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Waits on this condition variable for a notification, timing out after a specified duration.
|
||||||
|
/// Spurious wakes will not cause this function to return.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
/// use std::time::Duration;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // wait for the thread to start up
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let result = cvar.wait_timeout_until(
|
||||||
|
/// lock.lock().await,
|
||||||
|
/// Duration::from_millis(100),
|
||||||
|
/// |&mut started| started,
|
||||||
|
/// ).await;
|
||||||
|
/// if result.1.timed_out() {
|
||||||
|
/// // timed-out without the condition ever evaluating to true.
|
||||||
|
/// }
|
||||||
|
/// // access the locked mutex via result.0
|
||||||
|
/// # });
|
||||||
|
/// ```
|
||||||
|
#[allow(clippy::needless_lifetimes)]
|
||||||
|
pub async fn wait_timeout_until<'a, T, F>(
|
||||||
|
&self,
|
||||||
|
guard: MutexGuard<'a, T>,
|
||||||
|
dur: Duration,
|
||||||
|
condition: F,
|
||||||
|
) -> (MutexGuard<'a, T>, WaitTimeoutResult)
|
||||||
|
where
|
||||||
|
F: FnMut(&mut T) -> bool,
|
||||||
|
{
|
||||||
|
let mutex = guard_lock(&guard);
|
||||||
|
match timeout(dur, self.wait_until(guard, condition)).await {
|
||||||
|
Ok(guard) => (guard, WaitTimeoutResult(false)),
|
||||||
|
Err(_) => (mutex.lock().await, WaitTimeoutResult(true)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Wakes up one blocked task on this condvar.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # fn main() { async_std::task::block_on(async {
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_one();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // Wait for the thread to start up.
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// while !*started {
|
||||||
|
/// started = cvar.wait(started).await;
|
||||||
|
/// }
|
||||||
|
/// # }) }
|
||||||
|
/// ```
|
||||||
|
pub fn notify_one(&self) {
|
||||||
|
self.wakers.notify_one();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Wakes up all blocked tasks on this condvar.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
/// ```
|
||||||
|
/// # fn main() { async_std::task::block_on(async {
|
||||||
|
/// #
|
||||||
|
/// use std::sync::Arc;
|
||||||
|
///
|
||||||
|
/// use async_std::sync::{Mutex, Condvar};
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
/// let pair2 = pair.clone();
|
||||||
|
///
|
||||||
|
/// task::spawn(async move {
|
||||||
|
/// let (lock, cvar) = &*pair2;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// *started = true;
|
||||||
|
/// // We notify the condvar that the value has changed.
|
||||||
|
/// cvar.notify_all();
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// // Wait for the thread to start up.
|
||||||
|
/// let (lock, cvar) = &*pair;
|
||||||
|
/// let mut started = lock.lock().await;
|
||||||
|
/// // As long as the value inside the `Mutex<bool>` is `false`, we wait.
|
||||||
|
/// while !*started {
|
||||||
|
/// started = cvar.wait(started).await;
|
||||||
|
/// }
|
||||||
|
/// #
|
||||||
|
/// # }) }
|
||||||
|
/// ```
|
||||||
|
pub fn notify_all(&self) {
|
||||||
|
self.wakers.notify_all();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Condvar {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
f.pad("Condvar { .. }")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A future that waits for another task to notify the condition variable.
|
||||||
|
///
|
||||||
|
/// This is an internal future that `wait` and `wait_until` await on.
|
||||||
|
struct AwaitNotify<'a, 'b, T> {
|
||||||
|
/// The condition variable that we are waiting on
|
||||||
|
cond: &'a Condvar,
|
||||||
|
/// The lock used with `cond`.
|
||||||
|
/// This will be released the first time the future is polled,
|
||||||
|
/// after registering the context to be notified.
|
||||||
|
guard: Option<MutexGuard<'b, T>>,
|
||||||
|
/// A key into the conditions variable's `WakerSet`.
|
||||||
|
/// This is set to the index of the `Waker` for the context each time
|
||||||
|
/// the future is polled and not completed.
|
||||||
|
key: Option<usize>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'b, T> Future for AwaitNotify<'a, 'b, T> {
|
||||||
|
type Output = ();
|
||||||
|
|
||||||
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
match self.guard.take() {
|
||||||
|
Some(_) => {
|
||||||
|
self.key = Some(self.cond.wakers.insert(cx));
|
||||||
|
// the guard is dropped when we return, which frees the lock
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
if let Some(key) = self.key {
|
||||||
|
if self.cond.wakers.remove_if_notified(key, cx) {
|
||||||
|
self.key = None;
|
||||||
|
Poll::Ready(())
|
||||||
|
} else {
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// This should only happen if it is polled twice after receiving a notification
|
||||||
|
Poll::Ready(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, 'b, T> Drop for AwaitNotify<'a, 'b, T> {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
if let Some(key) = self.key {
|
||||||
|
self.cond.wakers.cancel(key);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -1,13 +0,0 @@
|
|||||||
//! Task executor.
|
|
||||||
//!
|
|
||||||
//! API bindings between `crate::task` and this module are very simple:
|
|
||||||
//!
|
|
||||||
//! * The only export is the `schedule` function.
|
|
||||||
//! * The only import is the `crate::task::Runnable` type.
|
|
||||||
|
|
||||||
pub(crate) use pool::schedule;
|
|
||||||
|
|
||||||
use sleepers::Sleepers;
|
|
||||||
|
|
||||||
mod pool;
|
|
||||||
mod sleepers;
|
|
||||||
@ -1,179 +0,0 @@
|
|||||||
use std::cell::Cell;
|
|
||||||
use std::iter;
|
|
||||||
use std::thread;
|
|
||||||
use std::time::Duration;
|
|
||||||
|
|
||||||
use crossbeam_deque::{Injector, Stealer, Worker};
|
|
||||||
use once_cell::sync::Lazy;
|
|
||||||
use once_cell::unsync::OnceCell;
|
|
||||||
|
|
||||||
use crate::task::executor::Sleepers;
|
|
||||||
use crate::task::Runnable;
|
|
||||||
use crate::utils::{abort_on_panic, random};
|
|
||||||
|
|
||||||
/// The state of an executor.
|
|
||||||
struct Pool {
|
|
||||||
/// The global queue of tasks.
|
|
||||||
injector: Injector<Runnable>,
|
|
||||||
|
|
||||||
/// Handles to local queues for stealing work from worker threads.
|
|
||||||
stealers: Vec<Stealer<Runnable>>,
|
|
||||||
|
|
||||||
/// Used for putting idle workers to sleep and notifying them when new tasks come in.
|
|
||||||
sleepers: Sleepers,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Global executor that runs spawned tasks.
|
|
||||||
static POOL: Lazy<Pool> = Lazy::new(|| {
|
|
||||||
let num_threads = num_cpus::get().max(1);
|
|
||||||
let mut stealers = Vec::new();
|
|
||||||
|
|
||||||
// Spawn worker threads.
|
|
||||||
for _ in 0..num_threads {
|
|
||||||
let worker = Worker::new_fifo();
|
|
||||||
stealers.push(worker.stealer());
|
|
||||||
|
|
||||||
let proc = Processor {
|
|
||||||
worker,
|
|
||||||
slot: Cell::new(None),
|
|
||||||
slot_runs: Cell::new(0),
|
|
||||||
};
|
|
||||||
|
|
||||||
thread::Builder::new()
|
|
||||||
.name("async-std/executor".to_string())
|
|
||||||
.spawn(|| {
|
|
||||||
let _ = PROCESSOR.with(|p| p.set(proc));
|
|
||||||
abort_on_panic(main_loop);
|
|
||||||
})
|
|
||||||
.expect("cannot start a thread driving tasks");
|
|
||||||
}
|
|
||||||
|
|
||||||
Pool {
|
|
||||||
injector: Injector::new(),
|
|
||||||
stealers,
|
|
||||||
sleepers: Sleepers::new(),
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
/// The state of a worker thread.
|
|
||||||
struct Processor {
|
|
||||||
/// The local task queue.
|
|
||||||
worker: Worker<Runnable>,
|
|
||||||
|
|
||||||
/// Contains the next task to run as an optimization that skips queues.
|
|
||||||
slot: Cell<Option<Runnable>>,
|
|
||||||
|
|
||||||
/// How many times in a row tasks have been taked from the slot rather than the queue.
|
|
||||||
slot_runs: Cell<u32>,
|
|
||||||
}
|
|
||||||
|
|
||||||
thread_local! {
|
|
||||||
/// Worker thread state.
|
|
||||||
static PROCESSOR: OnceCell<Processor> = OnceCell::new();
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Schedules a new runnable task for execution.
|
|
||||||
pub(crate) fn schedule(task: Runnable) {
|
|
||||||
PROCESSOR.with(|proc| {
|
|
||||||
// If the current thread is a worker thread, store it into its task slot or push it into
|
|
||||||
// its local task queue. Otherwise, push it into the global task queue.
|
|
||||||
match proc.get() {
|
|
||||||
Some(proc) => {
|
|
||||||
// Replace the task in the slot.
|
|
||||||
if let Some(task) = proc.slot.replace(Some(task)) {
|
|
||||||
// If the slot already contained a task, push it into the local task queue.
|
|
||||||
proc.worker.push(task);
|
|
||||||
POOL.sleepers.notify_one();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
None => {
|
|
||||||
POOL.injector.push(task);
|
|
||||||
POOL.sleepers.notify_one();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Main loop running a worker thread.
|
|
||||||
fn main_loop() {
|
|
||||||
/// Number of yields when no runnable task is found.
|
|
||||||
const YIELDS: u32 = 3;
|
|
||||||
/// Number of short sleeps when no runnable task in found.
|
|
||||||
const SLEEPS: u32 = 1;
|
|
||||||
|
|
||||||
// The number of times the thread didn't find work in a row.
|
|
||||||
let mut fails = 0;
|
|
||||||
|
|
||||||
loop {
|
|
||||||
// Try to find a runnable task.
|
|
||||||
match find_runnable() {
|
|
||||||
Some(task) => {
|
|
||||||
fails = 0;
|
|
||||||
|
|
||||||
// Run the found task.
|
|
||||||
task.run();
|
|
||||||
}
|
|
||||||
None => {
|
|
||||||
fails += 1;
|
|
||||||
|
|
||||||
// Yield the current thread or put it to sleep.
|
|
||||||
if fails <= YIELDS {
|
|
||||||
thread::yield_now();
|
|
||||||
} else if fails <= YIELDS + SLEEPS {
|
|
||||||
thread::sleep(Duration::from_micros(10));
|
|
||||||
} else {
|
|
||||||
POOL.sleepers.wait();
|
|
||||||
fails = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Find the next runnable task.
|
|
||||||
fn find_runnable() -> Option<Runnable> {
|
|
||||||
/// Maximum number of times the slot can be used in a row.
|
|
||||||
const SLOT_LIMIT: u32 = 16;
|
|
||||||
|
|
||||||
PROCESSOR.with(|proc| {
|
|
||||||
let proc = proc.get().unwrap();
|
|
||||||
|
|
||||||
// Try taking a task from the slot.
|
|
||||||
let runs = proc.slot_runs.get();
|
|
||||||
if runs < SLOT_LIMIT {
|
|
||||||
if let Some(task) = proc.slot.take() {
|
|
||||||
proc.slot_runs.set(runs + 1);
|
|
||||||
return Some(task);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
proc.slot_runs.set(0);
|
|
||||||
|
|
||||||
// Pop a task from the local queue, if not empty.
|
|
||||||
proc.worker.pop().or_else(|| {
|
|
||||||
// Otherwise, we need to look for a task elsewhere.
|
|
||||||
iter::repeat_with(|| {
|
|
||||||
// Try stealing a batch of tasks from the global queue.
|
|
||||||
POOL.injector
|
|
||||||
.steal_batch_and_pop(&proc.worker)
|
|
||||||
// Or try stealing a batch of tasks from one of the other threads.
|
|
||||||
.or_else(|| {
|
|
||||||
// First, pick a random starting point in the list of local queues.
|
|
||||||
let len = POOL.stealers.len();
|
|
||||||
let start = random(len as u32) as usize;
|
|
||||||
|
|
||||||
// Try stealing a batch of tasks from each local queue starting from the
|
|
||||||
// chosen point.
|
|
||||||
let (l, r) = POOL.stealers.split_at(start);
|
|
||||||
let stealers = r.iter().chain(l.iter());
|
|
||||||
stealers
|
|
||||||
.map(|s| s.steal_batch_and_pop(&proc.worker))
|
|
||||||
.collect()
|
|
||||||
})
|
|
||||||
})
|
|
||||||
// Loop while no task was stolen and any steal operation needs to be retried.
|
|
||||||
.find(|s| !s.is_retry())
|
|
||||||
// Extract the stolen task, if there is one.
|
|
||||||
.and_then(|s| s.success())
|
|
||||||
})
|
|
||||||
})
|
|
||||||
}
|
|
||||||
@ -1,52 +0,0 @@
|
|||||||
use std::sync::atomic::{AtomicBool, Ordering};
|
|
||||||
use std::sync::{Condvar, Mutex};
|
|
||||||
|
|
||||||
/// The place where worker threads go to sleep.
|
|
||||||
///
|
|
||||||
/// Similar to how thread parking works, if a notification comes up while no threads are sleeping,
|
|
||||||
/// the next thread that attempts to go to sleep will pick up the notification immediately.
|
|
||||||
pub struct Sleepers {
|
|
||||||
/// How many threads are currently a sleep.
|
|
||||||
sleep: Mutex<usize>,
|
|
||||||
|
|
||||||
/// A condvar for notifying sleeping threads.
|
|
||||||
wake: Condvar,
|
|
||||||
|
|
||||||
/// Set to `true` if a notification came up while nobody was sleeping.
|
|
||||||
notified: AtomicBool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Sleepers {
|
|
||||||
/// Creates a new `Sleepers`.
|
|
||||||
pub fn new() -> Sleepers {
|
|
||||||
Sleepers {
|
|
||||||
sleep: Mutex::new(0),
|
|
||||||
wake: Condvar::new(),
|
|
||||||
notified: AtomicBool::new(false),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Puts the current thread to sleep.
|
|
||||||
pub fn wait(&self) {
|
|
||||||
let mut sleep = self.sleep.lock().unwrap();
|
|
||||||
|
|
||||||
if !self.notified.swap(false, Ordering::SeqCst) {
|
|
||||||
*sleep += 1;
|
|
||||||
let _ = self.wake.wait(sleep).unwrap();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Notifies one thread.
|
|
||||||
pub fn notify_one(&self) {
|
|
||||||
if !self.notified.load(Ordering::SeqCst) {
|
|
||||||
let mut sleep = self.sleep.lock().unwrap();
|
|
||||||
|
|
||||||
if *sleep > 0 {
|
|
||||||
*sleep -= 1;
|
|
||||||
self.wake.notify_one();
|
|
||||||
} else {
|
|
||||||
self.notified.store(true, Ordering::SeqCst);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,28 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
use crate::task::{Builder, JoinHandle};
|
||||||
|
|
||||||
|
/// Spawns a task onto the thread-local executor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// #
|
||||||
|
/// use async_std::task;
|
||||||
|
///
|
||||||
|
/// let handle = task::spawn_local(async {
|
||||||
|
/// 1 + 2
|
||||||
|
/// });
|
||||||
|
///
|
||||||
|
/// assert_eq!(handle.await, 3);
|
||||||
|
/// #
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
pub fn spawn_local<F, T>(future: F) -> JoinHandle<T>
|
||||||
|
where
|
||||||
|
F: Future<Output = T> + 'static,
|
||||||
|
T: 'static,
|
||||||
|
{
|
||||||
|
Builder::new().local(future).expect("cannot spawn task")
|
||||||
|
}
|
||||||
@ -0,0 +1,84 @@
|
|||||||
|
use std::cell::Cell;
|
||||||
|
use std::ptr;
|
||||||
|
|
||||||
|
use crate::task::{LocalsMap, Task, TaskId};
|
||||||
|
use crate::utils::abort_on_panic;
|
||||||
|
|
||||||
|
thread_local! {
|
||||||
|
/// A pointer to the currently running task.
|
||||||
|
static CURRENT: Cell<*const TaskLocalsWrapper> = Cell::new(ptr::null_mut());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A wrapper to store task local data.
|
||||||
|
pub(crate) struct TaskLocalsWrapper {
|
||||||
|
/// The actual task details.
|
||||||
|
task: Task,
|
||||||
|
|
||||||
|
/// The map holding task-local values.
|
||||||
|
locals: LocalsMap,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TaskLocalsWrapper {
|
||||||
|
/// Creates a new task handle.
|
||||||
|
///
|
||||||
|
/// If the task is unnamed, the inner representation of the task will be lazily allocated on
|
||||||
|
/// demand.
|
||||||
|
#[inline]
|
||||||
|
pub(crate) fn new(task: Task) -> Self {
|
||||||
|
Self {
|
||||||
|
task,
|
||||||
|
locals: LocalsMap::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets the task's unique identifier.
|
||||||
|
#[inline]
|
||||||
|
pub fn id(&self) -> TaskId {
|
||||||
|
self.task.id()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a reference to the inner `Task`.
|
||||||
|
pub(crate) fn task(&self) -> &Task {
|
||||||
|
&self.task
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the map holding task-local values.
|
||||||
|
pub(crate) fn locals(&self) -> &LocalsMap {
|
||||||
|
&self.locals
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set a reference to the current task.
|
||||||
|
pub(crate) unsafe fn set_current<F, R>(task: *const TaskLocalsWrapper, f: F) -> R
|
||||||
|
where
|
||||||
|
F: FnOnce() -> R,
|
||||||
|
{
|
||||||
|
CURRENT.with(|current| {
|
||||||
|
let old_task = current.replace(task);
|
||||||
|
defer! {
|
||||||
|
current.set(old_task);
|
||||||
|
}
|
||||||
|
f()
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets a reference to the current task.
|
||||||
|
pub(crate) fn get_current<F, R>(f: F) -> Option<R>
|
||||||
|
where
|
||||||
|
F: FnOnce(&TaskLocalsWrapper) -> R,
|
||||||
|
{
|
||||||
|
let res = CURRENT.try_with(|current| unsafe { current.get().as_ref().map(f) });
|
||||||
|
match res {
|
||||||
|
Ok(Some(val)) => Some(val),
|
||||||
|
Ok(None) | Err(_) => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for TaskLocalsWrapper {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
// Abort the process if dropping task-locals panics.
|
||||||
|
abort_on_panic(|| {
|
||||||
|
unsafe { self.locals.clear() };
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,103 @@
|
|||||||
|
#![cfg(feature = "unstable")]
|
||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use async_std::sync::{Condvar, Mutex};
|
||||||
|
use async_std::task::{self, JoinHandle};
|
||||||
|
|
||||||
|
#[cfg(not(target_os = "unknown"))]
|
||||||
|
use async_std::task::spawn;
|
||||||
|
#[cfg(target_os = "unknown")]
|
||||||
|
use async_std::task::spawn_local as spawn;
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||||
|
fn wait_timeout_with_lock() {
|
||||||
|
task::block_on(async {
|
||||||
|
let pair = Arc::new((Mutex::new(false), Condvar::new()));
|
||||||
|
let pair2 = pair.clone();
|
||||||
|
|
||||||
|
spawn(async move {
|
||||||
|
let (m, c) = &*pair2;
|
||||||
|
let _g = m.lock().await;
|
||||||
|
task::sleep(Duration::from_millis(200)).await;
|
||||||
|
c.notify_one();
|
||||||
|
});
|
||||||
|
|
||||||
|
let (m, c) = &*pair;
|
||||||
|
let (_, wait_result) = c
|
||||||
|
.wait_timeout(m.lock().await, Duration::from_millis(50))
|
||||||
|
.await;
|
||||||
|
assert!(wait_result.timed_out());
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||||
|
fn wait_timeout_without_lock() {
|
||||||
|
task::block_on(async {
|
||||||
|
let m = Mutex::new(false);
|
||||||
|
let c = Condvar::new();
|
||||||
|
|
||||||
|
let (_, wait_result) = c
|
||||||
|
.wait_timeout(m.lock().await, Duration::from_millis(10))
|
||||||
|
.await;
|
||||||
|
assert!(wait_result.timed_out());
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||||
|
fn wait_timeout_until_timed_out() {
|
||||||
|
task::block_on(async {
|
||||||
|
let m = Mutex::new(false);
|
||||||
|
let c = Condvar::new();
|
||||||
|
|
||||||
|
let (_, wait_result) = c
|
||||||
|
.wait_timeout_until(m.lock().await, Duration::from_millis(100), |&mut started| {
|
||||||
|
started
|
||||||
|
})
|
||||||
|
.await;
|
||||||
|
assert!(wait_result.timed_out());
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||||
|
fn notify_all() {
|
||||||
|
task::block_on(async {
|
||||||
|
let mut tasks: Vec<JoinHandle<()>> = Vec::new();
|
||||||
|
let pair = Arc::new((Mutex::new(0u32), Condvar::new()));
|
||||||
|
|
||||||
|
for _ in 0..10 {
|
||||||
|
let pair = pair.clone();
|
||||||
|
tasks.push(spawn(async move {
|
||||||
|
let (m, c) = &*pair;
|
||||||
|
let mut count = m.lock().await;
|
||||||
|
while *count == 0 {
|
||||||
|
count = c.wait(count).await;
|
||||||
|
}
|
||||||
|
*count += 1;
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Give some time for tasks to start up
|
||||||
|
task::sleep(Duration::from_millis(50)).await;
|
||||||
|
|
||||||
|
let (m, c) = &*pair;
|
||||||
|
{
|
||||||
|
let mut count = m.lock().await;
|
||||||
|
*count += 1;
|
||||||
|
c.notify_all();
|
||||||
|
}
|
||||||
|
|
||||||
|
for t in tasks {
|
||||||
|
t.await;
|
||||||
|
}
|
||||||
|
let count = m.lock().await;
|
||||||
|
assert_eq!(11, *count);
|
||||||
|
})
|
||||||
|
}
|
||||||
@ -0,0 +1,26 @@
|
|||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use async_std::future::timeout;
|
||||||
|
use async_std::task;
|
||||||
|
|
||||||
|
#[cfg(target_arch = "wasm32")]
|
||||||
|
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
|
||||||
|
fn timeout_future_many() {
|
||||||
|
task::block_on(async {
|
||||||
|
let futures = (0..100)
|
||||||
|
.map(|i| {
|
||||||
|
timeout(Duration::from_millis(i * 20), async move {
|
||||||
|
task::sleep(Duration::from_millis(i)).await;
|
||||||
|
Ok::<(), async_std::future::TimeoutError>(())
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
for future in futures {
|
||||||
|
future.await.unwrap().unwrap();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
#!/bin/sh
|
||||||
|
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test buf_writer
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test channel
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test condvar
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test mutex
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test rwlock
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test stream
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test task_local
|
||||||
|
wasm-pack test --chrome --headless -- --features unstable --test timeout
|
||||||
Loading…
Reference in New Issue