2 use std
::iter
::{repeat, FromIterator}
;
3 use test
::{black_box, Bencher}
;
6 fn bench_new(b
: &mut Bencher
) {
7 b
.iter(|| Vec
::<u32>::new())
10 fn do_bench_with_capacity(b
: &mut Bencher
, src_len
: usize) {
11 b
.bytes
= src_len
as u64;
13 b
.iter(|| Vec
::<u32>::with_capacity(src_len
))
17 fn bench_with_capacity_0000(b
: &mut Bencher
) {
18 do_bench_with_capacity(b
, 0)
22 fn bench_with_capacity_0010(b
: &mut Bencher
) {
23 do_bench_with_capacity(b
, 10)
27 fn bench_with_capacity_0100(b
: &mut Bencher
) {
28 do_bench_with_capacity(b
, 100)
32 fn bench_with_capacity_1000(b
: &mut Bencher
) {
33 do_bench_with_capacity(b
, 1000)
36 fn do_bench_from_fn(b
: &mut Bencher
, src_len
: usize) {
37 b
.bytes
= src_len
as u64;
39 b
.iter(|| (0..src_len
).collect
::<Vec
<_
>>())
43 fn bench_from_fn_0000(b
: &mut Bencher
) {
44 do_bench_from_fn(b
, 0)
48 fn bench_from_fn_0010(b
: &mut Bencher
) {
49 do_bench_from_fn(b
, 10)
53 fn bench_from_fn_0100(b
: &mut Bencher
) {
54 do_bench_from_fn(b
, 100)
58 fn bench_from_fn_1000(b
: &mut Bencher
) {
59 do_bench_from_fn(b
, 1000)
62 fn do_bench_from_elem(b
: &mut Bencher
, src_len
: usize) {
63 b
.bytes
= src_len
as u64;
65 b
.iter(|| repeat(5).take(src_len
).collect
::<Vec
<usize>>())
69 fn bench_from_elem_0000(b
: &mut Bencher
) {
70 do_bench_from_elem(b
, 0)
74 fn bench_from_elem_0010(b
: &mut Bencher
) {
75 do_bench_from_elem(b
, 10)
79 fn bench_from_elem_0100(b
: &mut Bencher
) {
80 do_bench_from_elem(b
, 100)
84 fn bench_from_elem_1000(b
: &mut Bencher
) {
85 do_bench_from_elem(b
, 1000)
88 fn do_bench_from_slice(b
: &mut Bencher
, src_len
: usize) {
89 let src
: Vec
<_
> = FromIterator
::from_iter(0..src_len
);
91 b
.bytes
= src_len
as u64;
93 b
.iter(|| src
.as_slice().to_vec());
97 fn bench_from_slice_0000(b
: &mut Bencher
) {
98 do_bench_from_slice(b
, 0)
102 fn bench_from_slice_0010(b
: &mut Bencher
) {
103 do_bench_from_slice(b
, 10)
107 fn bench_from_slice_0100(b
: &mut Bencher
) {
108 do_bench_from_slice(b
, 100)
112 fn bench_from_slice_1000(b
: &mut Bencher
) {
113 do_bench_from_slice(b
, 1000)
116 fn do_bench_from_iter(b
: &mut Bencher
, src_len
: usize) {
117 let src
: Vec
<_
> = FromIterator
::from_iter(0..src_len
);
119 b
.bytes
= src_len
as u64;
122 let dst
: Vec
<_
> = FromIterator
::from_iter(src
.iter().cloned());
128 fn bench_from_iter_0000(b
: &mut Bencher
) {
129 do_bench_from_iter(b
, 0)
133 fn bench_from_iter_0010(b
: &mut Bencher
) {
134 do_bench_from_iter(b
, 10)
138 fn bench_from_iter_0100(b
: &mut Bencher
) {
139 do_bench_from_iter(b
, 100)
143 fn bench_from_iter_1000(b
: &mut Bencher
) {
144 do_bench_from_iter(b
, 1000)
147 fn do_bench_extend(b
: &mut Bencher
, dst_len
: usize, src_len
: usize) {
148 let dst
: Vec
<_
> = FromIterator
::from_iter(0..dst_len
);
149 let src
: Vec
<_
> = FromIterator
::from_iter(dst_len
..dst_len
+ src_len
);
151 b
.bytes
= src_len
as u64;
154 let mut dst
= dst
.clone();
155 dst
.extend(src
.clone());
161 fn bench_extend_0000_0000(b
: &mut Bencher
) {
162 do_bench_extend(b
, 0, 0)
166 fn bench_extend_0000_0010(b
: &mut Bencher
) {
167 do_bench_extend(b
, 0, 10)
171 fn bench_extend_0000_0100(b
: &mut Bencher
) {
172 do_bench_extend(b
, 0, 100)
176 fn bench_extend_0000_1000(b
: &mut Bencher
) {
177 do_bench_extend(b
, 0, 1000)
181 fn bench_extend_0010_0010(b
: &mut Bencher
) {
182 do_bench_extend(b
, 10, 10)
186 fn bench_extend_0100_0100(b
: &mut Bencher
) {
187 do_bench_extend(b
, 100, 100)
191 fn bench_extend_1000_1000(b
: &mut Bencher
) {
192 do_bench_extend(b
, 1000, 1000)
195 fn do_bench_extend_from_slice(b
: &mut Bencher
, dst_len
: usize, src_len
: usize) {
196 let dst
: Vec
<_
> = FromIterator
::from_iter(0..dst_len
);
197 let src
: Vec
<_
> = FromIterator
::from_iter(dst_len
..dst_len
+ src_len
);
199 b
.bytes
= src_len
as u64;
202 let mut dst
= dst
.clone();
203 dst
.extend_from_slice(&src
);
209 fn bench_extend_recycle(b
: &mut Bencher
) {
210 let mut data
= vec
![0; 1000];
213 let tmp
= std
::mem
::take(&mut data
);
214 let mut to_extend
= black_box(Vec
::new());
215 to_extend
.extend(tmp
.into_iter());
216 data
= black_box(to_extend
);
223 fn bench_extend_from_slice_0000_0000(b
: &mut Bencher
) {
224 do_bench_extend_from_slice(b
, 0, 0)
228 fn bench_extend_from_slice_0000_0010(b
: &mut Bencher
) {
229 do_bench_extend_from_slice(b
, 0, 10)
233 fn bench_extend_from_slice_0000_0100(b
: &mut Bencher
) {
234 do_bench_extend_from_slice(b
, 0, 100)
238 fn bench_extend_from_slice_0000_1000(b
: &mut Bencher
) {
239 do_bench_extend_from_slice(b
, 0, 1000)
243 fn bench_extend_from_slice_0010_0010(b
: &mut Bencher
) {
244 do_bench_extend_from_slice(b
, 10, 10)
248 fn bench_extend_from_slice_0100_0100(b
: &mut Bencher
) {
249 do_bench_extend_from_slice(b
, 100, 100)
253 fn bench_extend_from_slice_1000_1000(b
: &mut Bencher
) {
254 do_bench_extend_from_slice(b
, 1000, 1000)
257 fn do_bench_clone(b
: &mut Bencher
, src_len
: usize) {
258 let src
: Vec
<usize> = FromIterator
::from_iter(0..src_len
);
260 b
.bytes
= src_len
as u64;
262 b
.iter(|| src
.clone());
266 fn bench_clone_0000(b
: &mut Bencher
) {
271 fn bench_clone_0010(b
: &mut Bencher
) {
272 do_bench_clone(b
, 10)
276 fn bench_clone_0100(b
: &mut Bencher
) {
277 do_bench_clone(b
, 100)
281 fn bench_clone_1000(b
: &mut Bencher
) {
282 do_bench_clone(b
, 1000)
285 fn do_bench_clone_from(b
: &mut Bencher
, times
: usize, dst_len
: usize, src_len
: usize) {
286 let dst
: Vec
<_
> = FromIterator
::from_iter(0..src_len
);
287 let src
: Vec
<_
> = FromIterator
::from_iter(dst_len
..dst_len
+ src_len
);
289 b
.bytes
= (times
* src_len
) as u64;
292 let mut dst
= dst
.clone();
295 dst
.clone_from(&src
);
296 dst
= black_box(dst
);
303 fn bench_clone_from_01_0000_0000(b
: &mut Bencher
) {
304 do_bench_clone_from(b
, 1, 0, 0)
308 fn bench_clone_from_01_0000_0010(b
: &mut Bencher
) {
309 do_bench_clone_from(b
, 1, 0, 10)
313 fn bench_clone_from_01_0000_0100(b
: &mut Bencher
) {
314 do_bench_clone_from(b
, 1, 0, 100)
318 fn bench_clone_from_01_0000_1000(b
: &mut Bencher
) {
319 do_bench_clone_from(b
, 1, 0, 1000)
323 fn bench_clone_from_01_0010_0010(b
: &mut Bencher
) {
324 do_bench_clone_from(b
, 1, 10, 10)
328 fn bench_clone_from_01_0100_0100(b
: &mut Bencher
) {
329 do_bench_clone_from(b
, 1, 100, 100)
333 fn bench_clone_from_01_1000_1000(b
: &mut Bencher
) {
334 do_bench_clone_from(b
, 1, 1000, 1000)
338 fn bench_clone_from_01_0010_0100(b
: &mut Bencher
) {
339 do_bench_clone_from(b
, 1, 10, 100)
343 fn bench_clone_from_01_0100_1000(b
: &mut Bencher
) {
344 do_bench_clone_from(b
, 1, 100, 1000)
348 fn bench_clone_from_01_0010_0000(b
: &mut Bencher
) {
349 do_bench_clone_from(b
, 1, 10, 0)
353 fn bench_clone_from_01_0100_0010(b
: &mut Bencher
) {
354 do_bench_clone_from(b
, 1, 100, 10)
358 fn bench_clone_from_01_1000_0100(b
: &mut Bencher
) {
359 do_bench_clone_from(b
, 1, 1000, 100)
363 fn bench_clone_from_10_0000_0000(b
: &mut Bencher
) {
364 do_bench_clone_from(b
, 10, 0, 0)
368 fn bench_clone_from_10_0000_0010(b
: &mut Bencher
) {
369 do_bench_clone_from(b
, 10, 0, 10)
373 fn bench_clone_from_10_0000_0100(b
: &mut Bencher
) {
374 do_bench_clone_from(b
, 10, 0, 100)
378 fn bench_clone_from_10_0000_1000(b
: &mut Bencher
) {
379 do_bench_clone_from(b
, 10, 0, 1000)
383 fn bench_clone_from_10_0010_0010(b
: &mut Bencher
) {
384 do_bench_clone_from(b
, 10, 10, 10)
388 fn bench_clone_from_10_0100_0100(b
: &mut Bencher
) {
389 do_bench_clone_from(b
, 10, 100, 100)
393 fn bench_clone_from_10_1000_1000(b
: &mut Bencher
) {
394 do_bench_clone_from(b
, 10, 1000, 1000)
398 fn bench_clone_from_10_0010_0100(b
: &mut Bencher
) {
399 do_bench_clone_from(b
, 10, 10, 100)
403 fn bench_clone_from_10_0100_1000(b
: &mut Bencher
) {
404 do_bench_clone_from(b
, 10, 100, 1000)
408 fn bench_clone_from_10_0010_0000(b
: &mut Bencher
) {
409 do_bench_clone_from(b
, 10, 10, 0)
413 fn bench_clone_from_10_0100_0010(b
: &mut Bencher
) {
414 do_bench_clone_from(b
, 10, 100, 10)
418 fn bench_clone_from_10_1000_0100(b
: &mut Bencher
) {
419 do_bench_clone_from(b
, 10, 1000, 100)
422 macro_rules
! bench_in_place
{
423 ($
($fname
:ident
, $
type:ty
, $count
:expr
, $init
:expr
);*) => {
426 fn $
fname(b
: &mut Bencher
) {
428 let src
: Vec
<$
type> = black_box(vec
![$init
; $count
]);
431 .map(|(idx
, e
)| idx
as $
type ^ e
)
432 .collect
::<Vec
<$
type>>()
440 bench_in_place_xxu8_0010_i0
, u8, 10, 0;
441 bench_in_place_xxu8_0100_i0
, u8, 100, 0;
442 bench_in_place_xxu8_1000_i0
, u8, 1000, 0;
443 bench_in_place_xxu8_0010_i1
, u8, 10, 1;
444 bench_in_place_xxu8_0100_i1
, u8, 100, 1;
445 bench_in_place_xxu8_1000_i1
, u8, 1000, 1;
446 bench_in_place_xu32_0010_i0
, u32, 10, 0;
447 bench_in_place_xu32_0100_i0
, u32, 100, 0;
448 bench_in_place_xu32_1000_i0
, u32, 1000, 0;
449 bench_in_place_xu32_0010_i1
, u32, 10, 1;
450 bench_in_place_xu32_0100_i1
, u32, 100, 1;
451 bench_in_place_xu32_1000_i1
, u32, 1000, 1;
452 bench_in_place_u128_0010_i0
, u128
, 10, 0;
453 bench_in_place_u128_0100_i0
, u128
, 100, 0;
454 bench_in_place_u128_1000_i0
, u128
, 1000, 0;
455 bench_in_place_u128_0010_i1
, u128
, 10, 1;
456 bench_in_place_u128_0100_i1
, u128
, 100, 1;
457 bench_in_place_u128_1000_i1
, u128
, 1000, 1
461 fn bench_in_place_recycle(b
: &mut Bencher
) {
462 let mut data
= vec
![0; 1000];
465 let tmp
= std
::mem
::take(&mut data
);
469 .map(|(idx
, e
)| idx
.wrapping_add(e
))
471 .collect
::<Vec
<usize>>(),
477 fn bench_in_place_zip_recycle(b
: &mut Bencher
) {
478 let mut data
= vec
![0u8; 1000];
479 let mut rng
= rand
::thread_rng();
480 let mut subst
= vec
![0u8; 1000];
481 rng
.fill_bytes(&mut subst
[..]);
484 let tmp
= std
::mem
::take(&mut data
);
487 .zip(subst
.iter().copied())
489 .map(|(i
, (d
, s
))| d
.wrapping_add(i
as u8) ^ s
)
490 .collect
::<Vec
<_
>>();
491 data
= black_box(mangled
);
496 fn bench_in_place_zip_iter_mut(b
: &mut Bencher
) {
497 let mut data
= vec
![0u8; 256];
498 let mut rng
= rand
::thread_rng();
499 let mut subst
= vec
![0u8; 1000];
500 rng
.fill_bytes(&mut subst
[..]);
503 data
.iter_mut().enumerate().for_each(|(i
, d
)| {
504 *d
= d
.wrapping_add(i
as u8) ^ subst
[i
];
511 pub fn vec_cast
<T
, U
>(input
: Vec
<T
>) -> Vec
<U
> {
512 input
.into_iter().map(|e
| unsafe { std::mem::transmute_copy(&e) }
).collect()
516 fn bench_transmute(b
: &mut Bencher
) {
517 let mut vec
= vec
![10u32; 100];
518 b
.bytes
= 800; // 2 casts x 4 bytes x 100
520 let v
= std
::mem
::take(&mut vec
);
521 let v
= black_box(vec_cast
::<u32, i32>(v
));
522 let v
= black_box(vec_cast
::<i32, u32>(v
));
528 struct Droppable(usize);
530 impl Drop
for Droppable
{
537 fn bench_in_place_collect_droppable(b
: &mut Bencher
) {
538 let v
: Vec
<Droppable
> = std
::iter
::repeat_with(|| Droppable(0)).take(1000).collect();
544 .map(|(i
, e
)| Droppable(i ^ e
.0))
549 const LEN
: usize = 16384;
552 fn bench_chain_collect(b
: &mut Bencher
) {
553 let data
= black_box([0; LEN
]);
554 b
.iter(|| data
.iter().cloned().chain([1].iter().cloned()).collect
::<Vec
<_
>>());
558 fn bench_chain_chain_collect(b
: &mut Bencher
) {
559 let data
= black_box([0; LEN
]);
563 .chain([1].iter().cloned())
564 .chain([2].iter().cloned())
570 fn bench_nest_chain_chain_collect(b
: &mut Bencher
) {
571 let data
= black_box([0; LEN
]);
573 data
.iter().cloned().chain([1].iter().chain([2].iter()).cloned()).collect
::<Vec
<_
>>()
578 fn bench_range_map_collect(b
: &mut Bencher
) {
579 b
.iter(|| (0..LEN
).map(|_
| u32::default()).collect
::<Vec
<_
>>());
583 fn bench_chain_extend_ref(b
: &mut Bencher
) {
584 let data
= black_box([0; LEN
]);
586 let mut v
= Vec
::<u32>::with_capacity(data
.len() + 1);
587 v
.extend(data
.iter().chain([1].iter()));
593 fn bench_chain_extend_value(b
: &mut Bencher
) {
594 let data
= black_box([0; LEN
]);
596 let mut v
= Vec
::<u32>::with_capacity(data
.len() + 1);
597 v
.extend(data
.iter().cloned().chain(Some(1)));
603 fn bench_rev_1(b
: &mut Bencher
) {
604 let data
= black_box([0; LEN
]);
606 let mut v
= Vec
::<u32>::new();
607 v
.extend(data
.iter().rev());
613 fn bench_rev_2(b
: &mut Bencher
) {
614 let data
= black_box([0; LEN
]);
616 let mut v
= Vec
::<u32>::with_capacity(data
.len());
617 v
.extend(data
.iter().rev());
623 fn bench_map_regular(b
: &mut Bencher
) {
624 let data
= black_box([(0, 0); LEN
]);
626 let mut v
= Vec
::<u32>::new();
627 v
.extend(data
.iter().map(|t
| t
.1));
633 fn bench_map_fast(b
: &mut Bencher
) {
634 let data
= black_box([(0, 0); LEN
]);
636 let mut result
= Vec
::with_capacity(data
.len());
637 for i
in 0..data
.len() {
639 *result
.get_unchecked_mut(i
) = data
[i
].0;
647 fn random_sorted_fill(mut seed
: u32, buf
: &mut [u32]) {
648 let mask
= if buf
.len() < 8192 {
650 } else if buf
.len() < 200_000 {
656 for item
in buf
.iter_mut() {
667 fn bench_vec_dedup_old(b
: &mut Bencher
, sz
: usize) {
668 let mut template
= vec
![0u32; sz
];
669 b
.bytes
= std
::mem
::size_of_val(template
.as_slice()) as u64;
670 random_sorted_fill(0x43, &mut template
);
672 let mut vec
= template
.clone();
675 let (dedup
, _
) = vec
.partition_dedup();
680 black_box(vec
.first());
682 vec
.extend_from_slice(&template
);
686 fn bench_vec_dedup_new(b
: &mut Bencher
, sz
: usize) {
687 let mut template
= vec
![0u32; sz
];
688 b
.bytes
= std
::mem
::size_of_val(template
.as_slice()) as u64;
689 random_sorted_fill(0x43, &mut template
);
691 let mut vec
= template
.clone();
694 black_box(vec
.first());
696 vec
.extend_from_slice(&template
);
701 fn bench_dedup_old_100(b
: &mut Bencher
) {
702 bench_vec_dedup_old(b
, 100);
705 fn bench_dedup_new_100(b
: &mut Bencher
) {
706 bench_vec_dedup_new(b
, 100);
710 fn bench_dedup_old_1000(b
: &mut Bencher
) {
711 bench_vec_dedup_old(b
, 1000);
714 fn bench_dedup_new_1000(b
: &mut Bencher
) {
715 bench_vec_dedup_new(b
, 1000);
719 fn bench_dedup_old_10000(b
: &mut Bencher
) {
720 bench_vec_dedup_old(b
, 10000);
723 fn bench_dedup_new_10000(b
: &mut Bencher
) {
724 bench_vec_dedup_new(b
, 10000);
728 fn bench_dedup_old_100000(b
: &mut Bencher
) {
729 bench_vec_dedup_old(b
, 100000);
732 fn bench_dedup_new_100000(b
: &mut Bencher
) {
733 bench_vec_dedup_new(b
, 100000);