2 use std::iter::{repeat, FromIterator};
3 use test::{black_box, Bencher};
6 fn bench_new(b: &mut Bencher) {
8 let v: Vec<u32> = Vec::new();
9 assert_eq!(v.len(), 0);
10 assert_eq!(v.capacity(), 0);
15 fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
16 b.bytes = src_len as u64;
19 let v: Vec<u32> = Vec::with_capacity(src_len);
20 assert_eq!(v.len(), 0);
21 assert_eq!(v.capacity(), src_len);
27 fn bench_with_capacity_0000(b: &mut Bencher) {
28 do_bench_with_capacity(b, 0)
32 fn bench_with_capacity_0010(b: &mut Bencher) {
33 do_bench_with_capacity(b, 10)
37 fn bench_with_capacity_0100(b: &mut Bencher) {
38 do_bench_with_capacity(b, 100)
42 fn bench_with_capacity_1000(b: &mut Bencher) {
43 do_bench_with_capacity(b, 1000)
46 fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
47 b.bytes = src_len as u64;
50 let dst = (0..src_len).collect::<Vec<_>>();
51 assert_eq!(dst.len(), src_len);
52 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
58 fn bench_from_fn_0000(b: &mut Bencher) {
59 do_bench_from_fn(b, 0)
63 fn bench_from_fn_0010(b: &mut Bencher) {
64 do_bench_from_fn(b, 10)
68 fn bench_from_fn_0100(b: &mut Bencher) {
69 do_bench_from_fn(b, 100)
73 fn bench_from_fn_1000(b: &mut Bencher) {
74 do_bench_from_fn(b, 1000)
77 fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
78 b.bytes = src_len as u64;
81 let dst: Vec<usize> = repeat(5).take(src_len).collect();
82 assert_eq!(dst.len(), src_len);
83 assert!(dst.iter().all(|x| *x == 5));
89 fn bench_from_elem_0000(b: &mut Bencher) {
90 do_bench_from_elem(b, 0)
94 fn bench_from_elem_0010(b: &mut Bencher) {
95 do_bench_from_elem(b, 10)
99 fn bench_from_elem_0100(b: &mut Bencher) {
100 do_bench_from_elem(b, 100)
104 fn bench_from_elem_1000(b: &mut Bencher) {
105 do_bench_from_elem(b, 1000)
108 fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
109 let src: Vec<_> = FromIterator::from_iter(0..src_len);
111 b.bytes = src_len as u64;
114 let dst = src.clone()[..].to_vec();
115 assert_eq!(dst.len(), src_len);
116 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
122 fn bench_from_slice_0000(b: &mut Bencher) {
123 do_bench_from_slice(b, 0)
127 fn bench_from_slice_0010(b: &mut Bencher) {
128 do_bench_from_slice(b, 10)
132 fn bench_from_slice_0100(b: &mut Bencher) {
133 do_bench_from_slice(b, 100)
137 fn bench_from_slice_1000(b: &mut Bencher) {
138 do_bench_from_slice(b, 1000)
141 fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
142 let src: Vec<_> = FromIterator::from_iter(0..src_len);
144 b.bytes = src_len as u64;
147 let dst: Vec<_> = FromIterator::from_iter(src.clone());
148 assert_eq!(dst.len(), src_len);
149 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
155 fn bench_from_iter_0000(b: &mut Bencher) {
156 do_bench_from_iter(b, 0)
160 fn bench_from_iter_0010(b: &mut Bencher) {
161 do_bench_from_iter(b, 10)
165 fn bench_from_iter_0100(b: &mut Bencher) {
166 do_bench_from_iter(b, 100)
170 fn bench_from_iter_1000(b: &mut Bencher) {
171 do_bench_from_iter(b, 1000)
174 fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
175 let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
176 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
178 b.bytes = src_len as u64;
181 let mut dst = dst.clone();
182 dst.extend(src.clone());
183 assert_eq!(dst.len(), dst_len + src_len);
184 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
190 fn bench_extend_0000_0000(b: &mut Bencher) {
191 do_bench_extend(b, 0, 0)
195 fn bench_extend_0000_0010(b: &mut Bencher) {
196 do_bench_extend(b, 0, 10)
200 fn bench_extend_0000_0100(b: &mut Bencher) {
201 do_bench_extend(b, 0, 100)
205 fn bench_extend_0000_1000(b: &mut Bencher) {
206 do_bench_extend(b, 0, 1000)
210 fn bench_extend_0010_0010(b: &mut Bencher) {
211 do_bench_extend(b, 10, 10)
215 fn bench_extend_0100_0100(b: &mut Bencher) {
216 do_bench_extend(b, 100, 100)
220 fn bench_extend_1000_1000(b: &mut Bencher) {
221 do_bench_extend(b, 1000, 1000)
224 fn do_bench_extend_from_slice(b: &mut Bencher, dst_len: usize, src_len: usize) {
225 let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
226 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
228 b.bytes = src_len as u64;
231 let mut dst = dst.clone();
232 dst.extend_from_slice(&src);
233 assert_eq!(dst.len(), dst_len + src_len);
234 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
240 fn bench_extend_recycle(b: &mut Bencher) {
241 let mut data = vec![0; 1000];
244 let tmp = std::mem::take(&mut data);
245 let mut to_extend = black_box(Vec::new());
246 to_extend.extend(tmp.into_iter());
247 data = black_box(to_extend);
254 fn bench_extend_from_slice_0000_0000(b: &mut Bencher) {
255 do_bench_extend_from_slice(b, 0, 0)
259 fn bench_extend_from_slice_0000_0010(b: &mut Bencher) {
260 do_bench_extend_from_slice(b, 0, 10)
264 fn bench_extend_from_slice_0000_0100(b: &mut Bencher) {
265 do_bench_extend_from_slice(b, 0, 100)
269 fn bench_extend_from_slice_0000_1000(b: &mut Bencher) {
270 do_bench_extend_from_slice(b, 0, 1000)
274 fn bench_extend_from_slice_0010_0010(b: &mut Bencher) {
275 do_bench_extend_from_slice(b, 10, 10)
279 fn bench_extend_from_slice_0100_0100(b: &mut Bencher) {
280 do_bench_extend_from_slice(b, 100, 100)
284 fn bench_extend_from_slice_1000_1000(b: &mut Bencher) {
285 do_bench_extend_from_slice(b, 1000, 1000)
288 fn do_bench_clone(b: &mut Bencher, src_len: usize) {
289 let src: Vec<usize> = FromIterator::from_iter(0..src_len);
291 b.bytes = src_len as u64;
294 let dst = src.clone();
295 assert_eq!(dst.len(), src_len);
296 assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
302 fn bench_clone_0000(b: &mut Bencher) {
307 fn bench_clone_0010(b: &mut Bencher) {
308 do_bench_clone(b, 10)
312 fn bench_clone_0100(b: &mut Bencher) {
313 do_bench_clone(b, 100)
317 fn bench_clone_1000(b: &mut Bencher) {
318 do_bench_clone(b, 1000)
321 fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
322 let dst: Vec<_> = FromIterator::from_iter(0..src_len);
323 let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
325 b.bytes = (times * src_len) as u64;
328 let mut dst = dst.clone();
331 dst.clone_from(&src);
332 assert_eq!(dst.len(), src_len);
333 assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
340 fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
341 do_bench_clone_from(b, 1, 0, 0)
345 fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
346 do_bench_clone_from(b, 1, 0, 10)
350 fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
351 do_bench_clone_from(b, 1, 0, 100)
355 fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
356 do_bench_clone_from(b, 1, 0, 1000)
360 fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
361 do_bench_clone_from(b, 1, 10, 10)
365 fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
366 do_bench_clone_from(b, 1, 100, 100)
370 fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
371 do_bench_clone_from(b, 1, 1000, 1000)
375 fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
376 do_bench_clone_from(b, 1, 10, 100)
380 fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
381 do_bench_clone_from(b, 1, 100, 1000)
385 fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
386 do_bench_clone_from(b, 1, 10, 0)
390 fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
391 do_bench_clone_from(b, 1, 100, 10)
395 fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
396 do_bench_clone_from(b, 1, 1000, 100)
400 fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
401 do_bench_clone_from(b, 10, 0, 0)
405 fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
406 do_bench_clone_from(b, 10, 0, 10)
410 fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
411 do_bench_clone_from(b, 10, 0, 100)
415 fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
416 do_bench_clone_from(b, 10, 0, 1000)
420 fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
421 do_bench_clone_from(b, 10, 10, 10)
425 fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
426 do_bench_clone_from(b, 10, 100, 100)
430 fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
431 do_bench_clone_from(b, 10, 1000, 1000)
435 fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
436 do_bench_clone_from(b, 10, 10, 100)
440 fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
441 do_bench_clone_from(b, 10, 100, 1000)
445 fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
446 do_bench_clone_from(b, 10, 10, 0)
450 fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
451 do_bench_clone_from(b, 10, 100, 10)
455 fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
456 do_bench_clone_from(b, 10, 1000, 100)
459 macro_rules! bench_in_place {
460 ($($fname:ident, $type:ty, $count:expr, $init:expr);*) => {
463 fn $fname(b: &mut Bencher) {
465 let src: Vec<$type> = black_box(vec![$init; $count]);
466 let mut sink = src.into_iter()
468 .map(|(idx, e)| idx as $type ^ e)
469 .collect::<Vec<$type>>();
470 black_box(sink.as_mut_ptr())
478 bench_in_place_xxu8_0010_i0, u8, 10, 0;
479 bench_in_place_xxu8_0100_i0, u8, 100, 0;
480 bench_in_place_xxu8_1000_i0, u8, 1000, 0;
481 bench_in_place_xxu8_0010_i1, u8, 10, 1;
482 bench_in_place_xxu8_0100_i1, u8, 100, 1;
483 bench_in_place_xxu8_1000_i1, u8, 1000, 1;
484 bench_in_place_xu32_0010_i0, u32, 10, 0;
485 bench_in_place_xu32_0100_i0, u32, 100, 0;
486 bench_in_place_xu32_1000_i0, u32, 1000, 0;
487 bench_in_place_xu32_0010_i1, u32, 10, 1;
488 bench_in_place_xu32_0100_i1, u32, 100, 1;
489 bench_in_place_xu32_1000_i1, u32, 1000, 1;
490 bench_in_place_u128_0010_i0, u128, 10, 0;
491 bench_in_place_u128_0100_i0, u128, 100, 0;
492 bench_in_place_u128_1000_i0, u128, 1000, 0;
493 bench_in_place_u128_0010_i1, u128, 10, 1;
494 bench_in_place_u128_0100_i1, u128, 100, 1;
495 bench_in_place_u128_1000_i1, u128, 1000, 1
499 fn bench_in_place_recycle(b: &mut Bencher) {
500 let mut data = vec![0; 1000];
503 let tmp = std::mem::take(&mut data);
507 .map(|(idx, e)| idx.wrapping_add(e))
510 .collect::<Vec<usize>>(),
516 fn bench_in_place_zip_recycle(b: &mut Bencher) {
517 let mut data = vec![0u8; 1000];
518 let mut rng = rand::thread_rng();
519 let mut subst = vec![0u8; 1000];
520 rng.fill_bytes(&mut subst[..]);
523 let tmp = std::mem::take(&mut data);
526 .zip(subst.iter().copied())
528 .map(|(i, (d, s))| d.wrapping_add(i as u8) ^ s)
529 .collect::<Vec<_>>();
530 assert_eq!(mangled.len(), 1000);
531 data = black_box(mangled);
536 fn bench_in_place_zip_iter_mut(b: &mut Bencher) {
537 let mut data = vec![0u8; 256];
538 let mut rng = rand::thread_rng();
539 let mut subst = vec![0u8; 1000];
540 rng.fill_bytes(&mut subst[..]);
543 data.iter_mut().enumerate().for_each(|(i, d)| {
544 *d = d.wrapping_add(i as u8) ^ subst[i];
552 struct Droppable(usize);
554 impl Drop for Droppable {
561 fn bench_in_place_collect_droppable(b: &mut Bencher) {
562 let v: Vec<Droppable> = std::iter::repeat_with(|| Droppable(0)).take(1000).collect();
568 .map(|(i, e)| Droppable(i ^ e.0))
574 fn bench_chain_collect(b: &mut Bencher) {
575 let data = black_box([0; LEN]);
576 b.iter(|| data.iter().cloned().chain([1].iter().cloned()).collect::<Vec<_>>());
580 fn bench_chain_chain_collect(b: &mut Bencher) {
581 let data = black_box([0; LEN]);
585 .chain([1].iter().cloned())
586 .chain([2].iter().cloned())
592 fn bench_nest_chain_chain_collect(b: &mut Bencher) {
593 let data = black_box([0; LEN]);
595 data.iter().cloned().chain([1].iter().chain([2].iter()).cloned()).collect::<Vec<_>>()
599 pub fn example_plain_slow(l: &[u32]) -> Vec<u32> {
600 let mut result = Vec::with_capacity(l.len());
601 result.extend(l.iter().rev());
605 pub fn map_fast(l: &[(u32, u32)]) -> Vec<u32> {
606 let mut result = Vec::with_capacity(l.len());
607 for i in 0..l.len() {
609 *result.get_unchecked_mut(i) = l[i].0;
616 const LEN: usize = 16384;
619 fn bench_range_map_collect(b: &mut Bencher) {
620 b.iter(|| (0..LEN).map(|_| u32::default()).collect::<Vec<_>>());
624 fn bench_chain_extend_ref(b: &mut Bencher) {
625 let data = black_box([0; LEN]);
627 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
628 v.extend(data.iter().chain([1].iter()));
634 fn bench_chain_extend_value(b: &mut Bencher) {
635 let data = black_box([0; LEN]);
637 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
638 v.extend(data.iter().cloned().chain(Some(1)));
644 fn bench_rev_1(b: &mut Bencher) {
645 let data = black_box([0; LEN]);
647 let mut v = Vec::<u32>::new();
648 v.extend(data.iter().rev());
654 fn bench_rev_2(b: &mut Bencher) {
655 let data = black_box([0; LEN]);
656 b.iter(|| example_plain_slow(&data));
660 fn bench_map_regular(b: &mut Bencher) {
661 let data = black_box([(0, 0); LEN]);
663 let mut v = Vec::<u32>::new();
664 v.extend(data.iter().map(|t| t.1));
670 fn bench_map_fast(b: &mut Bencher) {
671 let data = black_box([(0, 0); LEN]);
672 b.iter(|| map_fast(&data));