1 #![feature(test)]
2 
3 extern crate test;
4 
5 macro_rules! bench_num {
6     ($name:ident, $read:ident, $bytes:expr, $data:expr) => {
7         mod $name {
8             use byteorder::{
9                 BigEndian, ByteOrder, LittleEndian, NativeEndian,
10             };
11             use test::black_box as bb;
12             use test::Bencher;
13 
14             const NITER: usize = 100_000;
15 
16             #[bench]
17             fn read_big_endian(b: &mut Bencher) {
18                 let buf = $data;
19                 b.iter(|| {
20                     for _ in 0..NITER {
21                         bb(BigEndian::$read(&buf, $bytes));
22                     }
23                 });
24             }
25 
26             #[bench]
27             fn read_little_endian(b: &mut Bencher) {
28                 let buf = $data;
29                 b.iter(|| {
30                     for _ in 0..NITER {
31                         bb(LittleEndian::$read(&buf, $bytes));
32                     }
33                 });
34             }
35 
36             #[bench]
37             fn read_native_endian(b: &mut Bencher) {
38                 let buf = $data;
39                 b.iter(|| {
40                     for _ in 0..NITER {
41                         bb(NativeEndian::$read(&buf, $bytes));
42                     }
43                 });
44             }
45         }
46     };
47     ($ty:ident, $max:ident,
48      $read:ident, $write:ident, $size:expr, $data:expr) => {
49         mod $ty {
50             use byteorder::{
51                 BigEndian, ByteOrder, LittleEndian, NativeEndian,
52             };
53             use std::$ty;
54             use test::black_box as bb;
55             use test::Bencher;
56 
57             const NITER: usize = 100_000;
58 
59             #[bench]
60             fn read_big_endian(b: &mut Bencher) {
61                 let buf = $data;
62                 b.iter(|| {
63                     for _ in 0..NITER {
64                         bb(BigEndian::$read(&buf));
65                     }
66                 });
67             }
68 
69             #[bench]
70             fn read_little_endian(b: &mut Bencher) {
71                 let buf = $data;
72                 b.iter(|| {
73                     for _ in 0..NITER {
74                         bb(LittleEndian::$read(&buf));
75                     }
76                 });
77             }
78 
79             #[bench]
80             fn read_native_endian(b: &mut Bencher) {
81                 let buf = $data;
82                 b.iter(|| {
83                     for _ in 0..NITER {
84                         bb(NativeEndian::$read(&buf));
85                     }
86                 });
87             }
88 
89             #[bench]
90             fn write_big_endian(b: &mut Bencher) {
91                 let mut buf = $data;
92                 let n = $ty::$max;
93                 b.iter(|| {
94                     for _ in 0..NITER {
95                         bb(BigEndian::$write(&mut buf, n));
96                     }
97                 });
98             }
99 
100             #[bench]
101             fn write_little_endian(b: &mut Bencher) {
102                 let mut buf = $data;
103                 let n = $ty::$max;
104                 b.iter(|| {
105                     for _ in 0..NITER {
106                         bb(LittleEndian::$write(&mut buf, n));
107                     }
108                 });
109             }
110 
111             #[bench]
112             fn write_native_endian(b: &mut Bencher) {
113                 let mut buf = $data;
114                 let n = $ty::$max;
115                 b.iter(|| {
116                     for _ in 0..NITER {
117                         bb(NativeEndian::$write(&mut buf, n));
118                     }
119                 });
120             }
121         }
122     };
123 }
124 
125 bench_num!(u16, MAX, read_u16, write_u16, 2, [1, 2]);
126 bench_num!(i16, MAX, read_i16, write_i16, 2, [1, 2]);
127 bench_num!(u32, MAX, read_u32, write_u32, 4, [1, 2, 3, 4]);
128 bench_num!(i32, MAX, read_i32, write_i32, 4, [1, 2, 3, 4]);
129 bench_num!(u64, MAX, read_u64, write_u64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
130 bench_num!(i64, MAX, read_i64, write_i64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
131 bench_num!(f32, MAX, read_f32, write_f32, 4, [1, 2, 3, 4]);
132 bench_num!(f64, MAX, read_f64, write_f64, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
133 
134 bench_num!(uint_1, read_uint, 1, [1]);
135 bench_num!(uint_2, read_uint, 2, [1, 2]);
136 bench_num!(uint_3, read_uint, 3, [1, 2, 3]);
137 bench_num!(uint_4, read_uint, 4, [1, 2, 3, 4]);
138 bench_num!(uint_5, read_uint, 5, [1, 2, 3, 4, 5]);
139 bench_num!(uint_6, read_uint, 6, [1, 2, 3, 4, 5, 6]);
140 bench_num!(uint_7, read_uint, 7, [1, 2, 3, 4, 5, 6, 7]);
141 bench_num!(uint_8, read_uint, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
142 
143 bench_num!(int_1, read_int, 1, [1]);
144 bench_num!(int_2, read_int, 2, [1, 2]);
145 bench_num!(int_3, read_int, 3, [1, 2, 3]);
146 bench_num!(int_4, read_int, 4, [1, 2, 3, 4]);
147 bench_num!(int_5, read_int, 5, [1, 2, 3, 4, 5]);
148 bench_num!(int_6, read_int, 6, [1, 2, 3, 4, 5, 6]);
149 bench_num!(int_7, read_int, 7, [1, 2, 3, 4, 5, 6, 7]);
150 bench_num!(int_8, read_int, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
151 
152 bench_num!(
153     u128,
154     MAX,
155     read_u128,
156     write_u128,
157     16,
158     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
159 );
160 bench_num!(
161     i128,
162     MAX,
163     read_i128,
164     write_i128,
165     16,
166     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
167 );
168 
169 bench_num!(uint128_1, read_uint128, 1, [1]);
170 bench_num!(uint128_2, read_uint128, 2, [1, 2]);
171 bench_num!(uint128_3, read_uint128, 3, [1, 2, 3]);
172 bench_num!(uint128_4, read_uint128, 4, [1, 2, 3, 4]);
173 bench_num!(uint128_5, read_uint128, 5, [1, 2, 3, 4, 5]);
174 bench_num!(uint128_6, read_uint128, 6, [1, 2, 3, 4, 5, 6]);
175 bench_num!(uint128_7, read_uint128, 7, [1, 2, 3, 4, 5, 6, 7]);
176 bench_num!(uint128_8, read_uint128, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
177 bench_num!(uint128_9, read_uint128, 9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
178 bench_num!(uint128_10, read_uint128, 10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
179 bench_num!(uint128_11, read_uint128, 11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
180 bench_num!(
181     uint128_12,
182     read_uint128,
183     12,
184     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
185 );
186 bench_num!(
187     uint128_13,
188     read_uint128,
189     13,
190     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
191 );
192 bench_num!(
193     uint128_14,
194     read_uint128,
195     14,
196     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
197 );
198 bench_num!(
199     uint128_15,
200     read_uint128,
201     15,
202     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
203 );
204 bench_num!(
205     uint128_16,
206     read_uint128,
207     16,
208     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
209 );
210 
211 bench_num!(int128_1, read_int128, 1, [1]);
212 bench_num!(int128_2, read_int128, 2, [1, 2]);
213 bench_num!(int128_3, read_int128, 3, [1, 2, 3]);
214 bench_num!(int128_4, read_int128, 4, [1, 2, 3, 4]);
215 bench_num!(int128_5, read_int128, 5, [1, 2, 3, 4, 5]);
216 bench_num!(int128_6, read_int128, 6, [1, 2, 3, 4, 5, 6]);
217 bench_num!(int128_7, read_int128, 7, [1, 2, 3, 4, 5, 6, 7]);
218 bench_num!(int128_8, read_int128, 8, [1, 2, 3, 4, 5, 6, 7, 8]);
219 bench_num!(int128_9, read_int128, 9, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
220 bench_num!(int128_10, read_int128, 10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
221 bench_num!(int128_11, read_int128, 11, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
222 bench_num!(
223     int128_12,
224     read_int128,
225     12,
226     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
227 );
228 bench_num!(
229     int128_13,
230     read_int128,
231     13,
232     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
233 );
234 bench_num!(
235     int128_14,
236     read_int128,
237     14,
238     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
239 );
240 bench_num!(
241     int128_15,
242     read_int128,
243     15,
244     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
245 );
246 bench_num!(
247     int128_16,
248     read_int128,
249     16,
250     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
251 );
252 
253 macro_rules! bench_slice {
254     ($name:ident, $numty:ty, $read:ident, $write:ident) => {
255         mod $name {
256             use std::mem::size_of;
257 
258             use byteorder::{BigEndian, ByteOrder, LittleEndian};
259             use rand::distributions;
260             use rand::{self, Rng};
261             use test::Bencher;
262 
263             #[bench]
264             fn read_big_endian(b: &mut Bencher) {
265                 let mut numbers: Vec<$numty> = rand::thread_rng()
266                     .sample_iter(&distributions::Standard)
267                     .take(100000)
268                     .collect();
269                 let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
270                 BigEndian::$write(&numbers, &mut bytes);
271 
272                 b.bytes = bytes.len() as u64;
273                 b.iter(|| {
274                     BigEndian::$read(&bytes, &mut numbers);
275                 });
276             }
277 
278             #[bench]
279             fn read_little_endian(b: &mut Bencher) {
280                 let mut numbers: Vec<$numty> = rand::thread_rng()
281                     .sample_iter(&distributions::Standard)
282                     .take(100000)
283                     .collect();
284                 let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
285                 LittleEndian::$write(&numbers, &mut bytes);
286 
287                 b.bytes = bytes.len() as u64;
288                 b.iter(|| {
289                     LittleEndian::$read(&bytes, &mut numbers);
290                 });
291             }
292 
293             #[bench]
294             fn write_big_endian(b: &mut Bencher) {
295                 let numbers: Vec<$numty> = rand::thread_rng()
296                     .sample_iter(&distributions::Standard)
297                     .take(100000)
298                     .collect();
299                 let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
300 
301                 b.bytes = bytes.len() as u64;
302                 b.iter(|| {
303                     BigEndian::$write(&numbers, &mut bytes);
304                 });
305             }
306 
307             #[bench]
308             fn write_little_endian(b: &mut Bencher) {
309                 let numbers: Vec<$numty> = rand::thread_rng()
310                     .sample_iter(&distributions::Standard)
311                     .take(100000)
312                     .collect();
313                 let mut bytes = vec![0; numbers.len() * size_of::<$numty>()];
314 
315                 b.bytes = bytes.len() as u64;
316                 b.iter(|| {
317                     LittleEndian::$write(&numbers, &mut bytes);
318                 });
319             }
320         }
321     };
322 }
323 
324 bench_slice!(slice_u64, u64, read_u64_into, write_u64_into);
325