small-collections 0.6.0

A collection of data structures optimized for small-buffer scenarios that reside on the stack and seamlessly spill to the heap.
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use criterion::{Criterion, black_box, criterion_group, criterion_main};
use small_collections::SmallLruCache;
use std::num::NonZeroUsize;

fn bench_lru_cache(c: &mut Criterion) {
    let n_large = 128;
    let cap_large = NonZeroUsize::new(n_large).unwrap();
    let n_small = 8;
    let cap_small = NonZeroUsize::new(n_small).unwrap();

    // --- N = 8 ---
    {
        let mut group = c.benchmark_group("LruCache vs SmallLruCache (Put 8)");
        group.bench_function("lru::LruCache", |b| {
            b.iter(|| {
                let mut l = lru::LruCache::new(cap_small);
                for i in 0..n_small {
                    l.put(black_box(i as i32), black_box(i as i32));
                }
                l
            })
        });

        group.bench_function("SmallLruCache<i32, i32, 8>", |b| {
            b.iter(|| {
                let mut l: SmallLruCache<i32, i32, 8> = SmallLruCache::new(cap_small);
                for i in 0..n_small {
                    l.put(black_box(i as i32), black_box(i as i32));
                }
                l
            })
        });
        group.finish();
    }

    {
        let mut group = c.benchmark_group("LruCache vs SmallLruCache (Get 8)");
        let mut l_std = lru::LruCache::new(cap_small);
        let mut l_small: SmallLruCache<i32, i32, 8> = SmallLruCache::new(cap_small);
        for i in 0..n_small {
            l_std.put(i as i32, i as i32);
            l_small.put(i as i32, i as i32);
        }

        group.bench_function("lru::LruCache", |b| {
            b.iter(|| {
                for i in 0..n_small {
                    black_box(l_std.get(&black_box(i as i32)));
                }
            })
        });

        group.bench_function("SmallLruCache<i32, i32, 8>", |b| {
            b.iter(|| {
                for i in 0..n_small {
                    black_box(l_small.get(&black_box(i as i32)));
                }
            })
        });
        group.finish();
    }

    // --- N = 128 ---
    {
        let mut group = c.benchmark_group("LruCache vs SmallLruCache (Put 128)");
        group.bench_function("lru::LruCache", |b| {
            b.iter(|| {
                let mut l = lru::LruCache::new(cap_large);
                for i in 0..n_large {
                    l.put(black_box(i as i32), black_box(i as i32));
                }
                l
            })
        });

        group.bench_function("SmallLruCache<i32, i32, 128>", |b| {
            b.iter(|| {
                let mut l: SmallLruCache<i32, i32, 128> = SmallLruCache::new(cap_large);
                for i in 0..n_large {
                    l.put(black_box(i as i32), black_box(i as i32));
                }
                l
            })
        });
        group.finish();
    }

    {
        let mut group = c.benchmark_group("LruCache vs SmallLruCache (Get 128)");
        let mut l_std = lru::LruCache::new(cap_large);
        let mut l_small: SmallLruCache<i32, i32, 128> = SmallLruCache::new(cap_large);
        for i in 0..n_large {
            l_std.put(i as i32, i as i32);
            l_small.put(i as i32, i as i32);
        }

        group.bench_function("lru::LruCache", |b| {
            b.iter(|| {
                for i in 0..n_large {
                    black_box(l_std.get(&black_box(i as i32)));
                }
            })
        });

        group.bench_function("SmallLruCache<i32, i32, 128>", |b| {
            b.iter(|| {
                for i in 0..n_large {
                    black_box(l_small.get(&black_box(i as i32)));
                }
            })
        });
        group.finish();
    }
}

criterion_group!(benches, bench_lru_cache);
criterion_main!(benches);