Debian Codegraph @

.cargo/vendor/rustdct/benches/bench_dct_naive.rs

raw
1 #![feature(test)]
2 extern crate rustdct;
3 extern crate test;
4
5 use rustdct::mdct::{window_fn, Mdct, MdctNaive};
6 use rustdct::{
7 algorithm::{Dct1Naive, Dst6And7Naive, Type2And3Naive, Type4Naive},
8 RequiredScratch,
9 };
10 use rustdct::{Dct1, Dct2, Dct3, Dct4, Dst6, Dst7};
11
12 use test::Bencher;
13
14 /// Times just the DCT1 execution (not allocation and pre-calculation)
15 /// for a given length
16 fn bench_dct1_naive(b: &mut Bencher, len: usize) {
17 let dct = Dct1Naive::new(len);
18
19 let mut buffer = vec![0_f32; len];
20 let mut scratch = vec![0_f32; dct.get_scratch_len()];
21 b.iter(|| {
22 dct.process_dct1_with_scratch(&mut buffer, &mut scratch);
23 });
24 }
25 #[bench]
26 fn dct1_naive_002(b: &mut Bencher) {
27 bench_dct1_naive(b, 2);
28 }
29 #[bench]
30 fn dct1_naive_004(b: &mut Bencher) {
31 bench_dct1_naive(b, 4);
32 }
33 #[bench]
34 fn dct1_naive_006(b: &mut Bencher) {
35 bench_dct1_naive(b, 6);
36 }
37 #[bench]
38 fn dct1_naive_008(b: &mut Bencher) {
39 bench_dct1_naive(b, 8);
40 }
41 #[bench]
42 fn dct1_naive_010(b: &mut Bencher) {
43 bench_dct1_naive(b, 10);
44 }
45
46 /// Times just the DCT2 execution (not allocation and pre-calculation)
47 /// for a given length
48 fn bench_dct2_naive(b: &mut Bencher, len: usize) {
49 let dct = Type2And3Naive::new(len);
50
51 let mut buffer = vec![0_f32; len];
52 let mut scratch = vec![0_f32; dct.get_scratch_len()];
53 b.iter(|| {
54 dct.process_dct2_with_scratch(&mut buffer, &mut scratch);
55 });
56 }
57
58 #[bench]
59 fn dct2_naive_06(b: &mut Bencher) {
60 bench_dct2_naive(b, 6);
61 }
62 #[bench]
63 fn dct2_naive_05(b: &mut Bencher) {
64 bench_dct2_naive(b, 5);
65 }
66 #[bench]
67 fn dct2_naive_04(b: &mut Bencher) {
68 bench_dct2_naive(b, 4);
69 }
70 #[bench]
71 fn dct2_naive_03(b: &mut Bencher) {
72 bench_dct2_naive(b, 3);
73 }
74 #[bench]
75 fn dct2_naive_02(b: &mut Bencher) {
76 bench_dct2_naive(b, 2);
77 }
78 #[bench]
79 fn dct2_naive_01(b: &mut Bencher) {
80 bench_dct2_naive(b, 1);
81 }
82
83 /// Times just the DCT3 execution (not allocation and pre-calculation)
84 /// for a given length
85 fn bench_dct3_naive(b: &mut Bencher, len: usize) {
86 let dct = Type2And3Naive::new(len);
87
88 let mut buffer = vec![0_f32; len];
89 let mut scratch = vec![0_f32; dct.get_scratch_len()];
90 b.iter(|| {
91 dct.process_dct3_with_scratch(&mut buffer, &mut scratch);
92 });
93 }
94
95 #[bench]
96 fn dct3_naive_0002(b: &mut Bencher) {
97 bench_dct3_naive(b, 2);
98 }
99 #[bench]
100 fn dct3_naive_0003(b: &mut Bencher) {
101 bench_dct3_naive(b, 3);
102 }
103 #[bench]
104 fn dct3_naive_0004(b: &mut Bencher) {
105 bench_dct3_naive(b, 4);
106 }
107 #[bench]
108 fn dct3_naive_0005(b: &mut Bencher) {
109 bench_dct3_naive(b, 5);
110 }
111 #[bench]
112 fn dct3_naive_0006(b: &mut Bencher) {
113 bench_dct3_naive(b, 6);
114 }
115
116 /// Times just the DCT4 execution (not allocation and pre-calculation)
117 /// for a given length
118 fn bench_dct4_naive(b: &mut Bencher, len: usize) {
119 let dct = Type4Naive::new(len);
120
121 let mut buffer = vec![0_f32; len];
122 let mut scratch = vec![0_f32; dct.get_scratch_len()];
123 b.iter(|| {
124 dct.process_dct4_with_scratch(&mut buffer, &mut scratch);
125 });
126 }
127
128 #[bench]
129 fn dct4_even_naive_02(b: &mut Bencher) {
130 bench_dct4_naive(b, 2);
131 }
132 #[bench]
133 fn dct4_even_naive_04(b: &mut Bencher) {
134 bench_dct4_naive(b, 4);
135 }
136 #[bench]
137 fn dct4_even_naive_06(b: &mut Bencher) {
138 bench_dct4_naive(b, 6);
139 }
140 #[bench]
141 fn dct4_even_naive_08(b: &mut Bencher) {
142 bench_dct4_naive(b, 8);
143 }
144 #[bench]
145 fn dct4_even_naive_10(b: &mut Bencher) {
146 bench_dct4_naive(b, 10);
147 }
148
149 #[bench]
150 fn dct4_odd_naive_01(b: &mut Bencher) {
151 bench_dct4_naive(b, 1);
152 }
153 #[bench]
154 fn dct4_odd_naive_03(b: &mut Bencher) {
155 bench_dct4_naive(b, 3);
156 }
157 #[bench]
158 fn dct4_odd_naive_05(b: &mut Bencher) {
159 bench_dct4_naive(b, 5);
160 }
161 #[bench]
162 fn dct4_odd_naive_07(b: &mut Bencher) {
163 bench_dct4_naive(b, 7);
164 }
165 #[bench]
166 fn dct4_odd_naive_09(b: &mut Bencher) {
167 bench_dct4_naive(b, 9);
168 }
169
170 /// Times just the MDCT execution (not allocation and pre-calculation)
171 /// for a given length
172 fn bench_mdct_naive(b: &mut Bencher, len: usize) {
173 let dct = MdctNaive::new(len, window_fn::mp3);
174
175 let input = vec![0_f32; len * 2];
176 let (input_a, input_b) = input.split_at(len);
177 let mut output = vec![0_f32; len];
178 let mut scratch = vec![0_f32; dct.get_scratch_len()];
179
180 b.iter(|| {
181 dct.process_mdct_with_scratch(input_a, input_b, &mut output, &mut scratch);
182 });
183 }
184
185 #[bench]
186 fn mdct_naive_02(b: &mut Bencher) {
187 bench_mdct_naive(b, 2);
188 }
189 #[bench]
190 fn mdct_naive_04(b: &mut Bencher) {
191 bench_mdct_naive(b, 4);
192 }
193 #[bench]
194 fn mdct_naive_06(b: &mut Bencher) {
195 bench_mdct_naive(b, 6);
196 }
197 #[bench]
198 fn mdct_naive_08(b: &mut Bencher) {
199 bench_mdct_naive(b, 8);
200 }
201 #[bench]
202 fn mdct_naive_10(b: &mut Bencher) {
203 bench_mdct_naive(b, 10);
204 }
205 #[bench]
206 fn mdct_naive_12(b: &mut Bencher) {
207 bench_mdct_naive(b, 12);
208 }
209
210 /// Times just the IMDCT execution (not allocation and pre-calculation)
211 /// for a given length
212 fn bench_imdct_naive(b: &mut Bencher, len: usize) {
213 let dct = MdctNaive::new(len, window_fn::mp3);
214
215 let input = vec![0_f32; len];
216 let mut output = vec![0_f32; len * 2];
217 let (output_a, output_b) = output.split_at_mut(len);
218 let mut scratch = vec![0_f32; dct.get_scratch_len()];
219 b.iter(|| {
220 dct.process_imdct_with_scratch(&input, output_a, output_b, &mut scratch);
221 });
222 }
223
224 #[bench]
225 fn imdct_naive_02(b: &mut Bencher) {
226 bench_imdct_naive(b, 2);
227 }
228 #[bench]
229 fn imdct_naive_04(b: &mut Bencher) {
230 bench_imdct_naive(b, 4);
231 }
232 #[bench]
233 fn imdct_naive_06(b: &mut Bencher) {
234 bench_imdct_naive(b, 6);
235 }
236 #[bench]
237 fn imdct_naive_08(b: &mut Bencher) {
238 bench_imdct_naive(b, 8);
239 }
240 #[bench]
241 fn imdct_naive_10(b: &mut Bencher) {
242 bench_imdct_naive(b, 10);
243 }
244 #[bench]
245 fn imdct_naive_12(b: &mut Bencher) {
246 bench_imdct_naive(b, 12);
247 }
248
249 /// Times just the DST6 execution (not allocation and pre-calculation)
250 /// for a given length
251 fn bench_dst6_naive(b: &mut Bencher, len: usize) {
252 let dct = Dst6And7Naive::new(len);
253
254 let mut buffer = vec![0_f32; len];
255 let mut scratch = vec![0_f32; dct.get_scratch_len()];
256 b.iter(|| {
257 dct.process_dst6_with_scratch(&mut buffer, &mut scratch);
258 });
259 }
260
261 #[bench]
262 fn dst6_even_naive_10(b: &mut Bencher) {
263 bench_dst6_naive(b, 10);
264 }
265 #[bench]
266 fn dst6_even_naive_11(b: &mut Bencher) {
267 bench_dst6_naive(b, 11);
268 }
269 #[bench]
270 fn dst6_even_naive_12(b: &mut Bencher) {
271 bench_dst6_naive(b, 12);
272 }
273 #[bench]
274 fn dst6_even_naive_13(b: &mut Bencher) {
275 bench_dst6_naive(b, 13);
276 }
277 #[bench]
278 fn dst6_even_naive_14(b: &mut Bencher) {
279 bench_dst6_naive(b, 14);
280 }
281 #[bench]
282 fn dst6_even_naive_15(b: &mut Bencher) {
283 bench_dst6_naive(b, 15);
284 }
285 #[bench]
286 fn dst6_even_naive_16(b: &mut Bencher) {
287 bench_dst6_naive(b, 16);
288 }
289 #[bench]
290 fn dst6_even_naive_17(b: &mut Bencher) {
291 bench_dst6_naive(b, 17);
292 }
293 #[bench]
294 fn dst6_even_naive_18(b: &mut Bencher) {
295 bench_dst6_naive(b, 18);
296 }
297 #[bench]
298 fn dst6_even_naive_19(b: &mut Bencher) {
299 bench_dst6_naive(b, 19);
300 }
301 #[bench]
302 fn dst6_even_naive_20(b: &mut Bencher) {
303 bench_dst6_naive(b, 20);
304 }
305 #[bench]
306 fn dst6_even_naive_21(b: &mut Bencher) {
307 bench_dst6_naive(b, 21);
308 }
309 #[bench]
310 fn dst6_even_naive_22(b: &mut Bencher) {
311 bench_dst6_naive(b, 22);
312 }
313 #[bench]
314 fn dst6_even_naive_23(b: &mut Bencher) {
315 bench_dst6_naive(b, 23);
316 }
317 #[bench]
318 fn dst6_even_naive_24(b: &mut Bencher) {
319 bench_dst6_naive(b, 24);
320 }
321 #[bench]
322 fn dst6_even_naive_25(b: &mut Bencher) {
323 bench_dst6_naive(b, 25);
324 }
325 #[bench]
326 fn dst6_even_naive_26(b: &mut Bencher) {
327 bench_dst6_naive(b, 26);
328 }
329 #[bench]
330 fn dst6_even_naive_27(b: &mut Bencher) {
331 bench_dst6_naive(b, 27);
332 }
333 #[bench]
334 fn dst6_even_naive_28(b: &mut Bencher) {
335 bench_dst6_naive(b, 28);
336 }
337 #[bench]
338 fn dst6_even_naive_29(b: &mut Bencher) {
339 bench_dst6_naive(b, 29);
340 }
341 #[bench]
342 fn dst6_even_naive_30(b: &mut Bencher) {
343 bench_dst6_naive(b, 30);
344 }
345 #[bench]
346 fn dst6_even_naive_31(b: &mut Bencher) {
347 bench_dst6_naive(b, 31);
348 }
349 #[bench]
350 fn dst6_even_naive_32(b: &mut Bencher) {
351 bench_dst6_naive(b, 32);
352 }
353 #[bench]
354 fn dst6_even_naive_33(b: &mut Bencher) {
355 bench_dst6_naive(b, 33);
356 }
357 #[bench]
358 fn dst6_even_naive_34(b: &mut Bencher) {
359 bench_dst6_naive(b, 34);
360 }
361 #[bench]
362 fn dst6_even_naive_35(b: &mut Bencher) {
363 bench_dst6_naive(b, 35);
364 }
365 #[bench]
366 fn dst6_even_naive_36(b: &mut Bencher) {
367 bench_dst6_naive(b, 36);
368 }
369 #[bench]
370 fn dst6_even_naive_37(b: &mut Bencher) {
371 bench_dst6_naive(b, 37);
372 }
373 #[bench]
374 fn dst6_even_naive_38(b: &mut Bencher) {
375 bench_dst6_naive(b, 38);
376 }
377 #[bench]
378 fn dst6_even_naive_39(b: &mut Bencher) {
379 bench_dst6_naive(b, 39);
380 }
381
382 /// Times just the DST7 execution (not allocation and pre-calculation)
383 /// for a given length
384 fn bench_dst7_naive(b: &mut Bencher, len: usize) {
385 let dct = Dst6And7Naive::new(len);
386
387 let mut buffer = vec![0_f32; len];
388 let mut scratch = vec![0_f32; dct.get_scratch_len()];
389 b.iter(|| {
390 dct.process_dst7_with_scratch(&mut buffer, &mut scratch);
391 });
392 }
393
394 #[bench]
395 fn dst7_even_naive_10(b: &mut Bencher) {
396 bench_dst7_naive(b, 10);
397 }
398 #[bench]
399 fn dst7_even_naive_11(b: &mut Bencher) {
400 bench_dst7_naive(b, 11);
401 }
402 #[bench]
403 fn dst7_even_naive_12(b: &mut Bencher) {
404 bench_dst7_naive(b, 12);
405 }
406 #[bench]
407 fn dst7_even_naive_13(b: &mut Bencher) {
408 bench_dst7_naive(b, 13);
409 }
410 #[bench]
411 fn dst7_even_naive_14(b: &mut Bencher) {
412 bench_dst7_naive(b, 14);
413 }
414 #[bench]
415 fn dst7_even_naive_15(b: &mut Bencher) {
416 bench_dst7_naive(b, 15);
417 }
418 #[bench]
419 fn dst7_even_naive_16(b: &mut Bencher) {
420 bench_dst7_naive(b, 16);
421 }
422 #[bench]
423 fn dst7_even_naive_17(b: &mut Bencher) {
424 bench_dst7_naive(b, 17);
425 }
426 #[bench]
427 fn dst7_even_naive_18(b: &mut Bencher) {
428 bench_dst7_naive(b, 18);
429 }
430 #[bench]
431 fn dst7_even_naive_19(b: &mut Bencher) {
432 bench_dst7_naive(b, 19);
433 }
434 #[bench]
435 fn dst7_even_naive_20(b: &mut Bencher) {
436 bench_dst7_naive(b, 20);
437 }
438 #[bench]
439 fn dst7_even_naive_21(b: &mut Bencher) {
440 bench_dst7_naive(b, 21);
441 }
442 #[bench]
443 fn dst7_even_naive_22(b: &mut Bencher) {
444 bench_dst7_naive(b, 22);
445 }
446 #[bench]
447 fn dst7_even_naive_23(b: &mut Bencher) {
448 bench_dst7_naive(b, 23);
449 }
450 #[bench]
451 fn dst7_even_naive_24(b: &mut Bencher) {
452 bench_dst7_naive(b, 24);
453 }
454 #[bench]
455 fn dst7_even_naive_25(b: &mut Bencher) {
456 bench_dst7_naive(b, 25);
457 }
458 #[bench]
459 fn dst7_even_naive_26(b: &mut Bencher) {
460 bench_dst7_naive(b, 26);
461 }
462 #[bench]
463 fn dst7_even_naive_27(b: &mut Bencher) {
464 bench_dst7_naive(b, 27);
465 }
466 #[bench]
467 fn dst7_even_naive_28(b: &mut Bencher) {
468 bench_dst7_naive(b, 28);
469 }
470 #[bench]
471 fn dst7_even_naive_29(b: &mut Bencher) {
472 bench_dst7_naive(b, 29);
473 }
474 #[bench]
475 fn dst7_even_naive_30(b: &mut Bencher) {
476 bench_dst7_naive(b, 30);
477 }
478 #[bench]
479 fn dst7_even_naive_31(b: &mut Bencher) {
480 bench_dst7_naive(b, 31);
481 }
482 #[bench]
483 fn dst7_even_naive_32(b: &mut Bencher) {
484 bench_dst7_naive(b, 32);
485 }
486 #[bench]
487 fn dst7_even_naive_33(b: &mut Bencher) {
488 bench_dst7_naive(b, 33);
489 }
490 #[bench]
491 fn dst7_even_naive_34(b: &mut Bencher) {
492 bench_dst7_naive(b, 34);
493 }
494 #[bench]
495 fn dst7_even_naive_35(b: &mut Bencher) {
496 bench_dst7_naive(b, 35);
497 }
498 #[bench]
499 fn dst7_even_naive_36(b: &mut Bencher) {
500 bench_dst7_naive(b, 36);
501 }
502 #[bench]
503 fn dst7_even_naive_37(b: &mut Bencher) {
504 bench_dst7_naive(b, 37);
505 }
506 #[bench]
507 fn dst7_even_naive_38(b: &mut Bencher) {
508 bench_dst7_naive(b, 38);
509 }
510 #[bench]
511 fn dst7_even_naive_39(b: &mut Bencher) {
512 bench_dst7_naive(b, 39);
513 }