hashbrown 0.17.1

A Rust port of Google's SwissTable hash map
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

//! This file contains benchmarks for the ops traits implemented by HashSet.
//! Each test is intended to have a defined larger and smaller set,
//! but using a larger size for the "small" set works just as well.
//!
//! Each assigning test is done in the configuration that is faster. Cheating, I know.
//! The exception to this is Sub, because there the result differs. So I made two benchmarks for Sub.
use criterion::Criterion;
use hashbrown::HashSet;

/// The number of items to generate for the larger of the sets.
const LARGE_SET_SIZE: usize = 1000;

/// The number of items to generate for the smaller of the sets.
const SMALL_SET_SIZE: usize = 100;

/// The number of keys present in both sets.
const OVERLAP: usize =
    [LARGE_SET_SIZE, SMALL_SET_SIZE][(LARGE_SET_SIZE < SMALL_SET_SIZE) as usize] / 2;

/// Creates a set containing end - start unique string elements.
fn create_set(start: usize, end: usize) -> HashSet<String> {
    (start..end).map(|nr| format!("key{nr}")).collect()
}

pub(crate) fn register_benches(c: &mut Criterion) {
    let large_set = create_set(0, LARGE_SET_SIZE);
    let small_set = create_set(
        LARGE_SET_SIZE - OVERLAP,
        LARGE_SET_SIZE + SMALL_SET_SIZE - OVERLAP,
    );

    c.bench_function("set_ops_bit_or", |b| {
        b.iter(|| &large_set | &small_set);
    });

    c.bench_function("set_ops_bit_and", |b| {
        b.iter(|| &large_set & &small_set);
    });

    c.bench_function("set_ops_bit_xor", |b| {
        b.iter(|| &large_set ^ &small_set);
    });

    c.bench_function("set_ops_sub_large_small", |b| {
        b.iter(|| &large_set - &small_set);
    });

    c.bench_function("set_ops_sub_small_large", |b| {
        b.iter(|| &small_set - &large_set);
    });

    c.bench_function("set_ops_bit_or_assign", |b| {
        b.iter(|| {
            let mut set = large_set.clone();
            set |= &small_set;
            set
        });
    });

    c.bench_function("set_ops_bit_and_assign", |b| {
        b.iter(|| {
            let mut set = small_set.clone();
            set &= &large_set;
            set
        });
    });

    c.bench_function("set_ops_bit_xor_assign", |b| {
        b.iter(|| {
            let mut set = large_set.clone();
            set ^= &small_set;
            set
        });
    });

    c.bench_function("set_ops_sub_assign_large_small", |b| {
        b.iter(|| {
            let mut set = large_set.clone();
            set -= &small_set;
            set
        });
    });

    c.bench_function("set_ops_sub_assign_small_large", |b| {
        b.iter(|| {
            let mut set = small_set.clone();
            set -= &large_set;
            set
        });
    });
}