rt: Remove `threaded_scheduler()` and `basic_scheduler()` (#2876)

Co-authored-by: Alice Ryhl <alice@ryhl.io>
Co-authored-by: Carl Lerche <me@carllerche.com>

1 files changed, 100 insertions, 114 deletions

diff --git a/tokio/src/runtime/enter.rs b/tokio/src/runtime/enter.rs
index f934162b..79ed4d17 100644
--- a/tokio/src/runtime/enter.rs
+++ b/tokio/src/runtime/enter.rs
@@ -4,8 +4,8 @@ use std::marker::PhantomData;
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum EnterContext {
+    #[cfg_attr(not(feature = "rt-core"), allow(dead_code))]
     Entered {
-        #[allow(dead_code)]
         allow_blocking: bool,
     },
     NotEntered,
@@ -24,32 +24,38 @@ pub(crate) struct Enter {
     _p: PhantomData<RefCell<()>>,
 }
 
-/// Marks the current thread as being within the dynamic extent of an
-/// executor.
-pub(crate) fn enter(allow_blocking: bool) -> Enter {
-    if let Some(enter) = try_enter(allow_blocking) {
-        return enter;
-    }
+cfg_rt_core! {
+    use crate::park::thread::ParkError;
 
-    panic!(
-        "Cannot start a runtime from within a runtime. This happens \
-         because a function (like `block_on`) attempted to block the \
-         current thread while the thread is being used to drive \
-         asynchronous tasks."
-    );
-}
+    use std::time::Duration;
 
-/// Tries to enter a runtime context, returns `None` if already in a runtime
-/// context.
-pub(crate) fn try_enter(allow_blocking: bool) -> Option<Enter> {
-    ENTERED.with(|c| {
-        if c.get().is_entered() {
-            None
-        } else {
-            c.set(EnterContext::Entered { allow_blocking });
-            Some(Enter { _p: PhantomData })
+    /// Marks the current thread as being within the dynamic extent of an
+    /// executor.
+    pub(crate) fn enter(allow_blocking: bool) -> Enter {
+        if let Some(enter) = try_enter(allow_blocking) {
+            return enter;
         }
-    })
+
+        panic!(
+            "Cannot start a runtime from within a runtime. This happens \
+            because a function (like `block_on`) attempted to block the \
+            current thread while the thread is being used to drive \
+            asynchronous tasks."
+        );
+    }
+
+    /// Tries to enter a runtime context, returns `None` if already in a runtime
+    /// context.
+    pub(crate) fn try_enter(allow_blocking: bool) -> Option<Enter> {
+        ENTERED.with(|c| {
+            if c.get().is_entered() {
+                None
+            } else {
+                c.set(EnterContext::Entered { allow_blocking });
+                Some(Enter { _p: PhantomData })
+            }
+        })
+    }
 }
 
 // Forces the current "entered" state to be cleared while the closure
@@ -59,113 +65,92 @@ pub(crate) fn try_enter(allow_blocking: bool) -> Option<Enter> {
 //
 // This is hidden for a reason. Do not use without fully understanding
 // executors. Misuing can easily cause your program to deadlock.
-#[cfg(all(feature = "rt-threaded", feature = "blocking"))]
-pub(crate) fn exit<F: FnOnce() -> R, R>(f: F) -> R {
-    // Reset in case the closure panics
-    struct Reset(EnterContext);
-    impl Drop for Reset {
-        fn drop(&mut self) {
-            ENTERED.with(|c| {
-                assert!(!c.get().is_entered(), "closure claimed permanent executor");
-                c.set(self.0);
-            });
+cfg_rt_threaded! {
+    pub(crate) fn exit<F: FnOnce() -> R, R>(f: F) -> R {
+        // Reset in case the closure panics
+        struct Reset(EnterContext);
+        impl Drop for Reset {
+            fn drop(&mut self) {
+                ENTERED.with(|c| {
+                    assert!(!c.get().is_entered(), "closure claimed permanent executor");
+                    c.set(self.0);
+                });
+            }
         }
-    }
 
-    let was = ENTERED.with(|c| {
-        let e = c.get();
-        assert!(e.is_entered(), "asked to exit when not entered");
-        c.set(EnterContext::NotEntered);
-        e
-    });
+        let was = ENTERED.with(|c| {
+            let e = c.get();
+            assert!(e.is_entered(), "asked to exit when not entered");
+            c.set(EnterContext::NotEntered);
+            e
+        });
 
-    let _reset = Reset(was);
-    // dropping _reset after f() will reset ENTERED
-    f()
+        let _reset = Reset(was);
+        // dropping _reset after f() will reset ENTERED
+        f()
+    }
 }
 
-cfg_rt_core! {
-    cfg_rt_util! {
-        /// Disallow blocking in the current runtime context until the guard is dropped.
-        pub(crate) fn disallow_blocking() -> DisallowBlockingGuard {
-            let reset = ENTERED.with(|c| {
-                if let EnterContext::Entered {
-                    allow_blocking: true,
-                } = c.get()
-                {
-                    c.set(EnterContext::Entered {
-                        allow_blocking: false,
-                    });
-                    true
-                } else {
-                    false
-                }
-            });
-            DisallowBlockingGuard(reset)
-        }
+cfg_rt_util! {
+    /// Disallow blocking in the current runtime context until the guard is dropped.
+    pub(crate) fn disallow_blocking() -> DisallowBlockingGuard {
+        let reset = ENTERED.with(|c| {
+            if let EnterContext::Entered {
+                allow_blocking: true,
+            } = c.get()
+            {
+                c.set(EnterContext::Entered {
+                    allow_blocking: false,
+                });
+                true
+            } else {
+                false
+            }
+        });
+        DisallowBlockingGuard(reset)
+    }
 
-        pub(crate) struct DisallowBlockingGuard(bool);
-        impl Drop for DisallowBlockingGuard {
-            fn drop(&mut self) {
-                if self.0 {
-                    // XXX: Do we want some kind of assertion here, or is "best effort" okay?
-                    ENTERED.with(|c| {
-                        if let EnterContext::Entered {
-                            allow_blocking: false,
-                        } = c.get()
-                        {
-                            c.set(EnterContext::Entered {
-                                allow_blocking: true,
-                            });
-                        }
-                    })
-                }
+    pub(crate) struct DisallowBlockingGuard(bool);
+    impl Drop for DisallowBlockingGuard {
+        fn drop(&mut self) {
+            if self.0 {
+                // XXX: Do we want some kind of assertion here, or is "best effort" okay?
+                ENTERED.with(|c| {
+                    if let EnterContext::Entered {
+                        allow_blocking: false,
+                    } = c.get()
+                    {
+                        c.set(EnterContext::Entered {
+                            allow_blocking: true,
+                        });
+                    }
+                })
             }
         }
     }
 }
 
 cfg_rt_threaded! {
-    cfg_blocking! {
-        /// Returns true if in a runtime context.
-        pub(crate) fn context() -> EnterContext {
-            ENTERED.with(|c| c.get())
-        }
+    /// Returns true if in a runtime context.
+    pub(crate) fn context() -> EnterContext {
+        ENTERED.with(|c| c.get())
     }
 }
 
-impl Enter {
-    /// Blocks the thread on the specified future, returning the value with
-    /// which that future completes.
-    pub(crate) fn block_on<F>(&mut self, f: F) -> Result<F::Output, crate::park::ParkError>
-    where
-        F: std::future::Future,
-    {
-        use crate::park::{CachedParkThread, Park};
-        use std::task::Context;
-        use std::task::Poll::Ready;
-
-        let mut park = CachedParkThread::new();
-        let waker = park.get_unpark()?.into_waker();
-        let mut cx = Context::from_waker(&waker);
-
-        pin!(f);
-
-        loop {
-            if let Ready(v) = crate::coop::budget(|| f.as_mut().poll(&mut cx)) {
-                return Ok(v);
-            }
+cfg_rt_core! {
+    impl Enter {
+        /// Blocks the thread on the specified future, returning the value with
+        /// which that future completes.
+        pub(crate) fn block_on<F>(&mut self, f: F) -> Result<F::Output, ParkError>
+        where
+            F: std::future::Future,
+        {
+            use crate::park::thread::CachedParkThread;
 
-            park.park()?;
+            let mut park = CachedParkThread::new();
+            park.block_on(f)
         }
-    }
-}
 
-cfg_blocking_impl! {
-    use crate::park::ParkError;
-    use std::time::Duration;
-
-    impl Enter {
         /// Blocks the thread on the specified future for **at most** `timeout`
         ///
         /// If the future completes before `timeout`, the result is returned. If
@@ -174,7 +159,8 @@ cfg_blocking_impl! {
         where
             F: std::future::Future,
         {
-            use crate::park::{CachedParkThread, Park};
+            use crate::park::Park;
+            use crate::park::thread::CachedParkThread;
             use std::task::Context;
             use std::task::Poll::Ready;
             use std::time::Instant;