Update Tokio to use std::future. (#1120)

A first pass at updating Tokio to use `std::future`. Implementations of `Future` from the futures crate are updated to implement `Future` from std. Implementations of `Stream` are moved to a feature flag. This commits disables a number of crates that have not yet been updated.
2026-08-28 00:00:11 +02:00 · 2019-06-24 12:34:30 -07:00
parent aa99950b9c
commit 06c473e628
150 changed files with 2694 additions and 9825 deletions
@@ -30,13 +30,14 @@
 mod scheduler;

 use crate::scheduler::Scheduler;
-use futures::future::{ExecuteError, ExecuteErrorKind, Executor};
-use futures::{executor, Async, Future};
 use std::cell::Cell;
 use std::error::Error;
 use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::{atomic, mpsc, Arc};
+use std::task::{Context, Poll, Waker};
 use std::thread;
 use std::time::{Duration, Instant};
 use tokio_executor::park::{Park, ParkThread, Unpark};
@@ -60,7 +61,7 @@ pub struct CurrentThread<P: Park = ParkThread> {
    spawn_handle: Handle,

    /// Receiver for futures spawned from other threads
-    spawn_receiver: mpsc::Receiver<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,
+    spawn_receiver: mpsc::Receiver<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>,

    /// The thread-local ID assigned to this executor.
    id: u64,
@@ -182,11 +183,7 @@ struct Borrow<'a, U> {
 }

 trait SpawnLocal {
-    fn spawn_local(
-        &mut self,
-        future: Box<dyn Future<Item = (), Error = ()>>,
-        already_counted: bool,
-    );
+    fn spawn_local(&mut self, future: Pin<Box<dyn Future<Output = ()>>>, already_counted: bool);
 }

 struct CurrentRunner {
@@ -225,7 +222,7 @@ thread_local! {
 ///
 /// [`CurrentThread`]: struct.CurrentThread.html
 /// [mod]: index.html
-pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
+pub fn block_on_all<F>(future: F) -> F::Output
 where
    F: Future,
 {
@@ -233,8 +230,7 @@ where

    let ret = current_thread.block_on(future);
    current_thread.run().unwrap();
-
-    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
+    ret
 }

 /// Executes a future on the current thread.
@@ -252,10 +248,10 @@ where
 /// [`tokio::spawn`]: ../fn.spawn.html
 pub fn spawn<F>(future: F)
 where
-    F: Future<Item = (), Error = ()> + 'static,
+    F: Future<Output = ()> + 'static,
 {
    TaskExecutor::current()
-        .spawn_local(Box::new(future))
+        .spawn_local(Box::pin(future))
        .unwrap();
 }

@@ -283,7 +279,7 @@ impl<P: Park> CurrentThread<P> {
        });

        let scheduler = Scheduler::new(unpark);
-        let notify = scheduler.notify();
+        let waker = scheduler.waker();

        let num_futures = Arc::new(atomic::AtomicUsize::new(0));

@@ -294,10 +290,10 @@ impl<P: Park> CurrentThread<P> {
            id,
            spawn_handle: Handle {
                sender: spawn_sender,
-                num_futures: num_futures,
-                notify: notify,
+                num_futures,
+                waker,
                shut_down: Cell::new(false),
-                thread: thread,
+                thread,
                id,
            },
            spawn_receiver: spawn_receiver,
@@ -319,9 +315,9 @@ impl<P: Park> CurrentThread<P> {
    /// This internally queues the future to be executed once `run` is called.
    pub fn spawn<F>(&mut self, future: F) -> &mut Self
    where
-        F: Future<Item = (), Error = ()> + 'static,
+        F: Future<Output = ()> + 'static,
    {
-        self.borrow().spawn_local(Box::new(future), false);
+        self.borrow().spawn_local(Box::pin(future), false);
        self
    }

@@ -338,7 +334,7 @@ impl<P: Park> CurrentThread<P> {
    ///
    /// The caller is responsible for ensuring that other spawned futures
    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F) -> Result<F::Item, BlockError<F::Error>>
+    pub fn block_on<F>(&mut self, future: F) -> F::Output
    where
        F: Future,
    {
@@ -424,7 +420,7 @@ impl<P: Park> Drop for CurrentThread<P> {
 impl tokio_executor::Executor for CurrentThread {
    fn spawn(
        &mut self,
-        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+        future: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> Result<(), SpawnError> {
        self.borrow().spawn_local(future, false);
        Ok(())
@@ -433,10 +429,10 @@ impl tokio_executor::Executor for CurrentThread {

 impl<T> tokio_executor::TypedExecutor<T> for CurrentThread
 where
-    T: Future<Item = (), Error = ()> + 'static,
+    T: Future<Output = ()> + 'static,
 {
    fn spawn(&mut self, future: T) -> Result<(), SpawnError> {
-        self.borrow().spawn_local(Box::new(future), false);
+        self.borrow().spawn_local(Box::pin(future), false);
        Ok(())
    }
 }
@@ -461,9 +457,9 @@ impl<'a, P: Park> Entered<'a, P> {
    /// This internally queues the future to be executed once `run` is called.
    pub fn spawn<F>(&mut self, future: F) -> &mut Self
    where
-        F: Future<Item = (), Error = ()> + 'static,
+        F: Future<Output = ()> + 'static,
    {
-        self.executor.borrow().spawn_local(Box::new(future), false);
+        self.executor.borrow().spawn_local(Box::pin(future), false);
        self
    }

@@ -480,29 +476,35 @@ impl<'a, P: Park> Entered<'a, P> {
    ///
    /// The caller is responsible for ensuring that other spawned futures
    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F) -> Result<F::Item, BlockError<F::Error>>
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the `Park` call returns an error.
+    pub fn block_on<F>(&mut self, mut future: F) -> F::Output
    where
        F: Future,
    {
-        let mut future = executor::spawn(future);
-        let notify = self.executor.scheduler.notify();
+        // Safety: we shadow the original `future`, so it will never move
+        // again.
+        let mut future = unsafe { Pin::new_unchecked(&mut future) };
+        let waker = self.executor.scheduler.waker();
+        let mut cx = Context::from_waker(&waker);

        loop {
            let res = self
                .executor
                .borrow()
-                .enter(self.enter, || future.poll_future_notify(&notify, 0));
+                .enter(self.enter, || future.as_mut().poll(&mut cx));

            match res {
-                Ok(Async::Ready(e)) => return Ok(e),
-                Err(e) => return Err(BlockError { inner: Some(e) }),
-                Ok(Async::NotReady) => {}
+                Poll::Ready(e) => return e,
+                Poll::Pending => {}
            }

            self.tick();

            if let Err(_) = self.executor.park.park() {
-                return Err(BlockError { inner: None });
+                panic!("block_on park failed");
            }
        }
    }
@@ -629,10 +631,11 @@ impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
 /// Handle to spawn a future on the corresponding `CurrentThread` instance
 #[derive(Clone)]
 pub struct Handle {
-    sender: mpsc::Sender<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,
+    sender: mpsc::Sender<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>,
    num_futures: Arc<atomic::AtomicUsize>,
    shut_down: Cell<bool>,
-    notify: executor::NotifyHandle,
+    /// Waker to the Scheduler
+    waker: Waker,
    thread: thread::ThreadId,

    /// The thread-local ID assigned to this Handle's executor.
@@ -657,12 +660,12 @@ impl Handle {
    /// instance of the `Handle` does not exist anymore.
    pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
    where
-        F: Future<Item = (), Error = ()> + Send + 'static,
+        F: Future<Output = ()> + Send + 'static,
    {
        if thread::current().id() == self.thread {
            let mut e = TaskExecutor::current();
            if e.id() == Some(self.id) {
-                return e.spawn_local(Box::new(future));
+                return e.spawn_local(Box::pin(future));
            }
        }

@@ -683,10 +686,9 @@ impl Handle {
        }

        self.sender
-            .send(Box::new(future))
+            .send(Box::pin(future))
            .expect("CurrentThread does not exist anymore");
-        // use 0 for the id, CurrentThread does not make use of it
-        self.notify.notify(0);
+        self.waker.wake_by_ref();
        Ok(())
    }

@@ -731,7 +733,7 @@ impl TaskExecutor {
    /// Spawn a future onto the current `CurrentThread` instance.
    pub fn spawn_local(
        &mut self,
-        future: Box<dyn Future<Item = (), Error = ()>>,
+        future: Pin<Box<dyn Future<Output = ()>>>,
    ) -> Result<(), SpawnError> {
        CURRENT.with(|current| match current.spawn.get() {
            Some(spawn) => {
@@ -746,7 +748,7 @@ impl TaskExecutor {
 impl tokio_executor::Executor for TaskExecutor {
    fn spawn(
        &mut self,
-        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+        future: Pin<Box<dyn Future<Output = ()> + Send>>,
    ) -> Result<(), SpawnError> {
        self.spawn_local(future)
    }
@@ -754,25 +756,10 @@ impl tokio_executor::Executor for TaskExecutor {

 impl<F> tokio_executor::TypedExecutor<F> for TaskExecutor
 where
-    F: Future<Item = (), Error = ()> + 'static,
+    F: Future<Output = ()> + 'static,
 {
    fn spawn(&mut self, future: F) -> Result<(), SpawnError> {
-        self.spawn_local(Box::new(future))
-    }
-}
-
-impl<F> Executor<F> for TaskExecutor
-where
-    F: Future<Item = (), Error = ()> + 'static,
-{
-    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
-        CURRENT.with(|current| match current.spawn.get() {
-            Some(spawn) => {
-                unsafe { (*spawn).spawn_local(Box::new(future), false) };
-                Ok(())
-            }
-            None => Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future)),
-        })
+        self.spawn_local(Box::pin(future))
    }
 }

@@ -791,11 +778,7 @@ impl<'a, U: Unpark> Borrow<'a, U> {
 }

 impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
-    fn spawn_local(
-        &mut self,
-        future: Box<dyn Future<Item = (), Error = ()>>,
-        already_counted: bool,
-    ) {
+    fn spawn_local(&mut self, future: Pin<Box<dyn Future<Output = ()>>>, already_counted: bool) {
        if !already_counted {
            // NOTE: we have a borrow of the Runtime, so we know that it isn't shut down.
            // NOTE: += 2 since LSB is the shutdown bit
@@ -1,14 +1,14 @@
 use crate::Borrow;
-use futures::executor::{self, NotifyHandle, Spawn, UnsafeNotify};
-use futures::{Async, Future};
 use std::cell::UnsafeCell;
 use std::fmt::{self, Debug};
-use std::marker::PhantomData;
+use std::future::Future;
 use std::mem;
+use std::pin::Pin;
 use std::ptr;
 use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release, SeqCst};
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
 use std::sync::{Arc, Weak};
+use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 use std::thread;
 use std::usize;
 use tokio_executor::park::Unpark;
@@ -22,8 +22,6 @@ pub struct Scheduler<U> {
    nodes: List<U>,
 }

-pub struct Notify<'a, U>(&'a Arc<Node<U>>);
-
 // A linked-list of nodes
 struct List<U> {
    len: usize,
@@ -78,12 +76,6 @@ struct Inner<U> {
 unsafe impl<U: Sync + Send> Send for Inner<U> {}
 unsafe impl<U: Sync + Send> Sync for Inner<U> {}

-impl<U: Unpark> executor::Notify for Inner<U> {
-    fn notify(&self, _: usize) {
-        self.unpark.unpark();
-    }
-}
-
 struct Node<U> {
    // The item
    item: UnsafeCell<Option<Task>>,
@@ -123,12 +115,12 @@ enum Dequeue<U> {
 }

 /// Wraps a spawned boxed future
-struct Task(Spawn<Box<dyn Future<Item = (), Error = ()>>>);
+struct Task(Pin<Box<dyn Future<Output = ()>>>);

 /// A task that is scheduled. `turn` must be called
 pub struct Scheduled<'a, U> {
    task: &'a mut Task,
-    notify: &'a Notify<'a, U>,
+    node: &'a Arc<Node<U>>,
    done: &'a mut bool,
 }

@@ -165,11 +157,11 @@ where
        }
    }

-    pub fn notify(&self) -> NotifyHandle {
-        self.inner.clone().into()
+    pub fn waker(&self) -> Waker {
+        waker_inner(self.inner.clone())
    }

-    pub fn schedule(&mut self, item: Box<dyn Future<Item = (), Error = ()>>) {
+    pub fn schedule(&mut self, item: Pin<Box<dyn Future<Output = ()>>>) {
        // Get the current scheduler tick
        let tick_num = self.inner.tick_num.load(SeqCst);

@@ -317,11 +309,10 @@ where
                    // deallocating the node if need be.
                    let borrow = &mut *bomb.borrow;
                    let enter = &mut *bomb.enter;
-                    let notify = Notify(bomb.node.as_ref().unwrap());

                    let mut scheduled = Scheduled {
                        task: item,
-                        notify: &notify,
+                        node: bomb.node.as_ref().unwrap(),
                        done: &mut done,
                    };

@@ -345,10 +336,15 @@ where
 impl<'a, U: Unpark> Scheduled<'a, U> {
    /// Polls the task, returns `true` if the task has completed.
    pub fn tick(&mut self) -> bool {
-        // Tick the future
-        let ret = match self.task.0.poll_future_notify(self.notify, 0) {
-            Ok(Async::Ready(_)) | Err(_) => true,
-            Ok(Async::NotReady) => false,
+        let waker = unsafe {
+            // Safety: we don't hold this waker ref longer than
+            // this `tick` function
+            waker_ref(self.node)
+        };
+        let mut cx = Context::from_waker(&waker);
+        let ret = match self.task.0.as_mut().poll(&mut cx) {
+            Poll::Ready(()) => true,
+            Poll::Pending => false,
        };

        *self.done = ret;
@@ -357,8 +353,8 @@ impl<'a, U: Unpark> Scheduled<'a, U> {
 }

 impl Task {
-    pub fn new(future: Box<dyn Future<Item = (), Error = ()> + 'static>) -> Self {
-        Task(executor::spawn(future))
+    pub fn new(future: Pin<Box<dyn Future<Output = ()> + 'static>>) -> Self {
+        Task(future)
    }
 }

@@ -630,63 +626,101 @@ impl<U> List<U> {
    }
 }

-impl<'a, U> Clone for Notify<'a, U> {
-    fn clone(&self) -> Self {
-        Notify(self.0)
-    }
+unsafe fn noop(_: *const ()) {}
+
+// ===== Raw Waker Inner<U> ======
+
+fn waker_inner<U: Unpark>(inner: Arc<Inner<U>>) -> Waker {
+    let ptr = Arc::into_raw(inner) as *const ();
+    let vtable = &RawWakerVTable::new(
+        clone_inner::<U>,
+        wake_inner::<U>,
+        wake_by_ref_inner::<U>,
+        drop_inner::<U>,
+    );
+
+    unsafe { Waker::from_raw(RawWaker::new(ptr, vtable)) }
 }

-impl<'a, U> fmt::Debug for Notify<'a, U> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("Notify").finish()
-    }
+unsafe fn clone_inner<U: Unpark>(data: *const ()) -> RawWaker {
+    let arc: Arc<Inner<U>> = Arc::from_raw(data as *const Inner<U>);
+    let clone = arc.clone();
+    // forget both Arcs so the refcounts don't get decremented
+    mem::forget(arc);
+    mem::forget(clone);
+
+    let vtable = &RawWakerVTable::new(
+        clone_inner::<U>,
+        wake_inner::<U>,
+        wake_by_ref_inner::<U>,
+        drop_inner::<U>,
+    );
+    RawWaker::new(data, vtable)
 }

-impl<'a, U: Unpark> From<Notify<'a, U>> for NotifyHandle {
-    fn from(handle: Notify<'a, U>) -> NotifyHandle {
-        unsafe {
-            let ptr = handle.0.clone();
-            let ptr = mem::transmute::<Arc<Node<U>>, *mut ArcNode<U>>(ptr);
-            NotifyHandle::new(hide_lt(ptr))
-        }
-    }
+unsafe fn wake_inner<U: Unpark>(data: *const ()) {
+    let arc: Arc<Inner<U>> = Arc::from_raw(data as *const Inner<U>);
+    arc.unpark.unpark();
 }

-struct ArcNode<U>(PhantomData<U>);
-
-// We should never touch `Task` on any thread other than the one owning
-// `Scheduler`, so this should be a safe operation.
-unsafe impl<U: Sync + Send> Send for ArcNode<U> {}
-unsafe impl<U: Sync + Send> Sync for ArcNode<U> {}
-
-impl<U: Unpark> executor::Notify for ArcNode<U> {
-    fn notify(&self, _id: usize) {
-        unsafe {
-            let me: *const ArcNode<U> = self;
-            let me: *const *const ArcNode<U> = &me;
-            let me = me as *const Arc<Node<U>>;
-            Node::notify(&*me)
-        }
-    }
+unsafe fn wake_by_ref_inner<U: Unpark>(data: *const ()) {
+    let arc: Arc<Inner<U>> = Arc::from_raw(data as *const Inner<U>);
+    arc.unpark.unpark();
+    // by_ref means we don't own the Node, so forget the Arc
+    mem::forget(arc);
 }

-unsafe impl<U: Unpark> UnsafeNotify for ArcNode<U> {
-    unsafe fn clone_raw(&self) -> NotifyHandle {
-        let me: *const ArcNode<U> = self;
-        let me: *const *const ArcNode<U> = &me;
-        let me = &*(me as *const Arc<Node<U>>);
-        Notify(me).into()
-    }
+unsafe fn drop_inner<U>(data: *const ()) {
+    drop(Arc::<Inner<U>>::from_raw(data as *const Inner<U>));
+}
+// ===== Raw Waker Node<U> ======

-    unsafe fn drop_raw(&self) {
-        let mut me: *const ArcNode<U> = self;
-        let me = &mut me as *mut *const ArcNode<U> as *mut Arc<Node<U>>;
-        ptr::drop_in_place(me);
-    }
+unsafe fn waker_ref<U: Unpark>(node: &Arc<Node<U>>) -> Waker {
+    let ptr = &*node as &Node<U> as *const Node<U> as *const ();
+    let vtable = &RawWakerVTable::new(
+        clone_node::<U>,
+        wake_unreachable,
+        wake_by_ref_node::<U>,
+        noop,
+    );
+
+    Waker::from_raw(RawWaker::new(ptr, vtable))
 }

-unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut dyn UnsafeNotify {
-    mem::transmute(p as *mut dyn UnsafeNotify)
+unsafe fn wake_unreachable(_data: *const ()) {
+    unreachable!("waker_ref::wake()");
+}
+
+unsafe fn clone_node<U: Unpark>(data: *const ()) -> RawWaker {
+    let arc: Arc<Node<U>> = Arc::from_raw(data as *const Node<U>);
+    let clone = arc.clone();
+    // forget both Arcs so the refcounts don't get decremented
+    mem::forget(arc);
+    mem::forget(clone);
+
+    let vtable = &RawWakerVTable::new(
+        clone_node::<U>,
+        wake_node::<U>,
+        wake_by_ref_node::<U>,
+        drop_node::<U>,
+    );
+    RawWaker::new(data, vtable)
+}
+
+unsafe fn wake_node<U: Unpark>(data: *const ()) {
+    let arc: Arc<Node<U>> = Arc::from_raw(data as *const Node<U>);
+    Node::<U>::notify(&arc);
+}
+
+unsafe fn wake_by_ref_node<U: Unpark>(data: *const ()) {
+    let arc: Arc<Node<U>> = Arc::from_raw(data as *const Node<U>);
+    Node::<U>::notify(&arc);
+    // by_ref means we don't own the Node, so forget the Arc
+    mem::forget(arc);
+}
+
+unsafe fn drop_node<U>(data: *const ()) {
+    drop(Arc::<Node<U>>::from_raw(data as *const Node<U>));
 }

 impl<U: Unpark> Node<U> {