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))
472 .collect::<Vec<usize>>(),
478 fn bench_in_place_zip_recycle(b: &mut Bencher) {
479 let mut data = vec![0u8; 1000];
480 let mut rng = rand::thread_rng();
481 let mut subst = vec![0u8; 1000];
482 rng.fill_bytes(&mut subst[..]);
485 let tmp = std::mem::take(&mut data);
488 .zip(subst.iter().copied())
490 .map(|(i, (d, s))| d.wrapping_add(i as u8) ^ s)
491 .collect::<Vec<_>>();
492 data = black_box(mangled);
497 fn bench_in_place_zip_iter_mut(b: &mut Bencher) {
498 let mut data = vec![0u8; 256];
499 let mut rng = rand::thread_rng();
500 let mut subst = vec![0u8; 1000];
501 rng.fill_bytes(&mut subst[..]);
504 data.iter_mut().enumerate().for_each(|(i, d)| {
505 *d = d.wrapping_add(i as u8) ^ subst[i];
512 pub fn vec_cast<T, U>(input: Vec<T>) -> Vec<U> {
513 input.into_iter().map(|e| unsafe { std::mem::transmute_copy(&e) }).collect()
517 fn bench_transmute(b: &mut Bencher) {
518 let mut vec = vec![10u32; 100];
519 b.bytes = 800; // 2 casts x 4 bytes x 100
521 let v = std::mem::take(&mut vec);
522 let v = black_box(vec_cast::<u32, i32>(v));
523 let v = black_box(vec_cast::<i32, u32>(v));
529 struct Droppable(usize);
531 impl Drop for Droppable {
538 fn bench_in_place_collect_droppable(b: &mut Bencher) {
539 let v: Vec<Droppable> = std::iter::repeat_with(|| Droppable(0)).take(1000).collect();
545 .map(|(i, e)| Droppable(i ^ e.0))
550 const LEN: usize = 16384;
553 fn bench_chain_collect(b: &mut Bencher) {
554 let data = black_box([0; LEN]);
555 b.iter(|| data.iter().cloned().chain([1].iter().cloned()).collect::<Vec<_>>());
559 fn bench_chain_chain_collect(b: &mut Bencher) {
560 let data = black_box([0; LEN]);
564 .chain([1].iter().cloned())
565 .chain([2].iter().cloned())
571 fn bench_nest_chain_chain_collect(b: &mut Bencher) {
572 let data = black_box([0; LEN]);
574 data.iter().cloned().chain([1].iter().chain([2].iter()).cloned()).collect::<Vec<_>>()
579 fn bench_range_map_collect(b: &mut Bencher) {
580 b.iter(|| (0..LEN).map(|_| u32::default()).collect::<Vec<_>>());
584 fn bench_chain_extend_ref(b: &mut Bencher) {
585 let data = black_box([0; LEN]);
587 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
588 v.extend(data.iter().chain([1].iter()));
594 fn bench_chain_extend_value(b: &mut Bencher) {
595 let data = black_box([0; LEN]);
597 let mut v = Vec::<u32>::with_capacity(data.len() + 1);
598 v.extend(data.iter().cloned().chain(Some(1)));
604 fn bench_rev_1(b: &mut Bencher) {
605 let data = black_box([0; LEN]);
607 let mut v = Vec::<u32>::new();
608 v.extend(data.iter().rev());
614 fn bench_rev_2(b: &mut Bencher) {
615 let data = black_box([0; LEN]);
617 let mut v = Vec::<u32>::with_capacity(data.len());
618 v.extend(data.iter().rev());
624 fn bench_map_regular(b: &mut Bencher) {
625 let data = black_box([(0, 0); LEN]);
627 let mut v = Vec::<u32>::new();
628 v.extend(data.iter().map(|t| t.1));
634 fn bench_map_fast(b: &mut Bencher) {
635 let data = black_box([(0, 0); LEN]);
637 let mut result = Vec::with_capacity(data.len());
638 for i in 0..data.len() {
640 *result.get_unchecked_mut(i) = data[i].0;
648 fn random_sorted_fill(mut seed: u32, buf: &mut [u32]) {
649 let mask = if buf.len() < 8192 {
651 } else if buf.len() < 200_000 {
657 for item in buf.iter_mut() {
668 fn bench_vec_dedup_old(b: &mut Bencher, sz: usize) {
669 let mut template = vec![0u32; sz];
670 b.bytes = std::mem::size_of_val(template.as_slice()) as u64;
671 random_sorted_fill(0x43, &mut template);
673 let mut vec = template.clone();
676 let (dedup, _) = vec.partition_dedup();
681 black_box(vec.first());
683 vec.extend_from_slice(&template);
687 fn bench_vec_dedup_new(b: &mut Bencher, sz: usize) {
688 let mut template = vec![0u32; sz];
689 b.bytes = std::mem::size_of_val(template.as_slice()) as u64;
690 random_sorted_fill(0x43, &mut template);
692 let mut vec = template.clone();
695 black_box(vec.first());
697 vec.extend_from_slice(&template);
702 fn bench_dedup_old_100(b: &mut Bencher) {
703 bench_vec_dedup_old(b, 100);
706 fn bench_dedup_new_100(b: &mut Bencher) {
707 bench_vec_dedup_new(b, 100);
711 fn bench_dedup_old_1000(b: &mut Bencher) {
712 bench_vec_dedup_old(b, 1000);
715 fn bench_dedup_new_1000(b: &mut Bencher) {
716 bench_vec_dedup_new(b, 1000);
720 fn bench_dedup_old_10000(b: &mut Bencher) {
721 bench_vec_dedup_old(b, 10000);
724 fn bench_dedup_new_10000(b: &mut Bencher) {
725 bench_vec_dedup_new(b, 10000);
729 fn bench_dedup_old_100000(b: &mut Bencher) {
730 bench_vec_dedup_old(b, 100000);
733 fn bench_dedup_new_100000(b: &mut Bencher) {
734 bench_vec_dedup_new(b, 100000);