Use cfg_64bit_metrics instead

tokio/src/runtime/metrics/runtime.rs

@@ -1,12 +1,15 @@
 use crate::runtime::Handle;
-#[cfg(target_has_atomic = "64")]
-use std::sync::atomic::Ordering::Relaxed;
-#[cfg(target_has_atomic = "64")]
+#[allow(unused_imports)]
 use std::time::Duration;
 
+cfg_64bit_metrics! {
+    use std::sync::atomic::Ordering::Relaxed;
+}
+
 cfg_unstable_metrics! {
     use std::ops::Range;
     use std::thread::ThreadId;
+    // use std::time::Duration;
 }
 
 /// Handle to the runtime's metrics.
@@ -96,52 +99,54 @@ impl RuntimeMetrics {
         self.handle.inner.injection_queue_depth()
     }
 
-    /// Returns the amount of time the given worker thread has been busy.
-    ///
-    /// The worker busy duration starts at zero when the runtime is created and
-    /// increases whenever the worker is spending time processing work. Using
-    /// this value can indicate the load of the given worker. If a lot of time
-    /// is spent busy, then the worker is under load and will check for inbound
-    /// events less often.
-    ///
-    /// The timer is monotonically increasing. It is never decremented or reset
-    /// to zero.
-    ///
-    /// # Arguments
-    ///
-    /// `worker` is the index of the worker being queried. The given value must
-    /// be between 0 and `num_workers()`. The index uniquely identifies a single
-    /// worker and will continue to identify the worker throughout the lifetime
-    /// of the runtime instance.
-    ///
-    /// # Panics
-    ///
-    /// The method panics when `worker` represents an invalid worker, i.e. is
-    /// greater than or equal to `num_workers()`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::runtime::Handle;
-    ///
-    /// #[tokio::main]
-    /// async fn main() {
-    ///     let metrics = Handle::current().metrics();
-    ///
-    ///     let n = metrics.worker_total_busy_duration(0);
-    ///     println!("worker 0 was busy for a total of {:?}", n);
-    /// }
-    /// ```
-    #[cfg(target_has_atomic = "64")]
-    pub fn worker_total_busy_duration(&self, worker: usize) -> Duration {
+    cfg_64bit_metrics! {
+        /// Returns the amount of time the given worker thread has been busy.
+        ///
+        /// The worker busy duration starts at zero when the runtime is created and
+        /// increases whenever the worker is spending time processing work. Using
+        /// this value can indicate the load of the given worker. If a lot of time
+        /// is spent busy, then the worker is under load and will check for inbound
+        /// events less often.
+        ///
+        /// The timer is monotonically increasing. It is never decremented or reset
+        /// to zero.
+        ///
+        /// # Arguments
+        ///
+        /// `worker` is the index of the worker being queried. The given value must
+        /// be between 0 and `num_workers()`. The index uniquely identifies a single
+        /// worker and will continue to identify the worker throughout the lifetime
+        /// of the runtime instance.
+        ///
+        /// # Panics
+        ///
+        /// The method panics when `worker` represents an invalid worker, i.e. is
+        /// greater than or equal to `num_workers()`.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// use tokio::runtime::Handle;
+        ///
+        /// #[tokio::main]
+        /// async fn main() {
+        ///     let metrics = Handle::current().metrics();
+        ///
+        ///     let n = metrics.worker_total_busy_duration(0);
+        ///     println!("worker 0 was busy for a total of {:?}", n);
+        /// }
+        /// ```
+        pub fn worker_total_busy_duration(&self, worker: usize) -> Duration {
         let nanos = self
             .handle
             .inner
             .worker_metrics(worker)
             .busy_duration_total
             .load(Relaxed);
         Duration::from_nanos(nanos)
+        }
     }
+
     cfg_unstable_metrics! {
 
         /// Returns the number of additional threads spawned by the runtime.

tokio/src/runtime/scheduler/current_thread/mod.rs

@@ -533,7 +533,7 @@ impl Handle {
         self.shared.inject.len()
     }
 
-    #[cfg(target_has_atomic = "64")]
+    #[allow(dead_code)]
     pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {
         assert_eq!(0, worker);
         &self.shared.worker_metrics

tokio/src/runtime/scheduler/mod.rs

@@ -10,7 +10,6 @@ cfg_rt! {
 
     use crate::runtime::TaskHooks;
 
-    #[cfg(target_has_atomic = "64")]
     use crate::runtime::{WorkerMetrics};
 }
 
@@ -197,7 +196,7 @@ cfg_rt! {
             match_flavor!(self, Handle(handle) => handle.injection_queue_depth())
         }
 
-        #[cfg(target_has_atomic = "64")]
+        #[allow(dead_code)]
         pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {
             match_flavor!(self, Handle(handle) => handle.worker_metrics(worker))
         }

tokio/src/runtime/scheduler/multi_thread/handle/metrics.rs

@@ -1,5 +1,4 @@
 use super::Handle;
-#[cfg(target_has_atomic = "64")]
 use crate::runtime::WorkerMetrics;
 
 cfg_unstable_metrics! {
@@ -19,7 +18,7 @@ impl Handle {
         self.shared.injection_queue_depth()
     }
 
-    #[cfg(target_has_atomic = "64")]
+    #[allow(dead_code)]
     pub(crate) fn worker_metrics(&self, worker: usize) -> &WorkerMetrics {
         &self.shared.worker_metrics[worker]
     }