From 24d0a0cfa8916eaef17f40f044d978aa3904d654 Mon Sep 17 00:00:00 2001 From: Ivan Petkov Date: Mon, 12 Oct 2020 12:57:22 -0700 Subject: [PATCH] chore: refactor runtime driver usage of `Either` (#2918) --- tokio/src/runtime/driver.rs | 100 +++++++++++++++------------------- tokio/src/util/linked_list.rs | 4 +- 2 files changed, 47 insertions(+), 57 deletions(-) diff --git a/tokio/src/runtime/driver.rs b/tokio/src/runtime/driver.rs index 6fccb11e30b..e89de9dc69e 100644 --- a/tokio/src/runtime/driver.rs +++ b/tokio/src/runtime/driver.rs @@ -8,34 +8,38 @@ use std::time::Duration; // ===== io driver ===== cfg_io_driver! { - type IoDriver = crate::park::either::Either; + type IoDriver = crate::io::driver::Driver; + type IoStack = crate::park::either::Either; pub(crate) type IoHandle = Option; - fn create_io_driver(enable: bool) -> io::Result<(IoDriver, IoHandle)> { + fn create_io_stack(enabled: bool) -> io::Result<(IoStack, IoHandle, SignalHandle)> { use crate::park::either::Either; #[cfg(loom)] - assert!(!enable); + assert!(!enabled); - if enable { - let driver = crate::io::driver::Driver::new()?; - let handle = driver.handle(); + let ret = if enabled { + let io_driver = crate::io::driver::Driver::new()?; + let io_handle = io_driver.handle(); + + let (signal_driver, signal_handle) = create_signal_driver(io_driver)?; + let process_driver = create_process_driver(signal_driver)?; - Ok((Either::A(driver), Some(handle))) + (Either::A(process_driver), Some(io_handle), signal_handle) } else { - let driver = ParkThread::new(); - Ok((Either::B(driver), None)) - } + (Either::B(ParkThread::new()), Default::default(), Default::default()) + }; + + Ok(ret) } } cfg_not_io_driver! { - type IoDriver = ParkThread; pub(crate) type IoHandle = (); + type IoStack = ParkThread; - fn create_io_driver(_enable: bool) -> io::Result<(IoDriver, IoHandle)> { - let driver = ParkThread::new(); - Ok((driver, ())) + fn create_io_stack(_enabled: bool) -> io::Result<(IoStack, IoHandle, SignalHandle)> { + Ok((ParkThread::new(), Default::default(), Default::default())) } } @@ -49,64 +53,52 @@ macro_rules! cfg_signal_internal_and_unix { } cfg_signal_internal_and_unix! { - type SignalDriver = crate::park::either::Either; + type SignalDriver = crate::signal::unix::driver::Driver; pub(crate) type SignalHandle = Option; fn create_signal_driver(io_driver: IoDriver) -> io::Result<(SignalDriver, SignalHandle)> { - use crate::park::either::Either; - - // Enable the signal driver if IO is also enabled - match io_driver { - Either::A(io_driver) => { - let driver = crate::signal::unix::driver::Driver::new(io_driver)?; - let handle = driver.handle(); - Ok((Either::A(driver), Some(handle))) - } - Either::B(_) => Ok((Either::B(io_driver), None)), - } + let driver = crate::signal::unix::driver::Driver::new(io_driver)?; + let handle = driver.handle(); + Ok((driver, Some(handle))) } } cfg_not_signal_internal! { - type SignalDriver = IoDriver; pub(crate) type SignalHandle = (); - fn create_signal_driver(io_driver: IoDriver) -> io::Result<(SignalDriver, SignalHandle)> { - Ok((io_driver, ())) + cfg_io_driver! { + type SignalDriver = IoDriver; + + fn create_signal_driver(io_driver: IoDriver) -> io::Result<(SignalDriver, SignalHandle)> { + Ok((io_driver, ())) + } } } // ===== process driver ===== cfg_process_driver! { - type ProcessDriver = crate::park::either::Either; + type ProcessDriver = crate::process::unix::driver::Driver; fn create_process_driver(signal_driver: SignalDriver) -> io::Result { - use crate::park::either::Either; - - // Enable the signal driver if IO is also enabled - match signal_driver { - Either::A(signal_driver) => { - let driver = crate::process::unix::driver::Driver::new(signal_driver)?; - Ok(Either::A(driver)) - } - Either::B(_) => Ok(Either::B(signal_driver)), - } + crate::process::unix::driver::Driver::new(signal_driver) } } cfg_not_process_driver! { - type ProcessDriver = SignalDriver; + cfg_io_driver! { + type ProcessDriver = SignalDriver; - fn create_process_driver(signal_driver: SignalDriver) -> io::Result { - Ok(signal_driver) + fn create_process_driver(signal_driver: SignalDriver) -> io::Result { + Ok(signal_driver) + } } } // ===== time driver ===== cfg_time! { - type TimeDriver = crate::park::either::Either, ProcessDriver>; + type TimeDriver = crate::park::either::Either, IoStack>; pub(crate) type Clock = crate::time::Clock; pub(crate) type TimeHandle = Option; @@ -117,24 +109,24 @@ cfg_time! { fn create_time_driver( enable: bool, - process_driver: ProcessDriver, + io_stack: IoStack, clock: Clock, ) -> (TimeDriver, TimeHandle) { use crate::park::either::Either; if enable { - let driver = crate::time::driver::Driver::new(process_driver, clock); + let driver = crate::time::driver::Driver::new(io_stack, clock); let handle = driver.handle(); (Either::A(driver), Some(handle)) } else { - (Either::B(process_driver), None) + (Either::B(io_stack), None) } } } cfg_not_time! { - type TimeDriver = ProcessDriver; + type TimeDriver = IoStack; pub(crate) type Clock = (); pub(crate) type TimeHandle = (); @@ -145,10 +137,10 @@ cfg_not_time! { fn create_time_driver( _enable: bool, - process_driver: ProcessDriver, + io_stack: IoStack, _clock: Clock, ) -> (TimeDriver, TimeHandle) { - (process_driver, ()) + (io_stack, ()) } } @@ -173,13 +165,11 @@ pub(crate) struct Cfg { impl Driver { pub(crate) fn new(cfg: Cfg) -> io::Result<(Self, Resources)> { - let clock = create_clock(); + let (io_stack, io_handle, signal_handle) = create_io_stack(cfg.enable_io)?; - let (io_driver, io_handle) = create_io_driver(cfg.enable_io)?; - let (signal_driver, signal_handle) = create_signal_driver(io_driver)?; - let process_driver = create_process_driver(signal_driver)?; + let clock = create_clock(); let (time_driver, time_handle) = - create_time_driver(cfg.enable_time, process_driver, clock.clone()); + create_time_driver(cfg.enable_time, io_stack, clock.clone()); Ok(( Self { inner: time_driver }, diff --git a/tokio/src/util/linked_list.rs b/tokio/src/util/linked_list.rs index b2f8dfc8a18..6aa227c281f 100644 --- a/tokio/src/util/linked_list.rs +++ b/tokio/src/util/linked_list.rs @@ -184,9 +184,9 @@ impl fmt::Debug for LinkedList { #[cfg(any( feature = "fs", - feature = "sync", + all(unix, feature = "process"), feature = "signal", - feature = "process" + feature = "sync", ))] impl LinkedList { pub(crate) fn last(&self) -> Option<&L::Target> {