## Microbenchmarks macro

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

**Cargo.toml**

```toml
[dependencies]
mbench = "0.1"
```

**main.rs**

```rust
#[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**

```sh
Elapsed / 10 = 3.70ms
Hello world!
```

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

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

```sh
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):

```rust
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.

```rust
#[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);
        });
    }
}
```

```sh
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.