Lib.rs

Microbenchmarks macro

Measures the average time for a given number of iterations. Easy to use, zero deps.

Cargo.toml

[dependencies]
mbench = "0.1"

main.rs

#[macro_use]
extern crate mbench;

fn my_func(x: u32) { vec![x; u16::MAX as usize].sort(); }

fn main() {
    let mut text = String::new();
    microbench!(
        text = "Hello world!".to_string();
        my_func(42);
        // ... code ....
    );
    println!("{text}");
}

Output

Elapsed / 10 = 3.70ms
Hello world!

The default is 10 iterations, but you can set an arbitrary number microbench!(4, {/* code */});.

microbench!(1, {
    text = "Hello world!".to_string();
    my_func(42);
});

Elapsed / 1 = 3.34ms
Hello world

In addition, there is a simplified syntax for setting the number of iterations (1,5,10,50,100,500,1000):

microbench1!(/* code */);
microbench5!(/* code */);
microbench10!(/* code */);
microbench50!(/* code */);
microbench100!(/* code */);
microbench500!(/* code */);
microbench1000!(/* code */);

With macro fixedbench!([0..=2], 10, {/* code */}); you can set the range in milliseconds (and optionally 10 iterations in this example). If the code runs longer or faster than the interval specified, then there will be a panic.

This can be used in tests. The test fails if the code becomes slower after the change. The default is 1 iteration.

#[macro_use]
extern crate mbench;

fn my_func(ms: u64) {
    let ms = std::time::Duration::from_millis(ms);
    std::thread::sleep(ms);
}

#[cfg(test)]
mod tests {
    use super::my_func;

    #[test]
    fn simple() {
        fixedbench!([..=2], {
            my_func(3);
        });
    }
}

running 1 test
test tests::simple ... FAILED

failures:

---- tests::simple stdout ----
Elapsed / 1 = 3.36ms
thread 'tests::simple' panicked at 'expected [..=2]ms, finished in 3ms.', main.rs:15:9

Keep in mind that the running time of the code may vary on different machines. After completing work on a piece of code, such a test should be removed or commented out.