How to Benchmark Rust Code?

fn main() {
    // Run registered benchmarks.
    divan::main();
}

// Define the function we want to benchmark
fn fibonacci(n: u64) -> u64 {
    if n <= 1 {
        1
    } else {
        fibonacci(n - 2) + fibonacci(n - 1)
    }
}

// Register a simple benchmark
#[divan::bench]
fn fib_bench() -> u64 {
    fibonacci(divan::black_box(10))
}

[[bench]]
name = "fibonacci"
harness = false

// Register a benchmark with multiple input sizes
#[divan::bench(args = [1, 2, 4, 8, 16, 32])]
fn fib_bench(n: u64) -> u64 {
    fibonacci(divan::black_box(n))
}

fn main() {
    divan::main();
}

#[divan::bench(args = [100, 1000, 10000])]
fn search_vector(bencher: divan::Bencher, size: usize) {
    // Setup: create a vector with test data
    // This runs once before all iterations
    let data: Vec<i32> = (0..size as i32).collect();
    let target = size as i32 / 2;

    bencher.bench_local(|| {
        // Only this part is measured
        data.iter().find(|&&x| x == target)
    });
}

fn main() {
    divan::main();
}

#[divan::bench(types = [&str, String])]
fn from_str<'a, T>() -> T
where
    T: From<&'a str>,
{
    divan::black_box("hello world").into()
}

fn main() {
    divan::main();
}

// Expensive function to generate test data
fn generate_large_json(size: usize) -> String {
    let items: Vec<_> = (0..size)
        .map(|i| format!(r#"{{"id":{},"name":"item_{}","value":{}}}"#, i, i, i * 10))
        .collect();
    format!("[{}]", items.join(","))
}

#[divan::bench(args = [10, 100, 1000])]
fn parse_json(bencher: divan::Bencher, size: usize) {
    bencher
        .with_inputs(|| {
            // Generate test JSON data for each iteration.
            // This time is NOT measured.
            generate_large_json(size)
        })
        .bench_values(|json_string| {
            // This is what we're actually benchmarking:
            // parsing the JSON string.
            serde_json::from_str::<serde_json::Value>(&json_string)
        });
}

use tokio::runtime::Runtime;
use tokio::time::{Duration, sleep};

fn main() {
    divan::main();
}

#[divan::bench]
fn async_sleep_benchmark(bencher: divan::Bencher) {
    let rt = Runtime::new().unwrap();

    bencher.bench_local(|| {
        rt.block_on(async {
            sleep(Duration::from_millis(100)).await; // simulates async work for 100ms
        });
    });
}

pub fn bubble_sort(mut arr: Vec<i32>) -> Vec<i32> {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n - 1 - i {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
            }
        }
    }
    arr
}

use my_lib::bubble_sort; // replace `my_lib` with your crate name

fn main() {
    divan::main();
}

// Generate synthetic test data
fn generate_random_vec(size: usize) -> Vec<i32> {
    use std::collections::hash_map::DefaultHasher;
    use std::hash::{Hash, Hasher};

    (0..size)
        .map(|i| {
            let mut hasher = DefaultHasher::new();
            i.hash(&mut hasher);
            (hasher.finish() % 10000) as i32
        })
        .collect()
}

#[divan::bench(args = [100, 1000, 10_000])]
fn bench_bubble_sort(bencher: divan::Bencher, size: usize) {
    bencher
        .with_inputs(|| generate_random_vec(size))
        .bench_values(|data| bubble_sort(data));
}

[workspace]
members = ["crate_a", "crate_b"]

[dev-dependencies]
divan = "0.1.21"

[package]
name = "crate_a"
version = "0.1.0"
edition = "2021"

[[bench]]
name = "sorting"
harness = false

[dev-dependencies]
divan = { workspace = true } # use the workspace version