mirror of
https://github.com/tokio-rs/tokio.git
synced 2025-09-28 12:10:37 +00:00
1204da7300
This PR restructures `runtime::context` into multiple files by component and feature flag. The goal is to reduce code defined in macros and make each context component more manageable. There should be no behavior changes except tweaking how the RNG seed is set. Instead of putting it in `set_current`, we set it when entering the runtime. This aligns better with the feature's original intent, enabling users to make a runtime's RNG deterministic. The seed should not be changed by `Handle::enter()`, so there is no need to have the code in `context::set_current`.
92 lines
2.1 KiB
Rust
92 lines
2.1 KiB
Rust
//! Multi-threaded runtime
|
|
|
|
mod counters;
|
|
use counters::Counters;
|
|
|
|
mod handle;
|
|
pub(crate) use handle::Handle;
|
|
|
|
mod overflow;
|
|
pub(crate) use overflow::Overflow;
|
|
|
|
mod idle;
|
|
use self::idle::Idle;
|
|
|
|
mod stats;
|
|
pub(crate) use stats::Stats;
|
|
|
|
mod park;
|
|
pub(crate) use park::{Parker, Unparker};
|
|
|
|
pub(crate) mod queue;
|
|
|
|
mod worker;
|
|
pub(crate) use worker::{Context, Launch, Shared};
|
|
|
|
pub(crate) use worker::block_in_place;
|
|
|
|
use crate::loom::sync::Arc;
|
|
use crate::runtime::{
|
|
blocking,
|
|
driver::{self, Driver},
|
|
scheduler, Config,
|
|
};
|
|
use crate::util::RngSeedGenerator;
|
|
|
|
use std::fmt;
|
|
use std::future::Future;
|
|
|
|
/// Work-stealing based thread pool for executing futures.
|
|
pub(crate) struct MultiThread;
|
|
|
|
// ===== impl MultiThread =====
|
|
|
|
impl MultiThread {
|
|
pub(crate) fn new(
|
|
size: usize,
|
|
driver: Driver,
|
|
driver_handle: driver::Handle,
|
|
blocking_spawner: blocking::Spawner,
|
|
seed_generator: RngSeedGenerator,
|
|
config: Config,
|
|
) -> (MultiThread, Arc<Handle>, Launch) {
|
|
let parker = Parker::new(driver);
|
|
let (handle, launch) = worker::create(
|
|
size,
|
|
parker,
|
|
driver_handle,
|
|
blocking_spawner,
|
|
seed_generator,
|
|
config,
|
|
);
|
|
|
|
(MultiThread, handle, launch)
|
|
}
|
|
|
|
/// Blocks the current thread waiting for the future to complete.
|
|
///
|
|
/// The future will execute on the current thread, but all spawned tasks
|
|
/// will be executed on the thread pool.
|
|
pub(crate) fn block_on<F>(&self, handle: &scheduler::Handle, future: F) -> F::Output
|
|
where
|
|
F: Future,
|
|
{
|
|
crate::runtime::context::enter_runtime(handle, true, |blocking| {
|
|
blocking.block_on(future).expect("failed to park thread")
|
|
})
|
|
}
|
|
|
|
pub(crate) fn shutdown(&mut self, handle: &scheduler::Handle) {
|
|
match handle {
|
|
scheduler::Handle::MultiThread(handle) => handle.shutdown(),
|
|
_ => panic!("expected MultiThread scheduler"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for MultiThread {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
fmt.debug_struct("MultiThread").finish()
|
|
}
|
|
}
|