mirror of
https://github.com/tokio-rs/tokio.git
synced 2025-09-25 12:00:35 +00:00
e106c4d32b
This additional benchmark exercises a common request/reply pattern using an MPSC for requests along with a oneshot payload as a reply mechanism. When used in a current threaded scenario, the bench is 17 times faster on my machine than when using the multi-threaded runtime and one worker thread. Not only that, but if I increase the number of worker threads to 6, performance degrades further. Does this suggest a scheduling problem with the multi-threaded runtime? No matter what, hopefully the benchmarks are a useful addition.
54 lines
1.3 KiB
Rust
54 lines
1.3 KiB
Rust
use bencher::{benchmark_group, benchmark_main, Bencher};
|
|
use tokio::{
|
|
runtime::Runtime,
|
|
sync::{mpsc, oneshot},
|
|
};
|
|
|
|
fn request_reply_current_thread(b: &mut Bencher) {
|
|
let rt = tokio::runtime::Builder::new_current_thread()
|
|
.build()
|
|
.unwrap();
|
|
|
|
request_reply(b, rt);
|
|
}
|
|
|
|
fn request_reply_multi_threaded(b: &mut Bencher) {
|
|
let rt = tokio::runtime::Builder::new_multi_thread()
|
|
.worker_threads(1)
|
|
.build()
|
|
.unwrap();
|
|
|
|
request_reply(b, rt);
|
|
}
|
|
|
|
fn request_reply(b: &mut Bencher, rt: Runtime) {
|
|
let tx = rt.block_on(async move {
|
|
let (tx, mut rx) = mpsc::channel::<oneshot::Sender<()>>(10);
|
|
tokio::spawn(async move {
|
|
while let Some(reply) = rx.recv().await {
|
|
reply.send(()).unwrap();
|
|
}
|
|
});
|
|
tx
|
|
});
|
|
|
|
b.iter(|| {
|
|
let task_tx = tx.clone();
|
|
rt.block_on(async move {
|
|
for _ in 0..1_000 {
|
|
let (o_tx, o_rx) = oneshot::channel();
|
|
task_tx.send(o_tx).await.unwrap();
|
|
let _ = o_rx.await;
|
|
}
|
|
})
|
|
});
|
|
}
|
|
|
|
benchmark_group!(
|
|
sync_mpsc_oneshot_group,
|
|
request_reply_current_thread,
|
|
request_reply_multi_threaded,
|
|
);
|
|
|
|
benchmark_main!(sync_mpsc_oneshot_group);
|