pointer-identity 0.1.1

Wrapper type to treat the pointer address of types as identity rather than the value
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use pointer_identity::PointerIdentity;
use rand::prelude::*;
use std::{
    collections::{BTreeMap, HashMap},
    rc::Rc,
    sync::Arc,
};

fn criterion_benchmark(c: &mut Criterion) {
    // how many times to read every key
    let read_multiplier = 10;
    // how many keys there are
    let data_size = 10000;

    let mut rng = thread_rng();

    let mut group = c.benchmark_group("BTreeMap");
    for key_length in [10, 100, 1000].into_iter() {
        let mut keys: Vec<Vec<u8>> = vec![];
        for _ in 0..data_size {
            let mut key = vec![0; key_length];
            rng.fill(&mut key[0..key_length]);
            keys.push(key);
        }

        let mut lookup = vec![];
        for _ in 1..(read_multiplier * keys.len()) {
            lookup.push(rng.gen_range(0..keys.len()));
        }

        {
            let keys: Vec<Rc<[u8]>> = keys.iter().map(|key| key.clone().into()).collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: BTreeMap<Rc<[u8]>, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("Rc<[u8]>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }

        {
            let keys: Vec<PointerIdentity<Rc<[u8]>>> = keys
                .iter()
                .map(|key| PointerIdentity(key.clone().into()))
                .collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: BTreeMap<_, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("PointerIdentity<Rc<[u8]>>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }

        {
            let keys: Vec<PointerIdentity<Arc<[u8]>>> = keys
                .iter()
                .map(|key| PointerIdentity(key.clone().into()))
                .collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: BTreeMap<_, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("PointerIdentity<Arc<[u8]>>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }
    }
    group.finish();

    let mut group = c.benchmark_group("HashMap");
    for key_length in [10, 100, 1000].into_iter() {
        let mut keys: Vec<Vec<u8>> = vec![];
        for _ in 0..data_size {
            let mut key = vec![0; key_length];
            rng.fill(&mut key[0..key_length]);
            keys.push(key);
        }

        let mut lookup = vec![];
        for _ in 0..(read_multiplier * keys.len()) {
            lookup.push(rng.gen_range(0..keys.len()));
        }

        {
            let keys: Vec<Rc<[u8]>> = keys.iter().map(|key| key.clone().into()).collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: HashMap<Rc<[u8]>, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("Rc<[u8]>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }

        {
            let keys: Vec<PointerIdentity<Rc<[u8]>>> = keys
                .iter()
                .map(|key| PointerIdentity(key.clone().into()))
                .collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: HashMap<_, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("PointerIdentity<Rc<[u8]>>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }

        {
            let keys: Vec<PointerIdentity<Arc<[u8]>>> = keys
                .iter()
                .map(|key| PointerIdentity(key.clone().into()))
                .collect();
            let lookup: Vec<_> = lookup.iter().map(|i| keys[*i].clone()).collect();
            let map: HashMap<_, usize> =
                keys.into_iter().enumerate().map(|(x, i)| (i, x)).collect();
            group.bench_function(BenchmarkId::new("PointerIdentity<Arc<[u8]>>", key_length), |b| {
                b.iter(|| {
                    for value in lookup.iter() {
                        black_box(map.get(value).unwrap());
                    }
                })
            });
        }
    }
    group.finish();
}

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