Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_o3db_sync/benches/map.rs

7.7 KiB, 5 runs

created by r1870400018:659, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1// To switch to nightly to run these benchmarks:
2// > rustup override set nightly
3// > clear;clear;cargo bench
4// To switch back to stable:
5// > rustup override set stable
6//
7// Run this with
8// > cargo bench
9#![feature(test)]
10extern crate test;
11
12use oxedyne_fe2o3_core::prelude::*;
13use oxedyne_fe2o3_crypto::{
14 hash::HashScheme,
15};
16
17use test::Bencher;
18
19use std::{
20 collections::{
21 HashMap,
22 BTreeMap,
23 },
24};
25
26const VAL_LEN: usize = 1_000;
27const KEY_LEN: usize = 32;
28
29fn gen_val() -> Vec<u8> {
30 vec![42u8; VAL_LEN]
31}
32
33fn gen_key() -> Vec<u8> {
34 vec![42u8; KEY_LEN]
35}
36
37//-----------------------------------------------------------------------------------------------//
38// Create maps
39//-----------------------------------------------------------------------------------------------//
40#[bench]
41fn bench_create_u32_hashmap(b: &mut Bencher) -> Result<()> {
42 b.iter(|| {
43 test::black_box({
44 let mut map: HashMap<u32, Vec<u8>> = HashMap::new();
45 });
46 });
47 Ok(())
48}
49
50#[bench]
51fn bench_create_u64_hashmap(b: &mut Bencher) -> Result<()> {
52 b.iter(|| {
53 test::black_box({
54 let mut map: HashMap<u64, Vec<u8>> = HashMap::new();
55 });
56 });
57 Ok(())
58}
59
60#[bench]
61fn bench_create_u128_hashmap(b: &mut Bencher) -> Result<()> {
62 b.iter(|| {
63 test::black_box({
64 let mut map: HashMap<u128, Vec<u8>> = HashMap::new();
65 });
66 });
67 Ok(())
68}
69
70#[bench]
71fn bench_create_vecu8_hashmap(b: &mut Bencher) -> Result<()> {
72 b.iter(|| {
73 test::black_box({
74 let mut map: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
75 });
76 });
77 Ok(())
78}
79
80#[bench]
81fn bench_create_u32_btreemap(b: &mut Bencher) -> Result<()> {
82 b.iter(|| {
83 test::black_box({
84 let mut map: BTreeMap<u32, Vec<u8>> = BTreeMap::new();
85 });
86 });
87 Ok(())
88}
89
90#[bench]
91fn bench_create_u64_btreemap(b: &mut Bencher) -> Result<()> {
92 b.iter(|| {
93 test::black_box({
94 let mut map: BTreeMap<u64, Vec<u8>> = BTreeMap::new();
95 });
96 });
97 Ok(())
98}
99
100#[bench]
101fn bench_create_u128_btreemap(b: &mut Bencher) -> Result<()> {
102 b.iter(|| {
103 test::black_box({
104 let mut map: BTreeMap<u128, Vec<u8>> = BTreeMap::new();
105 });
106 });
107 Ok(())
108}
109
110#[bench]
111fn bench_create_vecu8_btreemap(b: &mut Bencher) -> Result<()> {
112 b.iter(|| {
113 test::black_box({
114 let mut map: BTreeMap<Vec<u8>, Vec<u8>> = BTreeMap::new();
115 });
116 });
117 Ok(())
118}
119
120//-----------------------------------------------------------------------------------------------//
121// Map insertion
122//-----------------------------------------------------------------------------------------------//
123
124#[bench]
125fn bench_insert_u32_hashmap(b: &mut Bencher) -> Result<()> {
126 let mut map: HashMap<u32, Vec<u8>> = HashMap::new();
127 b.iter(|| {
128 let key = gen_key();
129 let val = gen_val();
130 test::black_box({
131 map.insert(42u32, val);
132 });
133 });
134 Ok(())
135}
136
137#[bench]
138fn bench_insert_u64_hashmap(b: &mut Bencher) -> Result<()> {
139 let mut map: HashMap<u64, Vec<u8>> = HashMap::new();
140 b.iter(|| {
141 let key = gen_key();
142 let val = gen_val();
143 test::black_box({
144 map.insert(42u64, val);
145 });
146 });
147 Ok(())
148}
149
150#[bench]
151fn bench_insert_u128_hashmap(b: &mut Bencher) -> Result<()> {
152 let mut map: HashMap<u128, Vec<u8>> = HashMap::new();
153 b.iter(|| {
154 let key = gen_key();
155 let val = gen_val();
156 test::black_box({
157 map.insert(42u128, val);
158 });
159 });
160 Ok(())
161}
162
163#[bench]
164fn bench_insert_vecu8_hashmap(b: &mut Bencher) -> Result<()> {
165 let mut map: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
166 b.iter(|| {
167 let key = gen_key();
168 let val = gen_val();
169 test::black_box({
170 map.insert(key, val);
171 });
172 });
173 Ok(())
174}
175
176#[bench]
177fn bench_insert_u32_btreemap(b: &mut Bencher) -> Result<()> {
178 let mut map: BTreeMap<u32, Vec<u8>> = BTreeMap::new();
179 b.iter(|| {
180 let key = gen_key();
181 let val = gen_val();
182 test::black_box({
183 map.insert(42u32, val);
184 });
185 });
186 Ok(())
187}
188
189#[bench]
190fn bench_insert_u64_btreemap(b: &mut Bencher) -> Result<()> {
191 let mut map: BTreeMap<u64, Vec<u8>> = BTreeMap::new();
192 b.iter(|| {
193 let key = gen_key();
194 let val = gen_val();
195 test::black_box({
196 map.insert(42u64, val);
197 });
198 });
199 Ok(())
200}
201
202#[bench]
203fn bench_insert_u128_btreemap(b: &mut Bencher) -> Result<()> {
204 let mut map: BTreeMap<u128, Vec<u8>> = BTreeMap::new();
205 b.iter(|| {
206 let key = gen_key();
207 let val = gen_val();
208 test::black_box({
209 map.insert(42u128, val);
210 });
211 });
212 Ok(())
213}
214
215#[bench]
216fn bench_insert_vecu8_btreemap(b: &mut Bencher) -> Result<()> {
217 let mut map: BTreeMap<Vec<u8>, Vec<u8>> = BTreeMap::new();
218 b.iter(|| {
219 let key = gen_key();
220 let val = gen_val();
221 test::black_box({
222 map.insert(key, val);
223 });
224 });
225 Ok(())
226}
227
228//-----------------------------------------------------------------------------------------------//
229// Map retrieval
230//-----------------------------------------------------------------------------------------------//
231
232#[bench]
233fn bench_get_u32_hashmap(b: &mut Bencher) -> Result<()> {
234 let val = gen_val();
235 let mut map: HashMap<u32, Vec<u8>> = HashMap::new();
236 map.insert(42u32, val);
237 b.iter(|| {
238 test::black_box({
239 let val_opt = map.get(&42u32);
240 });
241 });
242 Ok(())
243}
244
245#[bench]
246fn bench_get_u64_hashmap(b: &mut Bencher) -> Result<()> {
247 let val = gen_val();
248 let mut map: HashMap<u64, Vec<u8>> = HashMap::new();
249 map.insert(42u64, val);
250 b.iter(|| {
251 test::black_box({
252 let val_opt = map.get(&42u64);
253 });
254 });
255 Ok(())
256}
257
258#[bench]
259fn bench_get_u128_hashmap(b: &mut Bencher) -> Result<()> {
260 let val = gen_val();
261 let mut map: HashMap<u128, Vec<u8>> = HashMap::new();
262 map.insert(42u128, val);
263 b.iter(|| {
264 test::black_box({
265 let val_opt = map.get(&42u128);
266 });
267 });
268 Ok(())
269}
270
271#[bench]
272fn bench_get_vecu8_hashmap(b: &mut Bencher) -> Result<()> {
273 let key = gen_key();
274 let val = gen_val();
275 let mut map: HashMap<Vec<u8>, Vec<u8>> = HashMap::new();
276 map.insert(key.clone(), val);
277 b.iter(|| {
278 test::black_box({
279 let val_opt = map.get(&key);
280 });
281 });
282 Ok(())
283}
284
285#[bench]
286fn bench_get_u32_btreemap(b: &mut Bencher) -> Result<()> {
287 let val = gen_val();
288 let mut map: BTreeMap<u32, Vec<u8>> = BTreeMap::new();
289 map.insert(42u32, val);
290 b.iter(|| {
291 test::black_box({
292 let val_opt = map.get(&42u32);
293 });
294 });
295 Ok(())
296}
297
298#[bench]
299fn bench_get_u64_btreemap(b: &mut Bencher) -> Result<()> {
300 let val = gen_val();
301 let mut map: BTreeMap<u64, Vec<u8>> = BTreeMap::new();
302 map.insert(42u64, val);
303 b.iter(|| {
304 test::black_box({
305 let val_opt = map.get(&42u64);
306 });
307 });
308 Ok(())
309}
310
311#[bench]
312fn bench_get_u128_btreemap(b: &mut Bencher) -> Result<()> {
313 let val = gen_val();
314 let mut map: BTreeMap<u128, Vec<u8>> = BTreeMap::new();
315 map.insert(42u128, val);
316 b.iter(|| {
317 test::black_box({
318 let val_opt = map.get(&42u128);
319 });
320 });
321 Ok(())
322}
323
324#[bench]
325fn bench_get_vecu8_btreemap(b: &mut Bencher) -> Result<()> {
326 let key = gen_key();
327 let val = gen_val();
328 let mut map: BTreeMap<Vec<u8>, Vec<u8>> = BTreeMap::new();
329 map.insert(key.clone(), val);
330 b.iter(|| {
331 test::black_box({
332 let val_opt = map.get(&key);
333 });
334 });
335 Ok(())
336}
337