Debian Codegraph @

.cargo/vendor/rustdct/benches/bench_dct_via_fft.rs

raw
1 #![feature(test)]
2 extern crate rustdct;
3 extern crate test;
4
5 use std::sync::Arc;
6
7 use rustdct::algorithm::*;
8 use rustdct::mdct::{window_fn, Mdct, MdctViaDct4};
9 use rustdct::rustfft::FftPlanner;
10 use rustdct::DctPlanner;
11 use rustdct::{algorithm::type2and3_butterflies::*, RequiredScratch};
12 use rustdct::{Dct1, Dct2, Dct3, Dct4, Dst6, Dst7, TransformType2And3};
13
14 use test::Bencher;
15
16 /// Times just the DCT1 execution (not allocation and pre-calculation)
17 /// for a given length
18 fn bench_dct1_fft(b: &mut Bencher, len: usize) {
19 let mut planner = FftPlanner::new();
20 let dct = Dct1ConvertToFft::new(planner.plan_fft_forward((len - 1) * 2));
21
22 let mut buffer = vec![0_f32; len];
23 let mut scratch = vec![0_f32; dct.get_scratch_len()];
24 b.iter(|| {
25 dct.process_dct1_with_scratch(&mut buffer, &mut scratch);
26 });
27 }
28
29 #[bench]
30 fn dct1_fft_002(b: &mut Bencher) {
31 bench_dct1_fft(b, 2);
32 }
33 #[bench]
34 fn dct1_fft_004(b: &mut Bencher) {
35 bench_dct1_fft(b, 4);
36 }
37 #[bench]
38 fn dct1_fft_006(b: &mut Bencher) {
39 bench_dct1_fft(b, 6);
40 }
41 #[bench]
42 fn dct1_fft_008(b: &mut Bencher) {
43 bench_dct1_fft(b, 8);
44 }
45 #[bench]
46 fn dct1_fft_010(b: &mut Bencher) {
47 bench_dct1_fft(b, 10);
48 }
49
50 /// Times just the DCT2 execution (not allocation and pre-calculation)
51 /// for a given length
52 fn bench_dct2_fft(b: &mut Bencher, len: usize) {
53 let mut planner = FftPlanner::new();
54 let dct = Type2And3ConvertToFft::new(planner.plan_fft_forward(len));
55
56 let mut buffer = vec![0_f32; len];
57 let mut scratch = vec![0_f32; dct.get_scratch_len()];
58 b.iter(|| {
59 dct.process_dct2_with_scratch(&mut buffer, &mut scratch);
60 });
61 }
62
63 #[bench]
64 fn dct2_fft_06(b: &mut Bencher) {
65 bench_dct2_fft(b, 6);
66 }
67 #[bench]
68 fn dct2_fft_05(b: &mut Bencher) {
69 bench_dct2_fft(b, 5);
70 }
71 #[bench]
72 fn dct2_fft_04(b: &mut Bencher) {
73 bench_dct2_fft(b, 4);
74 }
75 #[bench]
76 fn dct2_fft_03(b: &mut Bencher) {
77 bench_dct2_fft(b, 3);
78 }
79 #[bench]
80 fn dct2_fft_02(b: &mut Bencher) {
81 bench_dct2_fft(b, 2);
82 }
83 #[bench]
84 fn dct2_fft_01(b: &mut Bencher) {
85 bench_dct2_fft(b, 1);
86 }
87
88 /// Times just the DCT2 execution (not allocation and pre-calculation)
89 /// for a given length
90 fn bench_dct2_split(b: &mut Bencher, len: usize) {
91 let power = len.trailing_zeros() as usize;
92 let mut instances = vec![
93 Arc::new(Type2And3Naive::new(1)) as Arc<dyn TransformType2And3<f32>>,
94 Arc::new(Type2And3Butterfly2::new()) as Arc<dyn TransformType2And3<f32>>,
95 Arc::new(Type2And3Butterfly4::new()) as Arc<dyn TransformType2And3<f32>>,
96 Arc::new(Type2And3Butterfly8::new()) as Arc<dyn TransformType2And3<f32>>,
97 Arc::new(Type2And3Butterfly16::new()) as Arc<dyn TransformType2And3<f32>>,
98 ];
99 for i in instances.len()..(power + 1) {
100 let dct = Arc::new(Type2And3SplitRadix::new(
101 instances[i - 1].clone(),
102 instances[i - 2].clone(),
103 ));
104 instances.push(dct);
105 }
106
107 let dct = instances[power].clone();
108 assert_eq!(dct.len(), len);
109
110 let mut buffer = vec![0_f32; len];
111 let mut scratch = vec![0_f32; dct.get_scratch_len()];
112 b.iter(|| {
113 dct.process_dct2_with_scratch(&mut buffer, &mut scratch);
114 });
115 }
116 #[bench]
117 fn dct2_power2_split_0002(b: &mut Bencher) {
118 bench_dct2_split(b, 2);
119 }
120 #[bench]
121 fn dct2_power2_split_0004(b: &mut Bencher) {
122 bench_dct2_split(b, 4);
123 }
124 #[bench]
125 fn dct2_power2_split_0008(b: &mut Bencher) {
126 bench_dct2_split(b, 4);
127 }
128 #[bench]
129 fn dct2_power2_split_0016(b: &mut Bencher) {
130 bench_dct2_split(b, 16);
131 }
132 #[bench]
133 fn dct2_power2_split_0032(b: &mut Bencher) {
134 bench_dct2_split(b, 32);
135 }
136 #[bench]
137 fn dct2_power2_split_0064(b: &mut Bencher) {
138 bench_dct2_split(b, 64);
139 }
140 #[bench]
141 fn dct2_power2_split_0128(b: &mut Bencher) {
142 bench_dct2_split(b, 128);
143 }
144 #[bench]
145 fn dct2_power2_split_0256(b: &mut Bencher) {
146 bench_dct2_split(b, 256);
147 }
148 #[bench]
149 fn dct2_power2_split_065536(b: &mut Bencher) {
150 bench_dct2_split(b, 65536);
151 }
152
153 #[bench]
154 fn dct2_power2_fft_0002(b: &mut Bencher) {
155 bench_dct2_fft(b, 2);
156 }
157 #[bench]
158 fn dct2_power2_fft_0004(b: &mut Bencher) {
159 bench_dct2_fft(b, 4);
160 }
161 #[bench]
162 fn dct2_power2_fft_0008(b: &mut Bencher) {
163 bench_dct2_fft(b, 4);
164 }
165 #[bench]
166 fn dct2_power2_fft_0016(b: &mut Bencher) {
167 bench_dct2_fft(b, 16);
168 }
169 #[bench]
170 fn dct2_power2_fft_0032(b: &mut Bencher) {
171 bench_dct2_fft(b, 32);
172 }
173 #[bench]
174 fn dct2_power2_fft_0064(b: &mut Bencher) {
175 bench_dct2_fft(b, 64);
176 }
177 #[bench]
178 fn dct2_power2_fft_0128(b: &mut Bencher) {
179 bench_dct2_fft(b, 128);
180 }
181 #[bench]
182 fn dct2_power2_fft_0256(b: &mut Bencher) {
183 bench_dct2_fft(b, 256);
184 }
185 #[bench]
186 fn dct2_power2_fft_065536(b: &mut Bencher) {
187 bench_dct2_fft(b, 65536);
188 }
189
190 /// Times just the DCT3 execution (not allocation and pre-calculation)
191 /// for a given length
192 fn bench_dct3_fft(b: &mut Bencher, len: usize) {
193 let mut planner = FftPlanner::new();
194 let dct = Type2And3ConvertToFft::new(planner.plan_fft_forward(len));
195
196 let mut buffer = vec![0_f32; len];
197 let mut scratch = vec![0_f32; dct.get_scratch_len()];
198 b.iter(|| {
199 dct.process_dct3_with_scratch(&mut buffer, &mut scratch);
200 });
201 }
202
203 #[bench]
204 fn dct3_fft_003(b: &mut Bencher) {
205 bench_dct3_fft(b, 3);
206 }
207 #[bench]
208 fn dct3_fft_004(b: &mut Bencher) {
209 bench_dct3_fft(b, 4);
210 }
211 #[bench]
212 fn dct3_fft_005(b: &mut Bencher) {
213 bench_dct3_fft(b, 5);
214 }
215 #[bench]
216 fn dct3_fft_006(b: &mut Bencher) {
217 bench_dct3_fft(b, 6);
218 }
219
220 #[bench]
221 fn dct3_power2_fft_00004(b: &mut Bencher) {
222 bench_dct3_fft(b, 4);
223 }
224 #[bench]
225 fn dct3_power2_fft_00008(b: &mut Bencher) {
226 bench_dct3_fft(b, 8);
227 }
228 #[bench]
229 fn dct3_power2_fft_00016(b: &mut Bencher) {
230 bench_dct3_fft(b, 16);
231 }
232 #[bench]
233 fn dct3_power2_fft_00032(b: &mut Bencher) {
234 bench_dct3_fft(b, 32);
235 }
236 #[bench]
237 fn dct3_power2_fft_00064(b: &mut Bencher) {
238 bench_dct3_fft(b, 64);
239 }
240 #[bench]
241 fn dct3_power2_fft_00256(b: &mut Bencher) {
242 bench_dct3_fft(b, 256);
243 }
244 #[bench]
245 fn dct3_power2_fft_065536(b: &mut Bencher) {
246 bench_dct3_fft(b, 65536);
247 }
248 #[bench]
249 fn dct3_power2_fft_16777216(b: &mut Bencher) {
250 bench_dct3_fft(b, 16777216);
251 }
252
253 /// Times just the DCT2 execution (not allocation and pre-calculation)
254 /// for a given length
255 fn bench_dct3_split(b: &mut Bencher, len: usize) {
256 let power = len.trailing_zeros() as usize;
257 let mut instances = vec![
258 Arc::new(Type2And3Naive::new(1)) as Arc<dyn TransformType2And3<f32>>,
259 Arc::new(Type2And3Butterfly2::new()) as Arc<dyn TransformType2And3<f32>>,
260 Arc::new(Type2And3Butterfly4::new()) as Arc<dyn TransformType2And3<f32>>,
261 Arc::new(Type2And3Butterfly8::new()) as Arc<dyn TransformType2And3<f32>>,
262 Arc::new(Type2And3Butterfly16::new()) as Arc<dyn TransformType2And3<f32>>,
263 ];
264 for i in instances.len()..(power + 1) {
265 let dct = Arc::new(Type2And3SplitRadix::new(
266 instances[i - 1].clone(),
267 instances[i - 2].clone(),
268 ));
269 instances.push(dct);
270 }
271
272 let dct = instances[power].clone();
273 assert_eq!(dct.len(), len);
274
275 let mut buffer = vec![0_f32; len];
276 let mut scratch = vec![0_f32; dct.get_scratch_len()];
277 b.iter(|| {
278 dct.process_dct3_with_scratch(&mut buffer, &mut scratch);
279 });
280 }
281 #[bench]
282 fn dct3_power2_split_0002(b: &mut Bencher) {
283 bench_dct3_split(b, 4);
284 }
285 #[bench]
286 fn dct3_power2_split_0004(b: &mut Bencher) {
287 bench_dct3_split(b, 4);
288 }
289 #[bench]
290 fn dct3_power2_split_0008(b: &mut Bencher) {
291 bench_dct3_split(b, 4);
292 }
293 #[bench]
294 fn dct3_power2_split_0016(b: &mut Bencher) {
295 bench_dct3_split(b, 16);
296 }
297 #[bench]
298 fn dct3_power2_split_0064(b: &mut Bencher) {
299 bench_dct3_split(b, 64);
300 }
301 #[bench]
302 fn dct3_power2_split_0256(b: &mut Bencher) {
303 bench_dct3_split(b, 256);
304 }
305 #[bench]
306 fn dct3_power2_split_065536(b: &mut Bencher) {
307 bench_dct3_split(b, 65536);
308 }
309
310 /// Times just the DCT4 execution (not allocation and pre-calculation)
311 /// for a given length
312 fn bench_dct4_via_dct3(b: &mut Bencher, len: usize) {
313 let mut planner = DctPlanner::new();
314 let inner_dct3 = planner.plan_dct3(len / 2);
315 let dct = Type4ConvertToType3Even::new(inner_dct3);
316
317 let mut buffer = vec![0_f32; len];
318 let mut scratch = vec![0_f32; dct.get_scratch_len()];
319 b.iter(|| {
320 dct.process_dct4_with_scratch(&mut buffer, &mut scratch);
321 });
322 }
323
324 #[bench]
325 fn dct4_even_via_dct3_02(b: &mut Bencher) {
326 bench_dct4_via_dct3(b, 2);
327 }
328 #[bench]
329 fn dct4_even_via_dct3_04(b: &mut Bencher) {
330 bench_dct4_via_dct3(b, 4);
331 }
332 #[bench]
333 fn dct4_even_via_dct3_06(b: &mut Bencher) {
334 bench_dct4_via_dct3(b, 6);
335 }
336 #[bench]
337 fn dct4_even_via_dct3_08(b: &mut Bencher) {
338 bench_dct4_via_dct3(b, 8);
339 }
340 #[bench]
341 fn dct4_even_via_dct3_10(b: &mut Bencher) {
342 bench_dct4_via_dct3(b, 10);
343 }
344
345 #[bench]
346 fn dct4_even_via_dct3_1000000(b: &mut Bencher) {
347 bench_dct4_via_dct3(b, 1000000);
348 }
349
350 /// Times just the DCT4 execution (not allocation and pre-calculation)
351 /// for a given length
352 fn bench_dct4_via_fft_odd(b: &mut Bencher, len: usize) {
353 let mut planner = FftPlanner::new();
354 let inner_fft = planner.plan_fft_forward(len);
355 let dct = Type4ConvertToFftOdd::new(inner_fft);
356
357 let mut buffer = vec![0_f32; len];
358 let mut scratch = vec![0_f32; dct.get_scratch_len()];
359 b.iter(|| {
360 dct.process_dct4_with_scratch(&mut buffer, &mut scratch);
361 });
362 }
363
364 #[bench]
365 fn dct4_odd_via_fft_01(b: &mut Bencher) {
366 bench_dct4_via_fft_odd(b, 1);
367 }
368 #[bench]
369 fn dct4_odd_via_fft_03(b: &mut Bencher) {
370 bench_dct4_via_fft_odd(b, 3);
371 }
372 #[bench]
373 fn dct4_odd_via_fft_05(b: &mut Bencher) {
374 bench_dct4_via_fft_odd(b, 5);
375 }
376 #[bench]
377 fn dct4_odd_via_fft_07(b: &mut Bencher) {
378 bench_dct4_via_fft_odd(b, 7);
379 }
380 #[bench]
381 fn dct4_odd_via_fft_09(b: &mut Bencher) {
382 bench_dct4_via_fft_odd(b, 9);
383 }
384 #[bench]
385 fn dct4_odd_via_fft_999999(b: &mut Bencher) {
386 bench_dct4_via_fft_odd(b, 999999);
387 }
388
389 /// Times just the MDCT execution (not allocation and pre-calculation)
390 /// for a given length
391 fn bench_mdct_fft(b: &mut Bencher, len: usize) {
392 let mut planner = DctPlanner::new();
393 let dct = MdctViaDct4::new(planner.plan_dct4(len), window_fn::mp3);
394
395 let input = vec![0_f32; len * 2];
396 let (input_a, input_b) = input.split_at(len);
397 let mut output = vec![0_f32; len];
398 let mut scratch = vec![0_f32; dct.get_scratch_len()];
399
400 b.iter(|| {
401 dct.process_mdct_with_scratch(input_a, input_b, &mut output, &mut scratch);
402 });
403 }
404 #[bench]
405 fn mdct_fft_02(b: &mut Bencher) {
406 bench_mdct_fft(b, 2);
407 }
408 #[bench]
409 fn mdct_fft_04(b: &mut Bencher) {
410 bench_mdct_fft(b, 4);
411 }
412 #[bench]
413 fn mdct_fft_06(b: &mut Bencher) {
414 bench_mdct_fft(b, 6);
415 }
416 #[bench]
417 fn mdct_fft_08(b: &mut Bencher) {
418 bench_mdct_fft(b, 8);
419 }
420 #[bench]
421 fn mdct_fft_10(b: &mut Bencher) {
422 bench_mdct_fft(b, 10);
423 }
424 #[bench]
425 fn mdct_fft_12(b: &mut Bencher) {
426 bench_mdct_fft(b, 12);
427 }
428
429 /// Times just the IMDCT execution (not allocation and pre-calculation)
430 /// for a given length
431 fn bench_imdct_fft(b: &mut Bencher, len: usize) {
432 let mut planner = DctPlanner::new();
433 let dct = MdctViaDct4::new(planner.plan_dct4(len), window_fn::mp3);
434
435 let input = vec![0_f32; len];
436 let mut output = vec![0_f32; len * 2];
437 let (output_a, output_b) = output.split_at_mut(len);
438 let mut scratch = vec![0_f32; dct.get_scratch_len()];
439 b.iter(|| {
440 dct.process_imdct_with_scratch(&input, output_a, output_b, &mut scratch);
441 });
442 }
443 #[bench]
444 fn imdct_fft_02(b: &mut Bencher) {
445 bench_imdct_fft(b, 2);
446 }
447 #[bench]
448 fn imdct_fft_04(b: &mut Bencher) {
449 bench_imdct_fft(b, 4);
450 }
451 #[bench]
452 fn imdct_fft_06(b: &mut Bencher) {
453 bench_imdct_fft(b, 6);
454 }
455 #[bench]
456 fn imdct_fft_08(b: &mut Bencher) {
457 bench_imdct_fft(b, 8);
458 }
459 #[bench]
460 fn imdct_fft_10(b: &mut Bencher) {
461 bench_imdct_fft(b, 10);
462 }
463 #[bench]
464 fn imdct_fft_12(b: &mut Bencher) {
465 bench_imdct_fft(b, 12);
466 }
467
468 /// Times just the DST6 execution (not allocation and pre-calculation)
469 /// for a given length
470 fn bench_dst6_fft(b: &mut Bencher, len: usize) {
471 let mut planner = FftPlanner::new();
472 let dct = Dst6And7ConvertToFft::new(planner.plan_fft_forward(len * 2 + 1));
473
474 let mut buffer = vec![0_f32; len];
475 let mut scratch = vec![0_f32; dct.get_scratch_len()];
476 b.iter(|| {
477 dct.process_dst6_with_scratch(&mut buffer, &mut scratch);
478 });
479 }
480
481 #[bench]
482 fn dst6_fft_10(b: &mut Bencher) {
483 bench_dst6_fft(b, 10);
484 }
485 #[bench]
486 fn dst6_fft_11(b: &mut Bencher) {
487 bench_dst6_fft(b, 11);
488 }
489 #[bench]
490 fn dst6_fft_12(b: &mut Bencher) {
491 bench_dst6_fft(b, 12);
492 }
493 #[bench]
494 fn dst6_fft_13(b: &mut Bencher) {
495 bench_dst6_fft(b, 13);
496 }
497 #[bench]
498 fn dst6_fft_14(b: &mut Bencher) {
499 bench_dst6_fft(b, 14);
500 }
501 #[bench]
502 fn dst6_fft_15(b: &mut Bencher) {
503 bench_dst6_fft(b, 15);
504 }
505 #[bench]
506 fn dst6_fft_16(b: &mut Bencher) {
507 bench_dst6_fft(b, 16);
508 }
509 #[bench]
510 fn dst6_fft_17(b: &mut Bencher) {
511 bench_dst6_fft(b, 17);
512 }
513 #[bench]
514 fn dst6_fft_18(b: &mut Bencher) {
515 bench_dst6_fft(b, 18);
516 }
517 #[bench]
518 fn dst6_fft_19(b: &mut Bencher) {
519 bench_dst6_fft(b, 19);
520 }
521 #[bench]
522 fn dst6_fft_20(b: &mut Bencher) {
523 bench_dst6_fft(b, 20);
524 }
525 #[bench]
526 fn dst6_fft_21(b: &mut Bencher) {
527 bench_dst6_fft(b, 21);
528 }
529 #[bench]
530 fn dst6_fft_22(b: &mut Bencher) {
531 bench_dst6_fft(b, 22);
532 }
533 #[bench]
534 fn dst6_fft_23(b: &mut Bencher) {
535 bench_dst6_fft(b, 23);
536 }
537 #[bench]
538 fn dst6_fft_24(b: &mut Bencher) {
539 bench_dst6_fft(b, 24);
540 }
541 #[bench]
542 fn dst6_fft_25(b: &mut Bencher) {
543 bench_dst6_fft(b, 25);
544 }
545 #[bench]
546 fn dst6_fft_26(b: &mut Bencher) {
547 bench_dst6_fft(b, 26);
548 }
549 #[bench]
550 fn dst6_fft_27(b: &mut Bencher) {
551 bench_dst6_fft(b, 27);
552 }
553 #[bench]
554 fn dst6_fft_28(b: &mut Bencher) {
555 bench_dst6_fft(b, 28);
556 }
557 #[bench]
558 fn dst6_fft_29(b: &mut Bencher) {
559 bench_dst6_fft(b, 29);
560 }
561 #[bench]
562 fn dst6_fft_30(b: &mut Bencher) {
563 bench_dst6_fft(b, 30);
564 }
565 #[bench]
566 fn dst6_fft_31(b: &mut Bencher) {
567 bench_dst6_fft(b, 31);
568 }
569 #[bench]
570 fn dst6_fft_32(b: &mut Bencher) {
571 bench_dst6_fft(b, 32);
572 }
573 #[bench]
574 fn dst6_fft_33(b: &mut Bencher) {
575 bench_dst6_fft(b, 33);
576 }
577 #[bench]
578 fn dst6_fft_34(b: &mut Bencher) {
579 bench_dst6_fft(b, 34);
580 }
581 #[bench]
582 fn dst6_fft_35(b: &mut Bencher) {
583 bench_dst6_fft(b, 35);
584 }
585 #[bench]
586 fn dst6_fft_36(b: &mut Bencher) {
587 bench_dst6_fft(b, 36);
588 }
589 #[bench]
590 fn dst6_fft_37(b: &mut Bencher) {
591 bench_dst6_fft(b, 37);
592 }
593 #[bench]
594 fn dst6_fft_38(b: &mut Bencher) {
595 bench_dst6_fft(b, 38);
596 }
597 #[bench]
598 fn dst6_fft_39(b: &mut Bencher) {
599 bench_dst6_fft(b, 39);
600 }
601
602 /// Times just the DST6 execution (not allocation and pre-calculation)
603 /// for a given length
604 fn bench_dst7_fft(b: &mut Bencher, len: usize) {
605 let mut planner = FftPlanner::new();
606 let dct = Dst6And7ConvertToFft::new(planner.plan_fft_forward(len * 2 + 1));
607
608 let mut buffer = vec![0_f32; len];
609 let mut scratch = vec![0_f32; dct.get_scratch_len()];
610 b.iter(|| {
611 dct.process_dst7_with_scratch(&mut buffer, &mut scratch);
612 });
613 }
614
615 #[bench]
616 fn dst7_fft_10(b: &mut Bencher) {
617 bench_dst7_fft(b, 10);
618 }
619 #[bench]
620 fn dst7_fft_11(b: &mut Bencher) {
621 bench_dst7_fft(b, 11);
622 }
623 #[bench]
624 fn dst7_fft_12(b: &mut Bencher) {
625 bench_dst7_fft(b, 12);
626 }
627 #[bench]
628 fn dst7_fft_13(b: &mut Bencher) {
629 bench_dst7_fft(b, 13);
630 }
631 #[bench]
632 fn dst7_fft_14(b: &mut Bencher) {
633 bench_dst7_fft(b, 14);
634 }
635 #[bench]
636 fn dst7_fft_15(b: &mut Bencher) {
637 bench_dst7_fft(b, 15);
638 }
639 #[bench]
640 fn dst7_fft_16(b: &mut Bencher) {
641 bench_dst7_fft(b, 16);
642 }
643 #[bench]
644 fn dst7_fft_17(b: &mut Bencher) {
645 bench_dst7_fft(b, 17);
646 }
647 #[bench]
648 fn dst7_fft_18(b: &mut Bencher) {
649 bench_dst7_fft(b, 18);
650 }
651 #[bench]
652 fn dst7_fft_19(b: &mut Bencher) {
653 bench_dst7_fft(b, 19);
654 }
655 #[bench]
656 fn dst7_fft_20(b: &mut Bencher) {
657 bench_dst7_fft(b, 20);
658 }
659 #[bench]
660 fn dst7_fft_21(b: &mut Bencher) {
661 bench_dst7_fft(b, 21);
662 }
663 #[bench]
664 fn dst7_fft_22(b: &mut Bencher) {
665 bench_dst7_fft(b, 22);
666 }
667 #[bench]
668 fn dst7_fft_23(b: &mut Bencher) {
669 bench_dst7_fft(b, 23);
670 }
671 #[bench]
672 fn dst7_fft_24(b: &mut Bencher) {
673 bench_dst7_fft(b, 24);
674 }
675 #[bench]
676 fn dst7_fft_25(b: &mut Bencher) {
677 bench_dst7_fft(b, 25);
678 }
679 #[bench]
680 fn dst7_fft_26(b: &mut Bencher) {
681 bench_dst7_fft(b, 26);
682 }
683 #[bench]
684 fn dst7_fft_27(b: &mut Bencher) {
685 bench_dst7_fft(b, 27);
686 }
687 #[bench]
688 fn dst7_fft_28(b: &mut Bencher) {
689 bench_dst7_fft(b, 28);
690 }
691 #[bench]
692 fn dst7_fft_29(b: &mut Bencher) {
693 bench_dst7_fft(b, 29);
694 }
695 #[bench]
696 fn dst7_fft_30(b: &mut Bencher) {
697 bench_dst7_fft(b, 30);
698 }
699 #[bench]
700 fn dst7_fft_31(b: &mut Bencher) {
701 bench_dst7_fft(b, 31);
702 }
703 #[bench]
704 fn dst7_fft_32(b: &mut Bencher) {
705 bench_dst7_fft(b, 32);
706 }
707 #[bench]
708 fn dst7_fft_33(b: &mut Bencher) {
709 bench_dst7_fft(b, 33);
710 }
711 #[bench]
712 fn dst7_fft_34(b: &mut Bencher) {
713 bench_dst7_fft(b, 34);
714 }
715 #[bench]
716 fn dst7_fft_35(b: &mut Bencher) {
717 bench_dst7_fft(b, 35);
718 }
719 #[bench]
720 fn dst7_fft_36(b: &mut Bencher) {
721 bench_dst7_fft(b, 36);
722 }
723 #[bench]
724 fn dst7_fft_37(b: &mut Bencher) {
725 bench_dst7_fft(b, 37);
726 }
727 #[bench]
728 fn dst7_fft_38(b: &mut Bencher) {
729 bench_dst7_fft(b, 38);
730 }
731 #[bench]
732 fn dst7_fft_39(b: &mut Bencher) {
733 bench_dst7_fft(b, 39);
734 }