From c90681bd8e629b5fde988b9f5be7b915e5cf8ae5 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Tue, 13 Oct 2020 06:13:23 +0900 Subject: rt: simplify rt-* features (#2949) tokio: merge rt-core and rt-util as rt rename rt-threaded to rt-multi-thread tokio-util: rename rt-core to rt Closes #2942 --- tokio/Cargo.toml | 12 ++++----- tokio/src/blocking.rs | 6 ++--- tokio/src/coop.rs | 6 ++--- tokio/src/future/block_on.rs | 4 +-- tokio/src/io/driver/mod.rs | 12 ++++----- tokio/src/lib.rs | 40 ++++++++++++++-------------- tokio/src/loom/std/mod.rs | 4 +-- tokio/src/macros/cfg.rs | 56 ++++++++++------------------------------ tokio/src/macros/mod.rs | 2 +- tokio/src/park/mod.rs | 4 +-- tokio/src/process/unix/driver.rs | 2 +- tokio/src/runtime/builder.rs | 8 +++--- tokio/src/runtime/context.rs | 2 +- tokio/src/runtime/enter.rs | 12 ++++----- tokio/src/runtime/mod.rs | 30 ++++++++++----------- tokio/src/runtime/spawner.rs | 16 ++++++------ tokio/src/runtime/task/core.rs | 2 +- tokio/src/runtime/task/error.rs | 2 +- tokio/src/runtime/task/join.rs | 2 +- tokio/src/runtime/task/mod.rs | 8 +++--- tokio/src/signal/unix/driver.rs | 8 +++--- tokio/src/sync/mod.rs | 4 +-- tokio/src/sync/notify.rs | 4 +-- tokio/src/task/blocking.rs | 2 +- tokio/src/task/local.rs | 8 +++--- tokio/src/task/mod.rs | 14 ++++------ tokio/src/task/spawn.rs | 2 +- tokio/src/task/yield_now.rs | 2 +- tokio/src/time/clock.rs | 6 ++--- tokio/src/time/driver/handle.rs | 6 ++--- tokio/src/time/driver/mod.rs | 2 +- tokio/src/util/linked_list.rs | 2 +- tokio/src/util/mod.rs | 9 +++---- tokio/src/util/slab.rs | 2 +- tokio/src/util/trace.rs | 4 +-- 35 files changed, 133 insertions(+), 172 deletions(-) (limited to 'tokio') diff --git a/tokio/Cargo.toml b/tokio/Cargo.toml index 5b361e6b..6b0c4d8c 100644 --- a/tokio/Cargo.toml +++ b/tokio/Cargo.toml @@ -37,9 +37,8 @@ full = [ "macros", "net", "process", - "rt-core", - "rt-util", - "rt-threaded", + "rt", + "rt-multi-thread", "signal", "stream", "sync", @@ -71,11 +70,10 @@ process = [ "winapi/threadpoollegacyapiset", ] # Includes basic task execution capabilities -rt-core = ["slab"] -rt-util = [] -rt-threaded = [ +rt = ["slab"] +rt-multi-thread = [ "num_cpus", - "rt-core", + "rt", ] signal = [ "lazy_static", diff --git a/tokio/src/blocking.rs b/tokio/src/blocking.rs index d6ef5915..f88b1db1 100644 --- a/tokio/src/blocking.rs +++ b/tokio/src/blocking.rs @@ -1,9 +1,9 @@ -cfg_rt_core! { +cfg_rt! { pub(crate) use crate::runtime::spawn_blocking; pub(crate) use crate::task::JoinHandle; } -cfg_not_rt_core! { +cfg_not_rt! { use std::fmt; use std::future::Future; use std::pin::Pin; @@ -15,7 +15,7 @@ cfg_not_rt_core! { R: Send + 'static, { assert_send_sync::>>(); - panic!("requires the `rt-core` Tokio feature flag") + panic!("requires the `rt` Tokio feature flag") } diff --git a/tokio/src/coop.rs b/tokio/src/coop.rs index f6cca1c5..980cdf8c 100644 --- a/tokio/src/coop.rs +++ b/tokio/src/coop.rs @@ -83,7 +83,7 @@ impl Budget { } } -cfg_rt_threaded! { +cfg_rt_multi_thread! { impl Budget { fn has_remaining(self) -> bool { self.0.map(|budget| budget > 0).unwrap_or(true) @@ -122,7 +122,7 @@ fn with_budget(budget: Budget, f: impl FnOnce() -> R) -> R { }) } -cfg_rt_threaded! { +cfg_rt_multi_thread! { /// Set the current task's budget pub(crate) fn set(budget: Budget) { CURRENT.with(|cell| cell.set(budget)) @@ -134,7 +134,7 @@ cfg_rt_threaded! { } } -cfg_rt_core! { +cfg_rt! { /// Forcibly remove the budgeting constraints early. /// /// Returns the remaining budget diff --git a/tokio/src/future/block_on.rs b/tokio/src/future/block_on.rs index 9fc7abc6..91f9cc00 100644 --- a/tokio/src/future/block_on.rs +++ b/tokio/src/future/block_on.rs @@ -1,13 +1,13 @@ use std::future::Future; -cfg_rt_core! { +cfg_rt! { pub(crate) fn block_on(f: F) -> F::Output { let mut e = crate::runtime::enter::enter(false); e.block_on(f).unwrap() } } -cfg_not_rt_core! { +cfg_not_rt! { pub(crate) fn block_on(f: F) -> F::Output { let mut park = crate::park::thread::CachedParkThread::new(); park.block_on(f).unwrap() diff --git a/tokio/src/io/driver/mod.rs b/tokio/src/io/driver/mod.rs index 0d4133a5..cd82b26f 100644 --- a/tokio/src/io/driver/mod.rs +++ b/tokio/src/io/driver/mod.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] mod ready; use ready::Ready; @@ -219,13 +219,13 @@ impl fmt::Debug for Driver { // ===== impl Handle ===== -cfg_rt_core! { +cfg_rt! { impl Handle { /// Returns a handle to the current reactor /// /// # Panics /// - /// This function panics if there is no current reactor set and `rt-core` feature + /// This function panics if there is no current reactor set and `rt` feature /// flag is not enabled. pub(super) fn current() -> Self { crate::runtime::context::io_handle() @@ -234,16 +234,16 @@ cfg_rt_core! { } } -cfg_not_rt_core! { +cfg_not_rt! { impl Handle { /// Returns a handle to the current reactor /// /// # Panics /// - /// This function panics if there is no current reactor set, or if the `rt-core` + /// This function panics if there is no current reactor set, or if the `rt` /// feature flag is not enabled. pub(super) fn current() -> Self { - panic!("there is no reactor running, must be called from the context of Tokio runtime with `rt-core` enabled.") + panic!("there is no reactor running, must be called from the context of Tokio runtime with `rt` enabled.") } } } diff --git a/tokio/src/lib.rs b/tokio/src/lib.rs index 92d2c35d..483f13ed 100644 --- a/tokio/src/lib.rs +++ b/tokio/src/lib.rs @@ -73,9 +73,9 @@ //! need. //! //! - `full`: Enables all Tokio public API features listed below. -//! - `rt-core`: Enables `tokio::spawn` and the basic (single-threaded) scheduler. -//! - `rt-threaded`: Enables the heavier, multi-threaded, work-stealing scheduler. -//! - `rt-util`: Enables non-scheduler utilities. +//! - `rt-core`: Enables `tokio::spawn`, the basic (current thread) scheduler, +//! and non-scheduler utilities. +//! - `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler. //! - `io-util`: Enables the IO based `Ext` traits. //! - `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types. //! - `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and `UdpSocket`. @@ -134,7 +134,7 @@ //! needs to `tokio::spawn` and use a `TcpStream`. //! //! ```toml -//! tokio = { version = "0.2", features = ["rt-core", "net"] } +//! tokio = { version = "0.2", features = ["rt", "net"] } //! ``` //! //! ## Working With Tasks @@ -148,7 +148,7 @@ //! * Functions for [running blocking operations][blocking] in an asynchronous //! task context. //! -//! The [`tokio::task`] module is present only when the "rt-core" feature flag +//! The [`tokio::task`] module is present only when the "rt" feature flag //! is enabled. //! //! [tasks]: task/index.html#what-are-tasks @@ -196,9 +196,9 @@ //! and managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't //! provide the functionality you need. //! -//! Using the runtime requires the "rt-core" or "rt-threaded" feature flags, to -//! enable the basic [single-threaded scheduler][rt-core] and the [thread-pool -//! scheduler][rt-threaded], respectively. See the [`runtime` module +//! Using the runtime requires the "rt" or "rt-multi-thread" feature flags, to +//! enable the basic [single-threaded scheduler][rt] and the [thread-pool +//! scheduler][rt-multi-thread], respectively. See the [`runtime` module //! documentation][rt-features] for details. In addition, the "macros" feature //! flag enables the `#[tokio::main]` and `#[tokio::test]` attributes. //! @@ -206,8 +206,8 @@ //! [`tokio::runtime`]: crate::runtime //! [`Builder`]: crate::runtime::Builder //! [`Runtime`]: crate::runtime::Runtime -//! [rt-core]: runtime/index.html#basic-scheduler -//! [rt-threaded]: runtime/index.html#threaded-scheduler +//! [rt]: runtime/index.html#basic-scheduler +//! [rt-multi-thread]: runtime/index.html#threaded-scheduler //! [rt-features]: runtime/index.html#runtime-scheduler //! //! ## CPU-bound tasks and blocking code @@ -362,11 +362,9 @@ cfg_process! { #[cfg(any(feature = "dns", feature = "fs", feature = "io-std"))] mod blocking; -cfg_rt_core! { +cfg_rt! { pub mod runtime; } -#[cfg(all(not(feature = "rt-core"), feature = "rt-util"))] -mod runtime; pub(crate) mod coop; @@ -393,7 +391,7 @@ cfg_not_sync! { } pub mod task; -cfg_rt_core! { +cfg_rt! { pub use task::spawn; } @@ -410,8 +408,8 @@ cfg_macros! { #[doc(hidden)] pub use tokio_macros::select_priv_declare_output_enum; - doc_rt_core! { - cfg_rt_threaded! { + cfg_rt! { + cfg_rt_multi_thread! { // This is the docs.rs case (with all features) so make sure macros // is included in doc(cfg). @@ -423,15 +421,15 @@ cfg_macros! { pub use tokio_macros::test; } - cfg_not_rt_threaded! { + cfg_not_rt_multi_thread! { #[cfg(not(test))] // Work around for rust-lang/rust#62127 - pub use tokio_macros::main_rt_core as main; - pub use tokio_macros::test_rt_core as test; + pub use tokio_macros::main_rt as main; + pub use tokio_macros::test_rt as test; } } - // Always fail if rt-core is not enabled. - cfg_not_rt_core! { + // Always fail if rt is not enabled. + cfg_not_rt! { #[cfg(not(test))] pub use tokio_macros::main_fail as main; pub use tokio_macros::test_fail as test; diff --git a/tokio/src/loom/std/mod.rs b/tokio/src/loom/std/mod.rs index fc32fc9f..95252868 100644 --- a/tokio/src/loom/std/mod.rs +++ b/tokio/src/loom/std/mod.rs @@ -79,12 +79,12 @@ pub(crate) mod sync { } pub(crate) mod sys { - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] pub(crate) fn num_cpus() -> usize { usize::max(1, num_cpus::get()) } - #[cfg(not(feature = "rt-threaded"))] + #[cfg(not(feature = "rt-multi-thread"))] pub(crate) fn num_cpus() -> usize { 1 } diff --git a/tokio/src/macros/cfg.rs b/tokio/src/macros/cfg.rs index 849fb42b..fedef7ad 100644 --- a/tokio/src/macros/cfg.rs +++ b/tokio/src/macros/cfg.rs @@ -8,7 +8,7 @@ macro_rules! cfg_block_on { feature = "fs", feature = "dns", feature = "io-std", - feature = "rt-core", + feature = "rt", ))] $item )* @@ -22,7 +22,7 @@ macro_rules! cfg_atomic_waker_impl { #[cfg(any( feature = "net", feature = "process", - feature = "rt-util", + feature = "rt", feature = "signal", feature = "time", ))] @@ -251,64 +251,35 @@ macro_rules! cfg_not_sync { } } -macro_rules! cfg_rt_core { +macro_rules! cfg_rt { ($($item:item)*) => { $( - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] + #[cfg_attr(docsrs, doc(cfg(feature = "rt")))] $item )* } } -macro_rules! cfg_task { +macro_rules! cfg_not_rt { ($($item:item)*) => { - $( - #[cfg(any(feature = "rt-core", feature = "rt-util"))] - #[cfg_attr(docsrs, doc(cfg(any(feature = "rt-core", feature = "rt-util"))))] - $item - )* - } -} - -macro_rules! doc_rt_core { - ($($item:item)*) => { - $( - #[cfg(feature = "rt-core")] - #[cfg_attr(docsrs, doc(cfg(feature = "rt-core")))] - $item - )* - } -} - -macro_rules! cfg_not_rt_core { - ($($item:item)*) => { - $( #[cfg(not(feature = "rt-core"))] $item )* - } -} - -macro_rules! cfg_rt_threaded { - ($($item:item)*) => { - $( - #[cfg(feature = "rt-threaded")] - #[cfg_attr(docsrs, doc(cfg(feature = "rt-threaded")))] - $item - )* + $( #[cfg(not(feature = "rt"))] $item )* } } -macro_rules! cfg_rt_util { +macro_rules! cfg_rt_multi_thread { ($($item:item)*) => { $( - #[cfg(feature = "rt-util")] - #[cfg_attr(docsrs, doc(cfg(feature = "rt-util")))] + #[cfg(feature = "rt-multi-thread")] + #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))] $item )* } } -macro_rules! cfg_not_rt_threaded { +macro_rules! cfg_not_rt_multi_thread { ($($item:item)*) => { - $( #[cfg(not(feature = "rt-threaded"))] $item )* + $( #[cfg(not(feature = "rt-multi-thread"))] $item )* } } @@ -372,8 +343,7 @@ macro_rules! cfg_coop { feature = "io-std", feature = "net", feature = "process", - feature = "rt-core", - feature = "rt-util", + feature = "rt", feature = "signal", feature = "sync", feature = "stream", diff --git a/tokio/src/macros/mod.rs b/tokio/src/macros/mod.rs index a9d87657..b0af5215 100644 --- a/tokio/src/macros/mod.rs +++ b/tokio/src/macros/mod.rs @@ -16,7 +16,7 @@ mod ready; mod thread_local; #[macro_use] -#[cfg(any(feature = "rt-core", feature = "rt-util"))] +#[cfg(feature = "rt")] pub(crate) mod scoped_tls; cfg_macros! { diff --git a/tokio/src/park/mod.rs b/tokio/src/park/mod.rs index e4b97512..5db26ce7 100644 --- a/tokio/src/park/mod.rs +++ b/tokio/src/park/mod.rs @@ -34,11 +34,11 @@ //! * `park_timeout` does the same as `park` but allows specifying a maximum //! time to block the thread for. -cfg_rt_core! { +cfg_rt! { pub(crate) mod either; } -#[cfg(any(feature = "rt-core", feature = "rt-util", feature = "sync"))] +#[cfg(any(feature = "rt", feature = "sync"))] pub(crate) mod thread; use std::sync::Arc; diff --git a/tokio/src/process/unix/driver.rs b/tokio/src/process/unix/driver.rs index 62fe8095..9a16cad5 100644 --- a/tokio/src/process/unix/driver.rs +++ b/tokio/src/process/unix/driver.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] //! Process driver diff --git a/tokio/src/runtime/builder.rs b/tokio/src/runtime/builder.rs index 27981d33..735e9b6a 100644 --- a/tokio/src/runtime/builder.rs +++ b/tokio/src/runtime/builder.rs @@ -73,7 +73,7 @@ pub(crate) type ThreadNameFn = std::sync::Arc String + Send + Sync + pub(crate) enum Kind { CurrentThread, - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] MultiThread, } @@ -84,7 +84,7 @@ impl Builder { } /// TODO - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] pub fn new_multi_thread() -> Builder { Builder::new(Kind::MultiThread) } @@ -365,7 +365,7 @@ impl Builder { pub fn build(&mut self) -> io::Result { match &self.kind { Kind::CurrentThread => self.build_basic_runtime(), - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] Kind::MultiThread => self.build_threaded_runtime(), } } @@ -477,7 +477,7 @@ cfg_time! { } } -cfg_rt_threaded! { +cfg_rt_multi_thread! { impl Builder { fn build_threaded_runtime(&mut self) -> io::Result { use crate::loom::sys::num_cpus; diff --git a/tokio/src/runtime/context.rs b/tokio/src/runtime/context.rs index e28d5282..9dfca8d8 100644 --- a/tokio/src/runtime/context.rs +++ b/tokio/src/runtime/context.rs @@ -48,7 +48,7 @@ cfg_time! { } } -cfg_rt_core! { +cfg_rt! { pub(crate) fn spawn_handle() -> Option { CONTEXT.with(|ctx| match *ctx.borrow() { Some(ref ctx) => Some(ctx.spawner.clone()), diff --git a/tokio/src/runtime/enter.rs b/tokio/src/runtime/enter.rs index 79ed4d17..4dd8dd01 100644 --- a/tokio/src/runtime/enter.rs +++ b/tokio/src/runtime/enter.rs @@ -4,7 +4,7 @@ use std::marker::PhantomData; #[derive(Debug, Clone, Copy)] pub(crate) enum EnterContext { - #[cfg_attr(not(feature = "rt-core"), allow(dead_code))] + #[cfg_attr(not(feature = "rt"), allow(dead_code))] Entered { allow_blocking: bool, }, @@ -24,7 +24,7 @@ pub(crate) struct Enter { _p: PhantomData>, } -cfg_rt_core! { +cfg_rt! { use crate::park::thread::ParkError; use std::time::Duration; @@ -65,7 +65,7 @@ cfg_rt_core! { // // 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_rt_multi_thread! { pub(crate) fn exit R, R>(f: F) -> R { // Reset in case the closure panics struct Reset(EnterContext); @@ -91,7 +91,7 @@ cfg_rt_threaded! { } } -cfg_rt_util! { +cfg_rt! { /// Disallow blocking in the current runtime context until the guard is dropped. pub(crate) fn disallow_blocking() -> DisallowBlockingGuard { let reset = ENTERED.with(|c| { @@ -130,14 +130,14 @@ cfg_rt_util! { } } -cfg_rt_threaded! { +cfg_rt_multi_thread! { /// Returns true if in a runtime context. pub(crate) fn context() -> EnterContext { ENTERED.with(|c| c.get()) } } -cfg_rt_core! { +cfg_rt! { impl Enter { /// Blocks the thread on the specified future, returning the value with /// which that future completes. diff --git a/tokio/src/runtime/mod.rs b/tokio/src/runtime/mod.rs index c79a942f..7712a7f8 100644 --- a/tokio/src/runtime/mod.rs +++ b/tokio/src/runtime/mod.rs @@ -114,7 +114,7 @@ //! //! The current-thread scheduler provides a _single-threaded_ future executor. //! All tasks will be created and executed on the current thread. This requires -//! the `rt-core` feature flag. +//! the `rt` feature flag. //! ``` //! use tokio::runtime; //! @@ -129,7 +129,7 @@ //! The multi-thread scheduler executes futures on a _thread pool_, using a //! work-stealing strategy. By default, it will start a worker thread for each //! CPU core available on the system. This tends to be the ideal configurations -//! for most applications. The multi-thread scheduler requires the `rt-threaded` +//! for most applications. The multi-thread scheduler requires the `rt-multi-thread` //! feature flag, and is selected by default: //! ``` //! use tokio::runtime; @@ -181,7 +181,7 @@ pub(crate) mod enter; pub(crate) mod task; -cfg_rt_core! { +cfg_rt! { mod basic_scheduler; use basic_scheduler::BasicScheduler; @@ -204,19 +204,19 @@ cfg_rt_core! { use self::spawner::Spawner; } -cfg_rt_threaded! { +cfg_rt_multi_thread! { mod park; use park::Parker; } -cfg_rt_threaded! { +cfg_rt_multi_thread! { mod queue; pub(crate) mod thread_pool; use self::thread_pool::ThreadPool; } -cfg_rt_core! { +cfg_rt! { use crate::task::JoinHandle; use std::future::Future; @@ -266,11 +266,11 @@ cfg_rt_core! { #[derive(Debug)] enum Kind { /// Execute all tasks on the current-thread. - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] CurrentThread(BasicScheduler), /// Execute tasks across multiple threads. - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] ThreadPool(ThreadPool), } @@ -282,8 +282,8 @@ cfg_rt_core! { /// /// This results in a scheduler, I/O driver, and time driver being /// initialized. The type of scheduler used depends on what feature flags - /// are enabled: if the `rt-threaded` feature is enabled, the [threaded - /// scheduler] is used, while if only the `rt-core` feature is enabled, the + /// are enabled: if the `rt-multi-thread` feature is enabled, the [threaded + /// scheduler] is used, while if only the `rt` feature is enabled, the /// [basic scheduler] is used instead. /// /// If the threaded scheduler is selected, it will not spawn @@ -313,7 +313,7 @@ cfg_rt_core! { /// [threaded scheduler]: index.html#threaded-scheduler /// [basic scheduler]: index.html#basic-scheduler /// [runtime builder]: crate::runtime::Builder - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] pub fn new() -> std::io::Result { Builder::new_multi_thread().enable_all().build() } @@ -343,14 +343,14 @@ cfg_rt_core! { /// }); /// # } /// ``` - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] pub fn spawn(&self, future: F) -> JoinHandle where F: Future + Send + 'static, F::Output: Send + 'static, { match &self.kind { - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] Kind::ThreadPool(exec) => exec.spawn(future), Kind::CurrentThread(exec) => exec.spawn(future), } @@ -393,9 +393,9 @@ cfg_rt_core! { /// [handle]: fn@Handle::block_on pub fn block_on(&self, future: F) -> F::Output { self.handle.enter(|| match &self.kind { - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] Kind::CurrentThread(exec) => exec.block_on(future), - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] Kind::ThreadPool(exec) => exec.block_on(future), }) } diff --git a/tokio/src/runtime/spawner.rs b/tokio/src/runtime/spawner.rs index 28ff7c04..a37c6679 100644 --- a/tokio/src/runtime/spawner.rs +++ b/tokio/src/runtime/spawner.rs @@ -1,25 +1,25 @@ -cfg_rt_core! { +cfg_rt! { use crate::runtime::basic_scheduler; use crate::task::JoinHandle; use std::future::Future; } -cfg_rt_threaded! { +cfg_rt_multi_thread! { use crate::runtime::thread_pool; } #[derive(Debug, Clone)] pub(crate) enum Spawner { - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] Basic(basic_scheduler::Spawner), - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] ThreadPool(thread_pool::Spawner), } impl Spawner { pub(crate) fn shutdown(&mut self) { - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] { if let Spawner::ThreadPool(spawner) = self { spawner.shutdown(); @@ -28,7 +28,7 @@ impl Spawner { } } -cfg_rt_core! { +cfg_rt! { impl Spawner { pub(crate) fn spawn(&self, future: F) -> JoinHandle where @@ -36,9 +36,9 @@ cfg_rt_core! { F::Output: Send + 'static, { match self { - #[cfg(feature = "rt-core")] + #[cfg(feature = "rt")] Spawner::Basic(spawner) => spawner.spawn(future), - #[cfg(feature = "rt-threaded")] + #[cfg(feature = "rt-multi-thread")] Spawner::ThreadPool(spawner) => spawner.spawn(future), } } diff --git a/tokio/src/runtime/task/core.rs b/tokio/src/runtime/task/core.rs index f4756c23..dfa87641 100644 --- a/tokio/src/runtime/task/core.rs +++ b/tokio/src/runtime/task/core.rs @@ -269,7 +269,7 @@ impl Core { } } -cfg_rt_threaded! { +cfg_rt_multi_thread! { impl Header { pub(crate) fn shutdown(&self) { use crate::runtime::task::RawTask; diff --git a/tokio/src/runtime/task/error.rs b/tokio/src/runtime/task/error.rs index 4197ba60..177fe65e 100644 --- a/tokio/src/runtime/task/error.rs +++ b/tokio/src/runtime/task/error.rs @@ -3,7 +3,7 @@ use std::fmt; use std::io; use std::sync::Mutex; -cfg_task! { +cfg_rt! { /// Task failed to execute to completion. pub struct JoinError { repr: Repr, diff --git a/tokio/src/runtime/task/join.rs b/tokio/src/runtime/task/join.rs index a63f5740..dedfb387 100644 --- a/tokio/src/runtime/task/join.rs +++ b/tokio/src/runtime/task/join.rs @@ -6,7 +6,7 @@ use std::marker::PhantomData; use std::pin::Pin; use std::task::{Context, Poll}; -cfg_task! { +cfg_rt! { /// An owned permission to join on a task (await its termination). /// /// This can be thought of as the equivalent of [`std::thread::JoinHandle`] for diff --git a/tokio/src/runtime/task/mod.rs b/tokio/src/runtime/task/mod.rs index d30a467f..7b49e95a 100644 --- a/tokio/src/runtime/task/mod.rs +++ b/tokio/src/runtime/task/mod.rs @@ -21,7 +21,7 @@ use self::state::State; mod waker; -cfg_rt_threaded! { +cfg_rt_multi_thread! { mod stack; pub(crate) use self::stack::TransferStack; } @@ -79,7 +79,7 @@ pub(crate) trait Schedule: Sync + Sized + 'static { } } -cfg_rt_core! { +cfg_rt! { /// Create a new task with an associated join handle pub(crate) fn joinable(task: T) -> (Notified, JoinHandle) where @@ -99,7 +99,7 @@ cfg_rt_core! { } } -cfg_rt_util! { +cfg_rt! { /// Create a new `!Send` task with an associated join handle pub(crate) unsafe fn joinable_local(task: T) -> (Notified, JoinHandle) where @@ -132,7 +132,7 @@ impl Task { } } -cfg_rt_threaded! { +cfg_rt_multi_thread! { impl Notified { pub(crate) unsafe fn from_raw(ptr: NonNull
) -> Notified { Notified(Task::from_raw(ptr)) diff --git a/tokio/src/signal/unix/driver.rs b/tokio/src/signal/unix/driver.rs index d4a49783..8e5ed7d0 100644 --- a/tokio/src/signal/unix/driver.rs +++ b/tokio/src/signal/unix/driver.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] //! Signal driver @@ -175,7 +175,7 @@ impl Handle { } } -cfg_rt_core! { +cfg_rt! { impl Handle { /// Returns a handle to the current driver /// @@ -190,7 +190,7 @@ cfg_rt_core! { } } -cfg_not_rt_core! { +cfg_not_rt! { impl Handle { /// Returns a handle to the current driver /// @@ -200,7 +200,7 @@ cfg_not_rt_core! { pub(super) fn current() -> Self { panic!( "there is no signal driver running, must be called from the context of Tokio runtime or with\ - `rt-core` enabled.", + `rt` enabled.", ) } } diff --git a/tokio/src/sync/mod.rs b/tokio/src/sync/mod.rs index ddb289eb..57ae2778 100644 --- a/tokio/src/sync/mod.rs +++ b/tokio/src/sync/mod.rs @@ -464,7 +464,7 @@ cfg_not_sync! { pub(crate) use mutex::Mutex; } - #[cfg(any(feature = "rt-core", feature = "signal", all(unix, feature = "process")))] + #[cfg(any(feature = "rt", feature = "signal", all(unix, feature = "process")))] pub(crate) mod notify; cfg_atomic_waker_impl! { @@ -473,7 +473,7 @@ cfg_not_sync! { } #[cfg(any( - feature = "rt-core", + feature = "rt", feature = "process", feature = "signal"))] pub(crate) mod oneshot; diff --git a/tokio/src/sync/notify.rs b/tokio/src/sync/notify.rs index 17117bfe..922f1095 100644 --- a/tokio/src/sync/notify.rs +++ b/tokio/src/sync/notify.rs @@ -1,7 +1,7 @@ // Allow `unreachable_pub` warnings when sync is not enabled -// due to the usage of `Notify` within the `rt-core` feature set. +// due to the usage of `Notify` within the `rt` feature set. // When this module is compiled with `sync` enabled we will warn on -// this lint. When `rt-core` is enabled we use `pub(crate)` which +// this lint. When `rt` is enabled we use `pub(crate)` which // triggers this warning but it is safe to ignore in this case. #![cfg_attr(not(feature = "sync"), allow(unreachable_pub, dead_code))] diff --git a/tokio/src/task/blocking.rs b/tokio/src/task/blocking.rs index 5f9d8af7..4c14db1b 100644 --- a/tokio/src/task/blocking.rs +++ b/tokio/src/task/blocking.rs @@ -1,6 +1,6 @@ use crate::task::JoinHandle; -cfg_rt_threaded! { +cfg_rt_multi_thread! { /// Runs the provided blocking function on the current thread without /// blocking the executor. /// diff --git a/tokio/src/task/local.rs b/tokio/src/task/local.rs index e19cbe63..5896126c 100644 --- a/tokio/src/task/local.rs +++ b/tokio/src/task/local.rs @@ -14,7 +14,7 @@ use std::task::Poll; use pin_project_lite::pin_project; -cfg_rt_util! { +cfg_rt! { /// A set of tasks which are executed on the same thread. /// /// In some cases, it is necessary to run one or more futures that do not @@ -158,7 +158,7 @@ pin_project! { scoped_thread_local!(static CURRENT: Context); -cfg_rt_util! { +cfg_rt! { /// Spawns a `!Send` future on the local task set. /// /// The spawned future will be run on the same thread that called `spawn_local.` @@ -346,8 +346,8 @@ impl LocalSet { /// [`Runtime::block_on`]: method@crate::runtime::Runtime::block_on /// [in-place blocking]: fn@crate::task::block_in_place /// [`spawn_blocking`]: fn@crate::task::spawn_blocking - #[cfg(feature = "rt-core")] - #[cfg_attr(docsrs, doc(cfg(feature = "rt-core")))] + #[cfg(feature = "rt")] + #[cfg_attr(docsrs, doc(cfg(feature = "rt")))] pub fn block_on(&self, rt: &crate::runtime::Runtime, future: F) -> F::Output where F: Future, diff --git a/tokio/src/task/mod.rs b/tokio/src/task/mod.rs index 860c8929..5dc5e72c 100644 --- a/tokio/src/task/mod.rs +++ b/tokio/src/task/mod.rs @@ -102,7 +102,7 @@ //! # } //! ``` //! -//! `spawn`, `JoinHandle`, and `JoinError` are present when the "rt-core" +//! `spawn`, `JoinHandle`, and `JoinError` are present when the "rt" //! feature flag is enabled. //! //! [`task::spawn`]: crate::task::spawn() @@ -159,7 +159,7 @@ //! //! #### block_in_place //! -//! When using the [threaded runtime][rt-threaded], the [`task::block_in_place`] +//! When using the [multi-threaded runtime][rt-multi-thread], the [`task::block_in_place`] //! function is also available. Like `task::spawn_blocking`, this function //! allows running a blocking operation from an asynchronous context. Unlike //! `spawn_blocking`, however, `block_in_place` works by transitioning the @@ -211,27 +211,23 @@ //! //! [`task::spawn_blocking`]: crate::task::spawn_blocking //! [`task::block_in_place`]: crate::task::block_in_place -//! [rt-threaded]: ../runtime/index.html#threaded-scheduler +//! [rt-multi-thread]: ../runtime/index.html#threaded-scheduler //! [`task::yield_now`]: crate::task::yield_now() //! [`thread::yield_now`]: std::thread::yield_now -cfg_task! { +cfg_rt! { pub use crate::runtime::task::{JoinError, JoinHandle}; -} -cfg_rt_core! { mod blocking; pub use blocking::spawn_blocking; mod spawn; pub use spawn::spawn; - cfg_rt_threaded! { + cfg_rt_multi_thread! { pub use blocking::block_in_place; } -} -cfg_rt_util! { mod yield_now; pub use yield_now::yield_now; diff --git a/tokio/src/task/spawn.rs b/tokio/src/task/spawn.rs index d7aca572..77acb579 100644 --- a/tokio/src/task/spawn.rs +++ b/tokio/src/task/spawn.rs @@ -3,7 +3,7 @@ use crate::task::JoinHandle; use std::future::Future; -doc_rt_core! { +cfg_rt! { /// Spawns a new asynchronous task, returning a /// [`JoinHandle`](super::JoinHandle) for it. /// diff --git a/tokio/src/task/yield_now.rs b/tokio/src/task/yield_now.rs index 97e2db2c..251cb931 100644 --- a/tokio/src/task/yield_now.rs +++ b/tokio/src/task/yield_now.rs @@ -2,7 +2,7 @@ use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; -cfg_rt_util! { +cfg_rt! { /// Yields execution back to the Tokio runtime. /// /// A task yields by awaiting on `yield_now()`, and may resume when that diff --git a/tokio/src/time/clock.rs b/tokio/src/time/clock.rs index c35fc7b3..fab7ecaf 100644 --- a/tokio/src/time/clock.rs +++ b/tokio/src/time/clock.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] //! Source of time abstraction. //! @@ -39,13 +39,13 @@ cfg_test_util! { use crate::time::{Duration, Instant}; use std::sync::{Arc, Mutex}; - cfg_rt_core! { + cfg_rt! { fn clock() -> Option { crate::runtime::context::clock() } } - cfg_not_rt_core! { + cfg_not_rt! { fn clock() -> Option { None } diff --git a/tokio/src/time/driver/handle.rs b/tokio/src/time/driver/handle.rs index 93d8cd7b..54b8a8bd 100644 --- a/tokio/src/time/driver/handle.rs +++ b/tokio/src/time/driver/handle.rs @@ -20,7 +20,7 @@ impl Handle { } } -cfg_rt_core! { +cfg_rt! { impl Handle { /// Tries to get a handle to the current timer. /// @@ -45,7 +45,7 @@ cfg_rt_core! { } } -cfg_not_rt_core! { +cfg_not_rt! { impl Handle { /// Tries to get a handle to the current timer. /// @@ -65,7 +65,7 @@ cfg_not_rt_core! { /// panicking. pub(crate) fn current() -> Self { panic!("there is no timer running, must be called from the context of Tokio runtime or \ - `rt-core` is not enabled") + `rt` is not enabled") } } } diff --git a/tokio/src/time/driver/mod.rs b/tokio/src/time/driver/mod.rs index d2e58954..8532c551 100644 --- a/tokio/src/time/driver/mod.rs +++ b/tokio/src/time/driver/mod.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] //! Time driver diff --git a/tokio/src/util/linked_list.rs b/tokio/src/util/linked_list.rs index 6aa227c2..46812766 100644 --- a/tokio/src/util/linked_list.rs +++ b/tokio/src/util/linked_list.rs @@ -203,7 +203,7 @@ impl Default for LinkedList { // ===== impl Iter ===== -cfg_rt_threaded! { +cfg_rt_multi_thread! { pub(crate) struct Iter<'a, T: Link> { curr: Option>, _p: core::marker::PhantomData<&'a T>, diff --git a/tokio/src/util/mod.rs b/tokio/src/util/mod.rs index ea6c6715..b2043dd6 100644 --- a/tokio/src/util/mod.rs +++ b/tokio/src/util/mod.rs @@ -7,23 +7,22 @@ cfg_io_driver! { feature = "fs", feature = "net", feature = "process", - feature = "rt-core", - feature = "rt-util", + feature = "rt", feature = "sync", feature = "signal", ))] pub(crate) mod linked_list; -#[cfg(any(feature = "rt-threaded", feature = "macros", feature = "stream"))] +#[cfg(any(feature = "rt-multi-thread", feature = "macros", feature = "stream"))] mod rand; -cfg_rt_core! { +cfg_rt! { mod wake; pub(crate) use wake::WakerRef; pub(crate) use wake::{waker_ref, Wake}; } -cfg_rt_threaded! { +cfg_rt_multi_thread! { pub(crate) use rand::FastRand; mod try_lock; diff --git a/tokio/src/util/slab.rs b/tokio/src/util/slab.rs index d5af2658..0ab46adc 100644 --- a/tokio/src/util/slab.rs +++ b/tokio/src/util/slab.rs @@ -1,4 +1,4 @@ -#![cfg_attr(not(feature = "rt-core"), allow(dead_code))] +#![cfg_attr(not(feature = "rt"), allow(dead_code))] use crate::loom::cell::UnsafeCell; use crate::loom::sync::atomic::{AtomicBool, AtomicUsize}; diff --git a/tokio/src/util/trace.rs b/tokio/src/util/trace.rs index adec5502..18956a36 100644 --- a/tokio/src/util/trace.rs +++ b/tokio/src/util/trace.rs @@ -1,5 +1,5 @@ cfg_trace! { - cfg_task! { + cfg_rt! { use std::future::Future; use std::pin::Pin; use std::task::{Context, Poll}; @@ -47,7 +47,7 @@ cfg_trace! { } cfg_not_trace! { - cfg_task! { + cfg_rt! { #[inline] pub(crate) fn task(task: F, _: &'static str) -> F { // nop -- cgit v1.2.3