Debian Codegraph @

.cargo/vendor/lebe/benches/benches.rs

raw
1 #[macro_use]
2 extern crate bencher;
3
4 use bencher::Bencher;
5 use lebe::prelude::*;
6 use byteorder::{ReadBytesExt, LittleEndian, BigEndian, WriteBytesExt};
7 use std::io::{Read, Write, Cursor};
8
9 const COUNT_8: usize = 2048;
10 const COUNT_16: usize = COUNT_8 / 2;
11 const COUNT_32: usize = COUNT_8 / 4;
12 const COUNT_64: usize = COUNT_8 / 8;
13
14
15 fn bytes(count: usize) -> Cursor<Vec<u8>> {
16 let vec: Vec<u8> = (0..count).map(|i| (i % 256) as u8).collect();
17 Cursor::new(vec)
18 }
19
20 fn floats(count: usize) -> Vec<f32> {
21 (0..count).map(|i| i as f32).collect()
22 }
23
24 fn read_slice_f32_le_crate(bench: &mut Bencher) {
25 bench.iter(move ||{
26 let mut target = vec![ 0_f32; COUNT_32 ];
27 bencher::black_box(bytes(COUNT_8).read_from_little_endian_into(target.as_mut_slice())).unwrap();
28 bencher::black_box(target);
29 })
30 }
31
32 fn read_slice_f32_le_byteorder(bench: &mut Bencher) {
33 bench.iter(move ||{
34 let mut target = vec![ 0_f32; COUNT_32 ];
35 bencher::black_box(bytes(COUNT_8).read_f32_into::<LittleEndian>(target.as_mut_slice())).unwrap();
36 bencher::black_box(target);
37 })
38 }
39
40 fn read_slice_f32_be_crate(bench: &mut Bencher) {
41 bench.iter(move ||{
42 let mut target = vec![ 0_f32; COUNT_32 ];
43 bencher::black_box(bytes(COUNT_8).read_from_big_endian_into(target.as_mut_slice())).unwrap();
44 bencher::black_box(target);
45 })
46 }
47
48 fn read_slice_f32_be_byteorder(bench: &mut Bencher) {
49 bench.iter(move ||{
50 let mut target = vec![ 0_f32; COUNT_32 ];
51 bencher::black_box(bytes(COUNT_8).read_f32_into::<BigEndian>(target.as_mut_slice())).unwrap();
52 bencher::black_box(target);
53 })
54 }
55
56 // FIXME faster than baseline?!?!!
57 fn write_slice_f32_le_crate(bench: &mut Bencher) {
58 bench.iter(move ||{
59 let data = floats(COUNT_32);
60 let mut output = Vec::with_capacity(COUNT_8);
61
62 bencher::black_box(output.write_as_little_endian(data.as_slice())).unwrap();
63 assert_eq!(output.len(), COUNT_8);
64 bencher::black_box(output);
65 })
66 }
67
68 fn write_slice_f32_le_byteorder(bench: &mut Bencher) {
69 bench.iter(move ||{
70 let data = floats(COUNT_32);
71 let mut output = Vec::with_capacity(COUNT_8);
72
73 for number in data {
74 bencher::black_box(output.write_f32::<LittleEndian>(number)).unwrap();
75 }
76
77 assert_eq!(output.len(), COUNT_8);
78 bencher::black_box(output);
79 })
80 }
81
82
83 fn write_slice_f32_be_crate(bench: &mut Bencher) {
84 bench.iter(move ||{
85 let data = floats(COUNT_32);
86 let mut output = Vec::with_capacity(COUNT_8);
87
88 bencher::black_box(output.write_as_big_endian(data.as_slice())).unwrap();
89 assert_eq!(output.len(), COUNT_8);
90 bencher::black_box(output);
91 })
92 }
93
94 fn write_slice_f32_be_byteorder(bench: &mut Bencher) {
95 bench.iter(move ||{
96 let data = floats(COUNT_32);
97 let mut output = Vec::with_capacity(COUNT_8);
98
99 for number in data {
100 bencher::black_box(output.write_f32::<BigEndian>(number)).unwrap();
101 }
102
103 assert_eq!(output.len(), COUNT_8);
104 bencher::black_box(output);
105 })
106 }
107
108
109
110 fn read_slice_baseline(bench: &mut Bencher) {
111 bench.iter(move ||{
112 let mut target = vec![ 0_u8; COUNT_8 ];
113 bencher::black_box(bytes(COUNT_8).read_exact(target.as_mut_slice())).unwrap();
114 bencher::black_box(target);
115 })
116 }
117
118
119 fn write_slice_baseline(bench: &mut Bencher) {
120 bench.iter(move ||{
121 let data = bytes(COUNT_8).into_inner();
122 let mut output = Vec::with_capacity(COUNT_8);
123
124 bencher::black_box(output.write_all(data.as_slice())).unwrap();
125 bencher::black_box(output);
126 })
127 }
128
129 benchmark_group!(
130 benches,
131 read_slice_f32_be_byteorder, read_slice_f32_be_crate, read_slice_f32_le_byteorder,
132 read_slice_f32_le_crate, write_slice_f32_le_byteorder, write_slice_f32_le_crate,
133 write_slice_f32_be_byteorder, write_slice_f32_be_crate,
134 read_slice_baseline, write_slice_baseline
135 );
136
137 benchmark_main!(benches);