impl RuntimeMetrics

fn num_workers(&self) -> usize

Returns the number of worker threads used by the runtime.

The number of workers is set by configuring worker_threads on runtime::Builder. When using the current_thread runtime, the return value is always 1.

Examples

use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.num_workers();
println!("Runtime is using {} workers", n);
# }

fn num_alive_tasks(&self) -> usize

Returns the current number of alive tasks in the runtime.

This counter increases when a task is spawned and decreases when a task exits.

Note: When using the multi-threaded runtime this number may not not have strong consistency i.e. no tasks may be running but the metric reports otherwise.

Examples

use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.num_alive_tasks();
println!("Runtime has {} alive tasks", n);
# }

fn global_queue_depth(&self) -> usize

Returns the number of tasks currently scheduled in the runtime's global queue.

Tasks that are spawned or notified from a non-runtime thread are scheduled using the runtime's global queue. This metric returns the current number of tasks pending in the global queue. As such, the returned value may increase or decrease as new tasks are scheduled and processed.

Examples

use tokio::runtime::Handle;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.global_queue_depth();
println!("{} tasks currently pending in the runtime's global queue", n);
# }

fn worker_total_busy_duration(&self, worker: usize) -> Duration

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(flavor = "current_thread")]
# 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);
# }

fn worker_park_count(&self, worker: usize) -> u64

Returns the total number of times the given worker thread has parked.

The worker park count starts at zero when the runtime is created and increases by one each time the worker parks the thread waiting for new inbound events to process. This usually means the worker has processed all pending work and is currently idle.

The counter 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(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();

let n = metrics.worker_park_count(0);
println!("worker 0 parked {} times", n);
# }

fn worker_park_unpark_count(&self, worker: usize) -> u64

Returns the total number of times the given worker thread has parked and unparked.

The worker park/unpark count starts at zero when the runtime is created and increases by one each time the worker parks the thread waiting for new inbound events to process. This usually means the worker has processed all pending work and is currently idle. When new work becomes available, the worker is unparked and the park/unpark count is again increased by one.

An odd count means that the worker is currently parked. An even count means that the worker is currently active.

The counter 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(flavor = "current_thread")]
# async fn main() {
let metrics = Handle::current().metrics();
let n = metrics.worker_park_unpark_count(0);

println!("worker 0 parked and unparked {} times", n);

if n % 2 == 0 {
    println!("worker 0 is active");
} else {
    println!("worker 0 is parked");
}
# }