metrics: stabilize RuntimeMetrics::worker_count

This PR stabilizes a single metric API to start the process of stabilizing metrics. Future work will continue to stabilize more metrics. Refs: tokio-rs#6546
rcoh · May 14, 2024 · 2ec8720 · 2ec8720
1 parent 6fcd9c0
commit 2ec8720
Show file tree

Hide file tree

Showing 18 changed files with 124 additions and 88 deletions.
diff --git a/tokio/src/lib.rs b/tokio/src/lib.rs
@@ -471,6 +471,7 @@ compile_error!("The `tokio_taskdump` feature requires `--cfg tokio_unstable`.");
 
 #[cfg(all(
     tokio_taskdump,
+    not(doc),
     not(all(
         target_os = "linux",
         any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")

diff --git a/tokio/src/macros/cfg.rs b/tokio/src/macros/cfg.rs
@@ -215,22 +215,40 @@ macro_rules! cfg_macros {
     }
 }
 
+// need to disable metrics on loom
 macro_rules! cfg_metrics {
     ($($item:item)*) => {
         $(
-            // For now, metrics is only disabled in loom tests.
-            // When stabilized, it might have a dedicated feature flag.
+            #[cfg(not(loom))]
+            $item
+        )*
+    }
+}
+
+macro_rules! cfg_unstable_metrics {
+    ($($item:item)*) => {
+        $(
             #[cfg(all(tokio_unstable, not(loom)))]
             #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))]
             $item
         )*
     }
 }
 
+macro_rules! cfg_not_unstable_metrics {
+    ($($item:item)*) => {
+        $(
+            #[cfg(any(not(tokio_unstable), loom))]
+            $item
+        )*
+    }
+
+}
+
 macro_rules! cfg_not_metrics {
     ($($item:item)*) => {
         $(
-            #[cfg(not(all(tokio_unstable, not(loom))))]
+            #[cfg(loom)]
             $item
         )*
     }

diff --git a/tokio/src/runtime/blocking/pool.rs b/tokio/src/runtime/blocking/pool.rs
@@ -40,7 +40,7 @@ impl SpawnerMetrics {
         self.num_idle_threads.load(Ordering::Relaxed)
     }
 
-    cfg_metrics! {
+    cfg_unstable_metrics! {
         fn queue_depth(&self) -> usize {
             self.queue_depth.load(Ordering::Relaxed)
         }
@@ -474,7 +474,7 @@ impl Spawner {
     }
 }
 
-cfg_metrics! {
+cfg_unstable_metrics! {
     impl Spawner {
         pub(crate) fn num_threads(&self) -> usize {
             self.inner.metrics.num_threads()

diff --git a/tokio/src/runtime/builder.rs b/tokio/src/runtime/builder.rs
@@ -956,7 +956,7 @@ impl Builder {
         }
     }
 
-    cfg_metrics! {
+    cfg_unstable_metrics! {
         /// Enables tracking the distribution of task poll times.
         ///
         /// Task poll times are not instrumented by default as doing so requires

diff --git a/tokio/src/runtime/coop.rs b/tokio/src/runtime/coop.rs
@@ -197,7 +197,7 @@ cfg_coop! {
     }
 
     cfg_rt! {
-        cfg_metrics! {
+        cfg_unstable_metrics! {
             #[inline(always)]
             fn inc_budget_forced_yield_count() {
                 let _ = context::with_current(|handle| {
@@ -206,7 +206,7 @@ cfg_coop! {
             }
         }
 
-        cfg_not_metrics! {
+        cfg_not_unstable_metrics! {
             #[inline(always)]
             fn inc_budget_forced_yield_count() {}
         }

diff --git a/tokio/src/runtime/io/metrics.rs b/tokio/src/runtime/io/metrics.rs
@@ -17,7 +17,7 @@ cfg_not_rt_and_metrics_and_net! {
 
 cfg_net! {
     cfg_rt! {
-        cfg_metrics! {
+        cfg_unstable_metrics! {
             pub(crate) use crate::runtime::IoDriverMetrics;
         }
     }

diff --git a/tokio/src/runtime/metrics/mod.rs b/tokio/src/runtime/metrics/mod.rs
@@ -9,27 +9,34 @@
 #![allow(clippy::module_inception)]
 
 cfg_metrics! {
-    mod batch;
-    pub(crate) use batch::MetricsBatch;
-
-    mod histogram;
-    pub(crate) use histogram::{Histogram, HistogramBatch, HistogramBuilder};
-    #[allow(unreachable_pub)] // rust-lang/rust#57411
-    pub use histogram::HistogramScale;
-
     mod runtime;
-    #[allow(unreachable_pub)] // rust-lang/rust#57411
     pub use runtime::RuntimeMetrics;
 
-    mod scheduler;
-    pub(crate) use scheduler::SchedulerMetrics;
+    cfg_unstable_metrics! {
+        mod batch;
+        pub(crate) use batch::MetricsBatch;
+
+        mod histogram;
+        pub(crate) use histogram::{HistogramBatch, HistogramBuilder, Histogram};
+
+        mod scheduler;
+        pub(crate) use scheduler::SchedulerMetrics;
+
+        mod worker;
+        pub(crate) use worker::WorkerMetrics;
+
+        cfg_net! {
+            mod io;
+            pub(crate) use io::IoDriverMetrics;
+        }
+        #[allow(unreachable_pub)] // rust-lang/rust#57411
+        pub use histogram::HistogramScale;
+    }
 
-    mod worker;
-    pub(crate) use worker::WorkerMetrics;
+    cfg_not_unstable_metrics! {
+        mod mock;
 
-    cfg_net! {
-        mod io;
-        pub(crate) use io::IoDriverMetrics;
+        pub(crate) use mock::{SchedulerMetrics, WorkerMetrics, MetricsBatch, HistogramBuilder};
     }
 }
 

diff --git a/tokio/src/runtime/metrics/runtime.rs b/tokio/src/runtime/metrics/runtime.rs
@@ -1,9 +1,5 @@
 use crate::runtime::Handle;
 
-use std::ops::Range;
-use std::sync::atomic::Ordering::Relaxed;
-use std::time::Duration;
-
 /// Handle to the runtime's metrics.
 ///
 /// This handle is internally reference-counted and can be freely cloned. A
@@ -15,6 +11,12 @@ pub struct RuntimeMetrics {
     handle: Handle,
 }
 
+cfg_unstable_metrics! {
+    use std::time::Duration;
+    use std::sync::atomic::Ordering::Relaxed;
+    use std::ops::Range;
+}
+
 impl RuntimeMetrics {
     pub(crate) fn new(handle: Handle) -> RuntimeMetrics {
         RuntimeMetrics { handle }
@@ -43,6 +45,8 @@ impl RuntimeMetrics {
         self.handle.inner.num_workers()
     }
 
+    cfg_unstable_metrics! {
+
     /// Returns the number of additional threads spawned by the runtime.
     ///
     /// The number of workers is set by configuring `max_blocking_threads` on
@@ -833,10 +837,8 @@ impl RuntimeMetrics {
     pub fn blocking_queue_depth(&self) -> usize {
         self.handle.inner.blocking_queue_depth()
     }
-}
 
-cfg_net! {
-    impl RuntimeMetrics {
+    cfg_net! {
         /// Returns the number of file descriptors that have been registered with the
         /// runtime's I/O driver.
         ///
@@ -921,4 +923,5 @@ cfg_net! {
                 .unwrap_or(0)
         }
     }
+    }
 }
diff --git a/tokio/src/runtime/mod.rs b/tokio/src/runtime/mod.rs
@@ -388,21 +388,23 @@ cfg_rt! {
     mod thread_id;
     pub(crate) use thread_id::ThreadId;
 
+    pub(crate) mod metrics;
     cfg_metrics! {
-        mod metrics;
-        pub use metrics::{RuntimeMetrics, HistogramScale};
+        pub use metrics::RuntimeMetrics;
 
-        pub(crate) use metrics::{MetricsBatch, SchedulerMetrics, WorkerMetrics, HistogramBuilder};
 
-        cfg_net! {
-        pub(crate) use metrics::IoDriverMetrics;
+        cfg_unstable_metrics! {
+            pub use metrics::HistogramScale;
+
+
+            cfg_net! {
+                pub(crate) use metrics::IoDriverMetrics;
+            }
         }
     }
 
-    cfg_not_metrics! {
-        pub(crate) mod metrics;
-        pub(crate) use metrics::{SchedulerMetrics, WorkerMetrics, MetricsBatch, HistogramBuilder};
-    }
+    pub(crate) use metrics::{MetricsBatch, SchedulerMetrics, WorkerMetrics, HistogramBuilder};
+
 
     /// After thread starts / before thread stops
     type Callback = std::sync::Arc<dyn Fn() + Send + Sync>;

diff --git a/tokio/src/runtime/runtime.rs b/tokio/src/runtime/runtime.rs
@@ -455,6 +455,14 @@ impl Runtime {
     pub fn shutdown_background(self) {
         self.shutdown_timeout(Duration::from_nanos(0));
     }
+
+    cfg_metrics! {
+        /// Returns a view that lets you get information about how the runtime
+        /// is performing.
+        pub fn metrics(&self) -> crate::runtime::RuntimeMetrics {
+            self.handle.metrics()
+        }
+    }
 }
 
 #[allow(clippy::single_match)] // there are comments in the error branch, so we don't want if-let
@@ -487,12 +495,4 @@ impl std::panic::UnwindSafe for Runtime {}
 
 impl std::panic::RefUnwindSafe for Runtime {}
 
-cfg_metrics! {
-    impl Runtime {
-        /// Returns a view that lets you get information about how the runtime
-        /// is performing.
-        pub fn metrics(&self) -> crate::runtime::RuntimeMetrics {
-            self.handle.metrics()
-        }
-    }
-}
+impl Runtime {}
diff --git a/tokio/src/runtime/scheduler/current_thread/mod.rs b/tokio/src/runtime/scheduler/current_thread/mod.rs
@@ -502,7 +502,7 @@ impl Handle {
     }
 }
 
-cfg_metrics! {
+cfg_unstable_metrics! {
     impl Handle {
         pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics {
             &self.shared.scheduler_metrics

diff --git a/tokio/src/runtime/scheduler/inject.rs b/tokio/src/runtime/scheduler/inject.rs
@@ -16,7 +16,7 @@ cfg_rt_multi_thread! {
     mod rt_multi_thread;
 }
 
-cfg_metrics! {
+cfg_unstable_metrics! {
     mod metrics;
 }
 

diff --git a/tokio/src/runtime/scheduler/mod.rs b/tokio/src/runtime/scheduler/mod.rs
@@ -164,8 +164,6 @@ cfg_rt! {
     }
 
     cfg_metrics! {
-        use crate::runtime::{SchedulerMetrics, WorkerMetrics};
-
         impl Handle {
             pub(crate) fn num_workers(&self) -> usize {
                 match self {
@@ -176,6 +174,12 @@ cfg_rt! {
                     Handle::MultiThreadAlt(handle) => handle.num_workers(),
                 }
             }
+        }
+
+    cfg_unstable_metrics! {
+        use crate::runtime::{SchedulerMetrics, WorkerMetrics};
+        impl Handle {
+
 
             pub(crate) fn num_blocking_threads(&self) -> usize {
                 match_flavor!(self, Handle(handle) => handle.num_blocking_threads())
@@ -210,6 +214,7 @@ cfg_rt! {
             }
         }
     }
+}
 
     impl Context {
         #[track_caller]

diff --git a/tokio/src/runtime/scheduler/multi_thread/handle.rs b/tokio/src/runtime/scheduler/multi_thread/handle.rs
@@ -9,9 +9,7 @@ use crate::util::RngSeedGenerator;
 
 use std::fmt;
 
-cfg_metrics! {
-    mod metrics;
-}
+mod metrics;
 
 cfg_taskdump! {
     mod taskdump;

diff --git a/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs b/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs
@@ -1,41 +1,43 @@
 use super::Handle;
 
-use crate::runtime::{SchedulerMetrics, WorkerMetrics};
-
 impl Handle {
     pub(crate) fn num_workers(&self) -> usize {
         self.shared.worker_metrics.len()
     }
+}
 
-    pub(crate) fn num_blocking_threads(&self) -> usize {
-        self.blocking_spawner.num_threads()
-    }
+cfg_unstable_metrics! {
+    impl Handle {
+            pub(crate) fn num_blocking_threads(&self) -> usize {
+                self.blocking_spawner.num_threads()
+            }
 
-    pub(crate) fn num_idle_blocking_threads(&self) -> usize {
-        self.blocking_spawner.num_idle_threads()
-    }
+            pub(crate) fn num_idle_blocking_threads(&self) -> usize {
+                self.blocking_spawner.num_idle_threads()
+            }
 
-    pub(crate) fn active_tasks_count(&self) -> usize {
-        self.shared.owned.active_tasks_count()
-    }
+            pub(crate) fn active_tasks_count(&self) -> usize {
+                self.shared.owned.active_tasks_count()
+            }
 
-    pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics {
-        &self.shared.scheduler_metrics
-    }
+            pub(crate) fn scheduler_metrics(&self) -> &crate::runtime::SchedulerMetrics {
+                &self.shared.scheduler_metrics
+            }
 
-    pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {
-        &self.shared.worker_metrics[worker]
-    }
+            pub(crate) fn worker_metrics(&self, worker: usize) -> &crate::runtime::WorkerMetrics {
+                &self.shared.worker_metrics[worker]
+            }
 
-    pub(crate) fn injection_queue_depth(&self) -> usize {
-        self.shared.injection_queue_depth()
-    }
+            pub(crate) fn injection_queue_depth(&self) -> usize {
+                self.shared.injection_queue_depth()
+            }
 
-    pub(crate) fn worker_local_queue_depth(&self, worker: usize) -> usize {
-        self.shared.worker_local_queue_depth(worker)
-    }
+            pub(crate) fn worker_local_queue_depth(&self, worker: usize) -> usize {
+                self.shared.worker_local_queue_depth(worker)
+            }
 
-    pub(crate) fn blocking_queue_depth(&self) -> usize {
-        self.blocking_spawner.queue_depth()
+            pub(crate) fn blocking_queue_depth(&self) -> usize {
+                self.blocking_spawner.queue_depth()
+            }
     }
 }