vendor/itertools-0.8.0/benches/tuples.rs

   1 #![feature(test)]
   2
   3 extern crate test;
   4 extern crate itertools;
   5
   6 use test::Bencher;
   7 use itertools::Itertools;
   8
   9 fn s1(a: u32) -> u32 {
  10     a
  11 }
  12
  13 fn s2(a: u32, b: u32) -> u32 {
  14     a + b
  15 }
  16
  17 fn s3(a: u32, b: u32, c: u32) -> u32 {
  18     a + b + c
  19 }
  20
  21 fn s4(a: u32, b: u32, c: u32, d: u32) -> u32 {
  22     a + b + c + d
  23 }
  24
  25 fn sum_s1(s: &[u32]) -> u32 {
  26     s1(s[0])
  27 }
  28
  29 fn sum_s2(s: &[u32]) -> u32 {
  30     s2(s[0], s[1])
  31 }
  32
  33 fn sum_s3(s: &[u32]) -> u32 {
  34     s3(s[0], s[1], s[2])
  35 }
  36
  37 fn sum_s4(s: &[u32]) -> u32 {
  38     s4(s[0], s[1], s[2], s[3])
  39 }
  40
  41 fn sum_t1(s: &(&u32, )) -> u32 {
  42     s1(*s.0)
  43 }
  44
  45 fn sum_t2(s: &(&u32, &u32)) -> u32 {
  46     s2(*s.0, *s.1)
  47 }
  48
  49 fn sum_t3(s: &(&u32, &u32, &u32)) -> u32 {
  50     s3(*s.0, *s.1, *s.2)
  51 }
  52
  53 fn sum_t4(s: &(&u32, &u32, &u32, &u32)) -> u32 {
  54     s4(*s.0, *s.1, *s.2, *s.3)
  55 }
  56
  57 macro_rules! def_benchs {
  58     ($N:expr;
  59      $TUPLE_FUN:ident,
  60      $TUPLES:ident,
  61      $TUPLE_WINDOWS:ident;
  62      $SLICE_FUN:ident,
  63      $CHUNKS:ident,
  64      $WINDOWS:ident;
  65      $FOR_CHUNKS:ident,
  66      $FOR_WINDOWS:ident
  67      ) => (
  68         #[bench]
  69         fn $FOR_CHUNKS(b: &mut Bencher) {
  70             let v: Vec<u32> = (0.. $N * 1_000).collect();
  71             let mut s = 0;
  72             b.iter(|| {
  73                 let mut j = 0;
  74                 for _ in 0..1_000 {
  75                     s += $SLICE_FUN(&v[j..(j + $N)]);
  76                     j += $N;
  77                 }
  78                 s
  79             });
  80         }
  81
  82         #[bench]
  83         fn $FOR_WINDOWS(b: &mut Bencher) {
  84             let v: Vec<u32> = (0..1_000).collect();
  85             let mut s = 0;
  86             b.iter(|| {
  87                 for i in 0..(1_000 - $N) {
  88                     s += $SLICE_FUN(&v[i..(i + $N)]);
  89                 }
  90                 s
  91             });
  92         }
  93
  94         #[bench]
  95         fn $TUPLES(b: &mut Bencher) {
  96             let v: Vec<u32> = (0.. $N * 1_000).collect();
  97             let mut s = 0;
  98             b.iter(|| {
  99                 for x in v.iter().tuples() {
 100                     s += $TUPLE_FUN(&x);
 101                 }
 102                 s
 103             });
 104         }
 105
 106         #[bench]
 107         fn $CHUNKS(b: &mut Bencher) {
 108             let v: Vec<u32> = (0.. $N * 1_000).collect();
 109             let mut s = 0;
 110             b.iter(|| {
 111                 for x in v.chunks($N) {
 112                     s += $SLICE_FUN(x);
 113                 }
 114                 s
 115             });
 116         }
 117
 118         #[bench]
 119         fn $TUPLE_WINDOWS(b: &mut Bencher) {
 120             let v: Vec<u32> = (0..1_000).collect();
 121             let mut s = 0;
 122             b.iter(|| {
 123                 for x in v.iter().tuple_windows() {
 124                     s += $TUPLE_FUN(&x);
 125                 }
 126                 s
 127             });
 128         }
 129
 130         #[bench]
 131         fn $WINDOWS(b: &mut Bencher) {
 132             let v: Vec<u32> = (0..1_000).collect();
 133             let mut s = 0;
 134             b.iter(|| {
 135                 for x in v.windows($N) {
 136                     s += $SLICE_FUN(x);
 137                 }
 138                 s
 139             });
 140         }
 141     )
 142 }
 143
 144 def_benchs!{
 145     1;
 146     sum_t1,
 147     tuple_chunks_1,
 148     tuple_windows_1;
 149     sum_s1,
 150     slice_chunks_1,
 151     slice_windows_1;
 152     for_chunks_1,
 153     for_windows_1
 154 }
 155
 156 def_benchs!{
 157     2;
 158     sum_t2,
 159     tuple_chunks_2,
 160     tuple_windows_2;
 161     sum_s2,
 162     slice_chunks_2,
 163     slice_windows_2;
 164     for_chunks_2,
 165     for_windows_2
 166 }
 167
 168 def_benchs!{
 169     3;
 170     sum_t3,
 171     tuple_chunks_3,
 172     tuple_windows_3;
 173     sum_s3,
 174     slice_chunks_3,
 175     slice_windows_3;
 176     for_chunks_3,
 177     for_windows_3
 178 }
 179
 180 def_benchs!{
 181     4;
 182     sum_t4,
 183     tuple_chunks_4,
 184     tuple_windows_4;
 185     sum_s4,
 186     slice_chunks_4,
 187     slice_windows_4;
 188     for_chunks_4,
 189     for_windows_4
 190 }