src/libcore/benches/iter.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use core::iter::*;
  12 use test::{Bencher, black_box};
  13
  14 #[bench]
  15 fn bench_rposition(b: &mut Bencher) {
  16     let it: Vec<usize> = (0..300).collect();
  17     b.iter(|| {
  18         it.iter().rposition(|&x| x <= 150);
  19     });
  20 }
  21
  22 #[bench]
  23 fn bench_skip_while(b: &mut Bencher) {
  24     b.iter(|| {
  25         let it = 0..100;
  26         let mut sum = 0;
  27         it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true);
  28     });
  29 }
  30
  31 #[bench]
  32 fn bench_multiple_take(b: &mut Bencher) {
  33     let mut it = (0..42).cycle();
  34     b.iter(|| {
  35         let n = it.next().unwrap();
  36         for _ in 0..n {
  37             it.clone().take(it.next().unwrap()).all(|_| true);
  38         }
  39     });
  40 }
  41
  42 fn scatter(x: i32) -> i32 { (x * 31) % 127 }
  43
  44 #[bench]
  45 fn bench_max_by_key(b: &mut Bencher) {
  46     b.iter(|| {
  47         let it = 0..100;
  48         it.max_by_key(|&x| scatter(x))
  49     })
  50 }
  51
  52 // http://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/
  53 #[bench]
  54 fn bench_max_by_key2(b: &mut Bencher) {
  55     fn max_index_iter(array: &[i32]) -> usize {
  56         array.iter().enumerate().max_by_key(|&(_, item)| item).unwrap().0
  57     }
  58
  59     let mut data = vec![0; 1638];
  60     data[514] = 9999;
  61
  62     b.iter(|| max_index_iter(&data));
  63 }
  64
  65 #[bench]
  66 fn bench_max(b: &mut Bencher) {
  67     b.iter(|| {
  68         let it = 0..100;
  69         it.map(scatter).max()
  70     })
  71 }
  72
  73 pub fn copy_zip(xs: &[u8], ys: &mut [u8]) {
  74     for (a, b) in ys.iter_mut().zip(xs) {
  75         *a = *b;
  76     }
  77 }
  78
  79 pub fn add_zip(xs: &[f32], ys: &mut [f32]) {
  80     for (a, b) in ys.iter_mut().zip(xs) {
  81         *a += *b;
  82     }
  83 }
  84
  85 #[bench]
  86 fn bench_zip_copy(b: &mut Bencher) {
  87     let source = vec![0u8; 16 * 1024];
  88     let mut dst = black_box(vec![0u8; 16 * 1024]);
  89     b.iter(|| {
  90         copy_zip(&source, &mut dst)
  91     })
  92 }
  93
  94 #[bench]
  95 fn bench_zip_add(b: &mut Bencher) {
  96     let source = vec![1.; 16 * 1024];
  97     let mut dst = vec![0.; 16 * 1024];
  98     b.iter(|| {
  99         add_zip(&source, &mut dst)
 100     });
 101 }
 102
 103 /// `Iterator::for_each` implemented as a plain loop.
 104 fn for_each_loop<I, F>(iter: I, mut f: F) where
 105     I: Iterator, F: FnMut(I::Item)
 106 {
 107     for item in iter {
 108         f(item);
 109     }
 110 }
 111
 112 /// `Iterator::for_each` implemented with `fold` for internal iteration.
 113 /// (except when `by_ref()` effectively disables that optimization.)
 114 fn for_each_fold<I, F>(iter: I, mut f: F) where
 115     I: Iterator, F: FnMut(I::Item)
 116 {
 117     iter.fold((), move |(), item| f(item));
 118 }
 119
 120 #[bench]
 121 fn bench_for_each_chain_loop(b: &mut Bencher) {
 122     b.iter(|| {
 123         let mut acc = 0;
 124         let iter = (0i64..1000000).chain(0..1000000).map(black_box);
 125         for_each_loop(iter, |x| acc += x);
 126         acc
 127     });
 128 }
 129
 130 #[bench]
 131 fn bench_for_each_chain_fold(b: &mut Bencher) {
 132     b.iter(|| {
 133         let mut acc = 0;
 134         let iter = (0i64..1000000).chain(0..1000000).map(black_box);
 135         for_each_fold(iter, |x| acc += x);
 136         acc
 137     });
 138 }
 139
 140 #[bench]
 141 fn bench_for_each_chain_ref_fold(b: &mut Bencher) {
 142     b.iter(|| {
 143         let mut acc = 0;
 144         let mut iter = (0i64..1000000).chain(0..1000000).map(black_box);
 145         for_each_fold(iter.by_ref(), |x| acc += x);
 146         acc
 147     });
 148 }