commonware-storage 2026.4.0

Persist and retrieve data from an abstract store.
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

use criterion::{criterion_group, BatchSize, Criterion};
use rand::Rng;
use std::{collections::HashMap, hint::black_box};

#[cfg(not(full_bench))]
const N_ITEMS: [usize; 1] = [100_000];
#[cfg(full_bench)]
const N_ITEMS: [usize; 3] = [100_000, 1_000_000, 10_000_000];

struct MockIndex {
    section: u64,
    _offset: u32,
    _len: u32,
    _next: Option<Box<Self>>,
}

fn bench_hashmap_iteration(c: &mut Criterion) {
    for n in N_ITEMS {
        for k in [4, 8, 16, 32] {
            c.bench_function(&format!("{}/n={} k={}", module_path!(), n, k), |b| {
                b.iter_batched(
                    || {
                        let mut map = HashMap::with_capacity(n);
                        let mut rng = rand::thread_rng();
                        let mut key = vec![0; k];

                        // Populate the HashMap with dummy data
                        for _ in 0..n {
                            rng.fill(&mut key[..]);
                            let value = MockIndex {
                                section: rng.gen(),
                                _offset: rng.gen(),
                                _len: rng.gen(),
                                _next: None,
                            };
                            map.insert(key.clone(), value);
                        }
                        map
                    },
                    |map| {
                        for (_, value) in map {
                            let _ = black_box(value.section);
                        }
                    },
                    BatchSize::SmallInput,
                )
            });
        }
    }
}

criterion_group! {
    name = benches;
    config = Criterion::default().sample_size(10);
    targets = bench_hashmap_iteration
}