tokio 1.48.0

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::runtime::Config;
use crate::util::metric_atomics::{MetricAtomicU64, MetricAtomicUsize};
use std::sync::atomic::Ordering::Relaxed;
use std::sync::Mutex;
use std::thread::ThreadId;

cfg_unstable_metrics! {
    use crate::runtime::metrics::Histogram;
}

/// Retrieve runtime worker metrics.
///
/// **Note**: This is an [unstable API][unstable]. The public API of this type
/// may break in 1.x releases. See [the documentation on unstable
/// features][unstable] for details.
///
/// [unstable]: crate#unstable-features
#[derive(Debug, Default)]
#[repr(align(128))]
pub(crate) struct WorkerMetrics {
    /// Amount of time the worker spent doing work vs. parking.
    pub(crate) busy_duration_total: MetricAtomicU64,

    /// Number of tasks currently in the local queue. Used only by the
    /// current-thread scheduler.
    pub(crate) queue_depth: MetricAtomicUsize,

    /// Thread id of worker thread.
    thread_id: Mutex<Option<ThreadId>>,

    ///  Number of times the worker parked.
    pub(crate) park_count: MetricAtomicU64,

    ///  Number of times the worker parked and unparked.
    pub(crate) park_unpark_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of times the worker woke then parked again without doing work.
    pub(crate) noop_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of tasks the worker stole.
    pub(crate) steal_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of times the worker stole
    pub(crate) steal_operations: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of tasks the worker polled.
    pub(crate) poll_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// EWMA task poll time, in nanoseconds.
    pub(crate) mean_poll_time: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of tasks scheduled for execution on the worker's local queue.
    pub(crate) local_schedule_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// Number of tasks moved from the local queue to the global queue to free space.
    pub(crate) overflow_count: MetricAtomicU64,

    #[cfg(tokio_unstable)]
    /// If `Some`, tracks the number of polls by duration range.
    pub(super) poll_count_histogram: Option<Histogram>,
}

impl WorkerMetrics {
    pub(crate) fn new() -> WorkerMetrics {
        WorkerMetrics::default()
    }

    pub(crate) fn set_queue_depth(&self, len: usize) {
        self.queue_depth.store(len, Relaxed);
    }

    pub(crate) fn set_thread_id(&self, thread_id: ThreadId) {
        *self.thread_id.lock().unwrap() = Some(thread_id);
    }

    cfg_metrics_variant! {
        stable: {
            pub(crate) fn from_config(_: &Config) -> WorkerMetrics {
                WorkerMetrics::new()
            }
        },
        unstable: {
            pub(crate) fn from_config(config: &Config) -> WorkerMetrics {
                let mut worker_metrics = WorkerMetrics::new();
                worker_metrics.poll_count_histogram = config
                    .metrics_poll_count_histogram
                    .as_ref()
                    .map(|histogram_builder| histogram_builder.build());
                worker_metrics
            }
        }
    }

    cfg_unstable_metrics! {
        pub(crate) fn queue_depth(&self) -> usize {
            self.queue_depth.load(Relaxed)
        }

        pub(crate) fn thread_id(&self) -> Option<ThreadId> {
            *self.thread_id.lock().unwrap()
        }
    }
}