bastion-executor 0.4.2

Cache affine NUMA-aware executor for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#![feature(test)]

extern crate test;

use bastion_executor::load_balancer;
use bastion_executor::prelude::spawn;
use futures_timer::Delay;
use lightproc::proc_stack::ProcStack;
use std::time::Duration;
use test::Bencher;

#[cfg(feature = "tokio-runtime")]
mod tokio_benchs {
    use super::*;
    #[bench]
    fn spawn_lot(b: &mut Bencher) {
        tokio_test::block_on(async { _spawn_lot(b) });
    }
    #[bench]
    fn spawn_single(b: &mut Bencher) {
        tokio_test::block_on(async {
            _spawn_single(b);
        });
    }
}

#[cfg(not(feature = "tokio-runtime"))]
mod no_tokio_benchs {
    use super::*;
    #[bench]
    fn spawn_lot(b: &mut Bencher) {
        _spawn_lot(b);
    }
    #[bench]
    fn spawn_single(b: &mut Bencher) {
        _spawn_single(b);
    }
}

// Benchmark for a 10K burst task spawn
fn _spawn_lot(b: &mut Bencher) {
    let proc_stack = ProcStack::default();
    b.iter(|| {
        let _ = (0..10_000)
            .map(|_| {
                spawn(
                    async {
                        let duration = Duration::from_millis(1);
                        Delay::new(duration).await;
                    },
                    proc_stack.clone(),
                )
            })
            .collect::<Vec<_>>();
    });
}

// Benchmark for a single task spawn
fn _spawn_single(b: &mut Bencher) {
    let proc_stack = ProcStack::default();
    b.iter(|| {
        spawn(
            async {
                let duration = Duration::from_millis(1);
                Delay::new(duration).await;
            },
            proc_stack.clone(),
        );
    });
}