mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-29 00:00:11 +02:00
Carl Lerche
8546ff826d
* runtime: cleanup and add config options This patch finishes the cleanup as part of the transition to Tokio 0.2. A number of changes were made to take advantage of having all Tokio types in a single crate. Also, fixes using Tokio types from `spawn_blocking`. * Many threads, one resource driver Previously, in the threaded scheduler, a resource driver (mio::Poll / timer combo) was created per thread. This was more or less fine, except it required balancing across the available drivers. When using a resource driver from **outside** of the thread pool, balancing is tricky. The change was original done to avoid having a dedicated driver thread. Now, instead of creating many resource drivers, a single resource driver is used. Each scheduler thread will attempt to "lock" the resource driver before parking on it. If the resource driver is already locked, the thread uses a condition variable to park. Contention should remain low as, under load, the scheduler avoids using the drivers. * Add configuration options to enable I/O / time New configuration options are added to `runtime::Builder` to allow enabling I/O and time drivers on a runtime instance basis. This is useful when wanting to create lightweight runtime instances to execute compute only tasks. * Bug fixes The condition variable parker is updated to the same algorithm used in `std`. This is motivated by some potential deadlock cases discovered by `loom`. The basic scheduler is fixed to fairly schedule tasks. `push_front` was accidentally used instead of `push_back`. I/O, time, and spawning now work from within `spawn_blocking` closures. * Misc cleanup The threaded scheduler is no longer generic over `P :Park`. Instead, it is hard coded to a specific parker. Tests, including loom tests, are updated to use `Runtime` directly. This provides greater coverage. The `blocking` module is moved back into `runtime` as all usage is within `runtime` itself.
55 lines
1.4 KiB
Rust
55 lines
1.4 KiB
Rust
#![cfg(unix)]
|
|
#![warn(rust_2018_idioms)]
|
|
|
|
mod support {
|
|
pub mod signal;
|
|
}
|
|
use support::signal::send_signal;
|
|
|
|
use tokio::runtime::Runtime;
|
|
use tokio::signal::unix::{signal, SignalKind};
|
|
|
|
use std::sync::mpsc::channel;
|
|
use std::thread;
|
|
|
|
#[test]
|
|
fn multi_loop() {
|
|
// An "ordinary" (non-future) channel
|
|
let (sender, receiver) = channel();
|
|
// Run multiple times, to make sure there are no race conditions
|
|
for _ in 0..10 {
|
|
// Run multiple event loops, each one in its own thread
|
|
let threads: Vec<_> = (0..4)
|
|
.map(|_| {
|
|
let sender = sender.clone();
|
|
thread::spawn(move || {
|
|
let mut rt = rt();
|
|
let _ = rt.block_on(async {
|
|
let mut signal = signal(SignalKind::hangup()).unwrap();
|
|
sender.send(()).unwrap();
|
|
signal.recv().await
|
|
});
|
|
})
|
|
})
|
|
.collect();
|
|
// Wait for them to declare they're ready
|
|
for &_ in threads.iter() {
|
|
receiver.recv().unwrap();
|
|
}
|
|
// Send a signal
|
|
send_signal(libc::SIGHUP);
|
|
// Make sure the threads terminated correctly
|
|
for t in threads {
|
|
t.join().unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn rt() -> Runtime {
|
|
tokio::runtime::Builder::new()
|
|
.basic_scheduler()
|
|
.enable_all()
|
|
.build()
|
|
.unwrap()
|
|
}
|