Struct tokio::runtime::scheduler::multi_thread::worker::Shared

pub(crate) struct Shared {
    remotes: Box<[Remote]>,
    pub(super) inject: Shared<Arc<Handle>>,
    idle: Idle,
    pub(crate) owned: OwnedTasks<Arc<Handle>>,
    pub(super) synced: Mutex<Synced>,
    shutdown_cores: Mutex<Vec<Box<Core>>>,
    pub(super) trace_status: TraceStatus,
    config: Config,
    pub(super) scheduler_metrics: SchedulerMetrics,
    pub(super) worker_metrics: Box<[WorkerMetrics]>,
    _counters: Counters,
}

State shared across all workers

Fields

remotes: Box<[Remote]>

Per-worker remote state. All other workers have access to this and is how they communicate between each other.

inject: Shared<Arc<Handle>>

Global task queue used for:

1. Submit work to the scheduler while not currently on a worker thread.
2. Submit work to the scheduler when a worker run queue is saturated

idle: Idle

Coordinates idle workers

owned: OwnedTasks<Arc<Handle>>

Collection of all active tasks spawned onto this executor.

synced: Mutex<Synced>

Data synchronized by the scheduler mutex

shutdown_cores: Mutex<Vec<Box<Core>>>

Cores that have observed the shutdown signal

The core is not placed back in the worker to avoid it from being stolen by a thread that was spawned as part of block_in_place.

trace_status: TraceStatus

The number of cores that have observed the trace signal.

config: Config

Scheduler configuration options

scheduler_metrics: SchedulerMetrics

Collects metrics from the runtime.

worker_metrics: Box<[WorkerMetrics]>

_counters: Counters

Only held to trigger some code on drop. This is used to get internal runtime metrics that can be useful when doing performance investigations. This does nothing (empty struct, no drop impl) unless the tokio_internal_mt_counters cfg flag is set.

Implementations

impl Shared

pub(crate) fn injection_queue_depth(&self) -> usize