vendor/memchr-1.0.2/benches/bench.rs

   1 #![feature(test)]
   2
   3 extern crate memchr;
   4 extern crate test;
   5
   6 use std::iter;
   7
   8 fn bench_data() -> Vec<u8> { iter::repeat(b'z').take(10000).collect() }
   9
  10 #[bench]
  11 fn iterator_memchr(b: &mut test::Bencher) {
  12     let haystack = bench_data();
  13     let needle = b'a';
  14     b.iter(|| {
  15         assert!(haystack.iter().position(|&b| b == needle).is_none());
  16     });
  17     b.bytes = haystack.len() as u64;
  18 }
  19
  20 #[bench]
  21 fn optimized_memchr(b: &mut test::Bencher) {
  22     let haystack = bench_data();
  23     let needle = b'a';
  24     b.iter(|| {
  25         assert!(memchr::memchr(needle, &haystack).is_none());
  26     });
  27     b.bytes = haystack.len() as u64;
  28 }
  29
  30 #[bench]
  31 fn iterator_memrchr(b: &mut test::Bencher) {
  32     let haystack = bench_data();
  33     let needle = b'a';
  34     b.iter(|| {
  35         assert!(haystack.iter().rposition(|&b| b == needle).is_none());
  36     });
  37     b.bytes = haystack.len() as u64;
  38 }
  39
  40 #[bench]
  41 fn optimized_memrchr(b: &mut test::Bencher) {
  42     let haystack = bench_data();
  43     let needle = b'a';
  44     b.iter(|| {
  45         assert!(memchr::memrchr(needle, &haystack).is_none());
  46     });
  47     b.bytes = haystack.len() as u64;
  48 }
  49
  50 #[bench]
  51 fn iterator_memchr2(b: &mut test::Bencher) {
  52     let haystack = bench_data();
  53     let (needle1, needle2) = (b'a', b'b');
  54     b.iter(|| {
  55         assert!(haystack.iter().position(|&b| {
  56             b == needle1 || b == needle2
  57         }).is_none());
  58     });
  59     b.bytes = haystack.len() as u64;
  60 }
  61
  62 #[bench]
  63 fn manual_memchr2(b: &mut test::Bencher) {
  64     fn find_singles(
  65         sparse: &[bool],
  66         text: &[u8],
  67     ) -> Option<(usize, usize)> {
  68         for (hi, &b) in text.iter().enumerate() {
  69             if sparse[b as usize] {
  70                 return Some((hi, hi+1));
  71             }
  72         }
  73         None
  74     }
  75
  76     let haystack = bench_data();
  77     let mut sparse = vec![false; 256];
  78     sparse[b'a' as usize] = true;
  79     sparse[b'b' as usize] = true;
  80     b.iter(|| {
  81         assert!(find_singles(&sparse, &haystack).is_none());
  82     });
  83     b.bytes = haystack.len() as u64;
  84 }
  85
  86 #[bench]
  87 fn optimized_memchr2(b: &mut test::Bencher) {
  88     let haystack = bench_data();
  89     let (needle1, needle2) = (b'a', b'b');
  90     b.iter(|| {
  91         assert!(memchr::memchr2(needle1, needle2, &haystack).is_none());
  92     });
  93     b.bytes = haystack.len() as u64;
  94 }
  95
  96 #[bench]
  97 fn iterator_memchr3(b: &mut test::Bencher) {
  98     let haystack = bench_data();
  99     let (needle1, needle2, needle3) = (b'a', b'b', b'c');
 100     b.iter(|| {
 101         assert!(haystack.iter().position(|&b| {
 102             b == needle1 || b == needle2 || b == needle3
 103         }).is_none());
 104     });
 105     b.bytes = haystack.len() as u64;
 106 }
 107
 108 #[bench]
 109 fn optimized_memchr3(b: &mut test::Bencher) {
 110     let haystack = bench_data();
 111     let (needle1, needle2, needle3) = (b'a', b'b', b'c');
 112     b.iter(|| {
 113         assert!(memchr::memchr3(
 114             needle1, needle2, needle3, &haystack).is_none());
 115     });
 116     b.bytes = haystack.len() as u64;
 117 }