library/alloc/benches/vec_deque.rs

   1 use std::collections::VecDeque;
   2 use test::{black_box, Bencher};
   3
   4 #[bench]
   5 fn bench_new(b: &mut Bencher) {
   6     b.iter(|| {
   7         let ring: VecDeque<i32> = VecDeque::new();
   8         black_box(ring);
   9     })
  10 }
  11
  12 #[bench]
  13 fn bench_grow_1025(b: &mut Bencher) {
  14     b.iter(|| {
  15         let mut deq = VecDeque::new();
  16         for i in 0..1025 {
  17             deq.push_front(i);
  18         }
  19         black_box(deq);
  20     })
  21 }
  22
  23 #[bench]
  24 fn bench_iter_1000(b: &mut Bencher) {
  25     let ring: VecDeque<_> = (0..1000).collect();
  26
  27     b.iter(|| {
  28         let mut sum = 0;
  29         for &i in &ring {
  30             sum += i;
  31         }
  32         black_box(sum);
  33     })
  34 }
  35
  36 #[bench]
  37 fn bench_mut_iter_1000(b: &mut Bencher) {
  38     let mut ring: VecDeque<_> = (0..1000).collect();
  39
  40     b.iter(|| {
  41         let mut sum = 0;
  42         for i in &mut ring {
  43             sum += *i;
  44         }
  45         black_box(sum);
  46     })
  47 }
  48
  49 #[bench]
  50 fn bench_try_fold(b: &mut Bencher) {
  51     let ring: VecDeque<_> = (0..1000).collect();
  52
  53     b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b))))
  54 }
  55
  56 #[bench]
  57 fn bench_from_array_1000(b: &mut Bencher) {
  58     const N: usize = 1000;
  59     let mut array: [usize; N] = [0; N];
  60
  61     for i in 0..N {
  62         array[i] = i;
  63     }
  64
  65     b.iter(|| {
  66         let deq: VecDeque<_> = array.into();
  67         black_box(deq);
  68     })
  69 }
  70
  71 #[bench]
  72 fn bench_extend_bytes(b: &mut Bencher) {
  73     let mut ring: VecDeque<u8> = VecDeque::with_capacity(1000);
  74     let input: &[u8] = &[128; 512];
  75
  76     b.iter(|| {
  77         ring.clear();
  78         ring.extend(black_box(input));
  79     });
  80 }
  81
  82 #[bench]
  83 fn bench_extend_vec(b: &mut Bencher) {
  84     let mut ring: VecDeque<u8> = VecDeque::with_capacity(1000);
  85     let input = vec![128; 512];
  86
  87     b.iter(|| {
  88         ring.clear();
  89
  90         let input = input.clone();
  91         ring.extend(black_box(input));
  92     });
  93 }
  94
  95 #[bench]
  96 fn bench_extend_trustedlen(b: &mut Bencher) {
  97     let mut ring: VecDeque<u16> = VecDeque::with_capacity(1000);
  98
  99     b.iter(|| {
 100         ring.clear();
 101         ring.extend(black_box(0..512));
 102     });
 103 }
 104
 105 #[bench]
 106 fn bench_extend_chained_trustedlen(b: &mut Bencher) {
 107     let mut ring: VecDeque<u16> = VecDeque::with_capacity(1000);
 108
 109     b.iter(|| {
 110         ring.clear();
 111         ring.extend(black_box((0..256).chain(768..1024)));
 112     });
 113 }
 114
 115 #[bench]
 116 fn bench_extend_chained_bytes(b: &mut Bencher) {
 117     let mut ring: VecDeque<u16> = VecDeque::with_capacity(1000);
 118     let input1: &[u16] = &[128; 256];
 119     let input2: &[u16] = &[255; 256];
 120
 121     b.iter(|| {
 122         ring.clear();
 123         ring.extend(black_box(input1.iter().chain(input2.iter())));
 124     });
 125 }