From 68d0e3cb5fc0b5e4348e5eeab79e44fc91f0f2d4 Mon Sep 17 00:00:00 2001 From: Alice Ryhl Date: Sun, 30 Jun 2024 14:02:29 +0100 Subject: [PATCH] metrics: rename `num_active_tasks` to `num_alive_tasks` (#6667) --- tokio/src/runtime/metrics/runtime.rs | 19 ++++++++++--------- .../runtime/scheduler/current_thread/mod.rs | 4 ++-- tokio/src/runtime/scheduler/mod.rs | 4 ++-- .../scheduler/multi_thread/handle/metrics.rs | 4 ++-- .../multi_thread_alt/handle/metrics.rs | 4 ++-- tokio/src/runtime/task/list.rs | 2 +- tokio/tests/rt_metrics.rs | 16 ++++++++-------- 7 files changed, 27 insertions(+), 26 deletions(-) diff --git a/tokio/src/runtime/metrics/runtime.rs b/tokio/src/runtime/metrics/runtime.rs index 4eab344f022..bdf7791bea9 100644 --- a/tokio/src/runtime/metrics/runtime.rs +++ b/tokio/src/runtime/metrics/runtime.rs @@ -75,15 +75,16 @@ impl RuntimeMetrics { self.handle.inner.num_blocking_threads() } - #[deprecated = "Renamed to num_active_tasks"] - /// Renamed to [`RuntimeMetrics::num_active_tasks`] + #[deprecated = "Renamed to num_alive_tasks"] + /// Renamed to [`RuntimeMetrics::num_alive_tasks`] pub fn active_tasks_count(&self) -> usize { - self.num_active_tasks() + self.num_alive_tasks() } - /// Returns the current number of active tasks in the runtime. + /// Returns the current number of alive tasks in the runtime. /// - /// This value increases and decreases over time as tasks are spawned and as they are completed or cancelled. + /// This counter increases when a task is spawned and decreases when a + /// task exits. /// /// # Examples /// @@ -94,12 +95,12 @@ impl RuntimeMetrics { /// async fn main() { /// let metrics = Handle::current().metrics(); /// - /// let n = metrics.num_active_tasks(); - /// println!("Runtime has {} active tasks", n); + /// let n = metrics.num_alive_tasks(); + /// println!("Runtime has {} alive tasks", n); /// } /// ``` - pub fn num_active_tasks(&self) -> usize { - self.handle.inner.active_tasks_count() + pub fn num_alive_tasks(&self) -> usize { + self.handle.inner.alive_tasks_count() } /// Returns the number of idle threads, which have spawned by the runtime diff --git a/tokio/src/runtime/scheduler/current_thread/mod.rs b/tokio/src/runtime/scheduler/current_thread/mod.rs index 449aa8330f3..b1e5df532ad 100644 --- a/tokio/src/runtime/scheduler/current_thread/mod.rs +++ b/tokio/src/runtime/scheduler/current_thread/mod.rs @@ -533,8 +533,8 @@ cfg_unstable_metrics! { self.blocking_spawner.queue_depth() } - pub(crate) fn active_tasks_count(&self) -> usize { - self.shared.owned.active_tasks_count() + pub(crate) fn alive_tasks_count(&self) -> usize { + self.shared.owned.alive_tasks_count() } cfg_64bit_metrics! { diff --git a/tokio/src/runtime/scheduler/mod.rs b/tokio/src/runtime/scheduler/mod.rs index c0467f45d1c..f6dc7ed6204 100644 --- a/tokio/src/runtime/scheduler/mod.rs +++ b/tokio/src/runtime/scheduler/mod.rs @@ -193,8 +193,8 @@ cfg_rt! { match_flavor!(self, Handle(handle) => handle.num_idle_blocking_threads()) } - pub(crate) fn active_tasks_count(&self) -> usize { - match_flavor!(self, Handle(handle) => handle.active_tasks_count()) + pub(crate) fn alive_tasks_count(&self) -> usize { + match_flavor!(self, Handle(handle) => handle.alive_tasks_count()) } pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics { diff --git a/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs b/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs index 5db2336065a..bc0723fe8dc 100644 --- a/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs +++ b/tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs @@ -27,8 +27,8 @@ impl Handle { self.blocking_spawner.num_idle_threads() } - pub(crate) fn active_tasks_count(&self) -> usize { - self.shared.owned.active_tasks_count() + pub(crate) fn alive_tasks_count(&self) -> usize { + self.shared.owned.alive_tasks_count() } pub(crate) fn scheduler_metrics(&self) -> &SchedulerMetrics { diff --git a/tokio/src/runtime/scheduler/multi_thread_alt/handle/metrics.rs b/tokio/src/runtime/scheduler/multi_thread_alt/handle/metrics.rs index 4adc191a6b1..6bb6e1aecb3 100644 --- a/tokio/src/runtime/scheduler/multi_thread_alt/handle/metrics.rs +++ b/tokio/src/runtime/scheduler/multi_thread_alt/handle/metrics.rs @@ -18,8 +18,8 @@ impl Handle { self.blocking_spawner.num_idle_threads() } - pub(crate) fn active_tasks_count(&self) -> usize { - self.shared.owned.active_tasks_count() + pub(crate) fn alive_tasks_count(&self) -> usize { + self.shared.owned.alive_tasks_count() } cfg_64bit_metrics! { diff --git a/tokio/src/runtime/task/list.rs b/tokio/src/runtime/task/list.rs index 7e49293244a..63ff4567231 100644 --- a/tokio/src/runtime/task/list.rs +++ b/tokio/src/runtime/task/list.rs @@ -166,7 +166,7 @@ impl OwnedTasks { self.list.shard_size() } - pub(crate) fn active_tasks_count(&self) -> usize { + pub(crate) fn alive_tasks_count(&self) -> usize { self.list.len() } diff --git a/tokio/tests/rt_metrics.rs b/tokio/tests/rt_metrics.rs index 0680d7960a5..ff49e6a6129 100644 --- a/tokio/tests/rt_metrics.rs +++ b/tokio/tests/rt_metrics.rs @@ -93,22 +93,22 @@ fn blocking_queue_depth() { } #[test] -fn num_active_tasks() { +fn num_alive_tasks() { let rt = current_thread(); let metrics = rt.metrics(); - assert_eq!(0, metrics.num_active_tasks()); + assert_eq!(0, metrics.num_alive_tasks()); rt.block_on(rt.spawn(async move { - assert_eq!(1, metrics.num_active_tasks()); + assert_eq!(1, metrics.num_alive_tasks()); })) .unwrap(); - assert_eq!(0, rt.metrics().num_active_tasks()); + assert_eq!(0, rt.metrics().num_alive_tasks()); let rt = threaded(); let metrics = rt.metrics(); - assert_eq!(0, metrics.num_active_tasks()); + assert_eq!(0, metrics.num_alive_tasks()); rt.block_on(rt.spawn(async move { - assert_eq!(1, metrics.num_active_tasks()); + assert_eq!(1, metrics.num_alive_tasks()); })) .unwrap(); @@ -116,12 +116,12 @@ fn num_active_tasks() { // wake_join() is called before the task is released, so in multithreaded // code, this means we sometimes exit the block_on before the counter decrements. for _ in 0..100 { - if rt.metrics().num_active_tasks() == 0 { + if rt.metrics().num_alive_tasks() == 0 { break; } std::thread::sleep(std::time::Duration::from_millis(100)); } - assert_eq!(0, rt.metrics().num_active_tasks()); + assert_eq!(0, rt.metrics().num_alive_tasks()); } #[test]