runtime: cleanup and add config options (#1807)

* runtime: cleanup and add config options

This patch finishes the cleanup as part of the transition to Tokio 0.2.
A number of changes were made to take advantage of having all Tokio
types in a single crate. Also, fixes using Tokio types from
`spawn_blocking`.

* Many threads, one resource driver

Previously, in the threaded scheduler, a resource driver (mio::Poll /
timer combo) was created per thread. This was more or less fine, except
it required balancing across the available drivers. When using a
resource driver from **outside** of the thread pool, balancing is
tricky. The change was original done to avoid having a dedicated driver
thread.

Now, instead of creating many resource drivers, a single resource driver
is used. Each scheduler thread will attempt to "lock" the resource
driver before parking on it. If the resource driver is already locked,
the thread uses a condition variable to park. Contention should remain
low as, under load, the scheduler avoids using the drivers.

* Add configuration options to enable I/O / time

New configuration options are added to `runtime::Builder` to allow
enabling I/O and time drivers on a runtime instance basis. This is
useful when wanting to create lightweight runtime instances to execute
compute only tasks.

* Bug fixes

The condition variable parker is updated to the same algorithm used in
`std`. This is motivated by some potential deadlock cases discovered by
`loom`.

The basic scheduler is fixed to fairly schedule tasks. `push_front` was
accidentally used instead of `push_back`.

I/O, time, and spawning now work from within `spawn_blocking` closures.

* Misc cleanup

The threaded scheduler is no longer generic over `P :Park`. Instead, it
is hard coded to a specific parker. Tests, including loom tests, are
updated to use `Runtime` directly. This provides greater coverage.

The `blocking` module is moved back into `runtime` as all usage is
within `runtime` itself.

1 files changed, 25 insertions, 25 deletions

diff --git a/tokio/src/runtime/enter.rs b/tokio/src/runtime/enter.rs
index a0925cb4..1995da63 100644
--- a/tokio/src/runtime/enter.rs
+++ b/tokio/src/runtime/enter.rs
@@ -46,36 +46,36 @@ pub(crate) fn try_enter() -> Option<Enter> {
 //
 // This is hidden for a reason. Do not use without fully understanding
 // executors. Misuing can easily cause your program to deadlock.
-cfg_rt_threaded! {
-    #[cfg(feature = "blocking")]
-    pub(crate) fn exit<F: FnOnce() -> R, R>(f: F) -> R {
-        // Reset in case the closure panics
-        struct Reset;
-        impl Drop for Reset {
-            fn drop(&mut self) {
-                ENTERED.with(|c| {
-                    c.set(true);
-                });
-            }
+#[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;
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            ENTERED.with(|c| {
+                c.set(true);
+            });
         }
+    }
 
-        ENTERED.with(|c| {
-            debug_assert!(c.get());
-            c.set(false);
-        });
+    ENTERED.with(|c| {
+        debug_assert!(c.get());
+        c.set(false);
+    });
 
-        let reset = Reset;
-        let ret = f();
-        ::std::mem::forget(reset);
+    let reset = Reset;
+    let ret = f();
+    ::std::mem::forget(reset);
 
-        ENTERED.with(|c| {
-            assert!(!c.get(), "closure claimed permanent executor");
-            c.set(true);
-        });
+    ENTERED.with(|c| {
+        assert!(!c.get(), "closure claimed permanent executor");
+        c.set(true);
+    });
 
-        ret
-    }
+    ret
+}
 
+cfg_blocking_impl! {
     impl Enter {
         /// Blocks the thread on the specified future, returning the value with
         /// which that future completes.
@@ -83,7 +83,7 @@ cfg_rt_threaded! {
         where
             F: std::future::Future,
         {
-            use crate::runtime::park::{CachedParkThread, Park};
+            use crate::park::{CachedParkThread, Park};
             use std::pin::Pin;
             use std::task::Context;
             use std::task::Poll::Ready;