vendor/scroll/benches/bench.rs

   1 #![feature(test)]
   2 extern crate test;
   3
   4 use scroll::{Cread, Pread, LE};
   5 use test::black_box;
   6
   7 #[bench]
   8 fn bench_parallel_cread_with(b: &mut test::Bencher) {
   9     use rayon::prelude::*;
  10     let vec = vec![0u8; 1_000_000];
  11     let nums = vec![0usize; 500_000];
  12     b.iter(|| {
  13         let data = black_box(&vec[..]);
  14         nums.par_iter().for_each(| offset | {
  15             let _: u16 = black_box(data.cread_with(*offset, LE));
  16         });
  17     });
  18     b.bytes = vec.len() as u64;
  19 }
  20
  21 #[bench]
  22 fn bench_cread_vec(b: &mut test::Bencher) {
  23     let vec = vec![0u8; 1_000_000];
  24     b.iter(|| {
  25         let data = black_box(&vec[..]);
  26         for val in data.chunks(2) {
  27             let _: u16 = black_box(val.cread_with(0, LE));
  28         }
  29     });
  30     b.bytes = vec.len() as u64;
  31 }
  32
  33 #[bench]
  34 fn bench_cread(b: &mut test::Bencher) {
  35     const NITER: i32 = 100_000;
  36     b.iter(|| {
  37         for _ in 1..NITER {
  38             let data = black_box([1, 2]);
  39             let _: u16 = black_box(data.cread(0));
  40         }
  41     });
  42     b.bytes = 2 * NITER as u64;
  43 }
  44
  45 #[bench]
  46 fn bench_pread_ctx_vec(b: &mut test::Bencher) {
  47     let vec = vec![0u8; 1_000_000];
  48     b.iter(|| {
  49         let data = black_box(&vec[..]);
  50         for val in data.chunks(2) {
  51             let _: Result<u16, _> = black_box(val.pread(0));
  52         }
  53     });
  54     b.bytes = vec.len() as u64;
  55 }
  56
  57 #[bench]
  58 fn bench_pread_with_unwrap(b: &mut test::Bencher) {
  59     const NITER: i32 = 100_000;
  60     b.iter(|| {
  61         for _ in 1..NITER {
  62             let data: &[u8] = &black_box([1, 2]);
  63             let _: u16 = black_box(data.pread_with(0, LE).unwrap());
  64         }
  65     });
  66     b.bytes = 2 * NITER as u64;
  67 }
  68
  69 #[bench]
  70 fn bench_pread_vec(b: &mut test::Bencher) {
  71     let vec = vec![0u8; 1_000_000];
  72     b.iter(|| {
  73         let data = black_box(&vec[..]);
  74         for val in data.chunks(2) {
  75             let _: Result<u16, _> = black_box(val.pread_with(0, LE));
  76         }
  77     });
  78     b.bytes = vec.len() as u64;
  79 }
  80
  81 #[bench]
  82 fn bench_pread_unwrap(b: &mut test::Bencher) {
  83     const NITER: i32 = 100_000;
  84     b.iter(|| {
  85         for _ in 1..NITER {
  86             let data = black_box([1, 2]);
  87             let _: u16 = black_box(data.pread(0)).unwrap();
  88         }
  89     });
  90     b.bytes = 2 * NITER as u64;
  91 }
  92
  93 #[bench]
  94 fn bench_gread_vec(b: &mut test::Bencher) {
  95     let vec = vec![0u8; 1_000_000];
  96     b.iter(|| {
  97         let data = black_box(&vec[..]);
  98         for val in data.chunks(2) {
  99             let mut offset = 0;
 100             let _: Result<u16, _> = black_box(val.gread(&mut offset));
 101         }
 102     });
 103     b.bytes = vec.len() as u64;
 104 }
 105
 106 #[bench]
 107 fn bench_gread_unwrap(b: &mut test::Bencher) {
 108     const NITER: i32 = 100_000;
 109     b.iter(|| {
 110         for _ in 1..NITER {
 111             let data = black_box([1, 2]);
 112             let mut offset = 0;
 113             let _: u16 = black_box(data.gread_with(&mut offset, LE).unwrap());
 114         }
 115     });
 116     b.bytes = 2 * NITER as u64;
 117 }
 118
 119 #[bench]
 120 fn bench_parallel_pread_with(b: &mut test::Bencher) {
 121     use rayon::prelude::*;
 122     let vec = vec![0u8; 1_000_000];
 123     let nums = vec![0usize; 500_000];
 124     b.iter(|| {
 125         let data = black_box(&vec[..]);
 126         nums.par_iter().for_each(| offset | {
 127             let _: Result<u16, _> = black_box(data.pread_with(*offset, LE));
 128         });
 129     });
 130     b.bytes = vec.len() as u64;
 131 }
 132
 133 #[bench]
 134 fn bench_byteorder_vec(b: &mut test::Bencher) {
 135     use byteorder::ReadBytesExt;
 136     let vec = vec![0u8; 1_000_000];
 137     b.iter(|| {
 138         let data = black_box(&vec[..]);
 139         for mut val in data.chunks(2) {
 140             let _: Result<u16, _> = black_box(val.read_u16::<byteorder::LittleEndian>());
 141         }
 142     });
 143     b.bytes = vec.len() as u64;
 144 }
 145
 146 #[bench]
 147 fn bench_byteorder(b: &mut test::Bencher) {
 148     use byteorder::ByteOrder;
 149     const NITER: i32 = 100_000;
 150     b.iter(|| {
 151         for _ in 1..NITER {
 152             let data = black_box([1, 2]);
 153             let _: u16 = black_box(byteorder::LittleEndian::read_u16(&data));
 154         }
 155     });
 156     b.bytes = 2 * NITER as u64;
 157 }