Debian Codegraph @

.cargo/vendor/rustfft/benches/bench_rustfft_scalar.rs

raw
1 #![allow(bare_trait_objects)]
2 #![allow(non_snake_case)]
3 #![feature(test)]
4 extern crate rustfft;
5 extern crate test;
6
7 use rustfft::algorithm::butterflies::*;
8 use rustfft::algorithm::*;
9 use rustfft::num_complex::Complex;
10 use rustfft::num_traits::Zero;
11 use rustfft::FftPlannerScalar;
12 use rustfft::{Direction, Fft, FftDirection, FftNum, Length};
13 use std::sync::Arc;
14 use test::Bencher;
15
16 struct Noop {
17 len: usize,
18 direction: FftDirection,
19 }
20 impl<T: FftNum> Fft<T> for Noop {
21 fn process_with_scratch(&self, _buffer: &mut [Complex<T>], _scratch: &mut [Complex<T>]) {}
22 fn process_outofplace_with_scratch(
23 &self,
24 _input: &mut [Complex<T>],
25 _output: &mut [Complex<T>],
26 _scratch: &mut [Complex<T>],
27 ) {
28 }
29 fn get_inplace_scratch_len(&self) -> usize {
30 self.len
31 }
32 fn get_outofplace_scratch_len(&self) -> usize {
33 0
34 }
35 }
36 impl Length for Noop {
37 fn len(&self) -> usize {
38 self.len
39 }
40 }
41 impl Direction for Noop {
42 fn fft_direction(&self) -> FftDirection {
43 self.direction
44 }
45 }
46
47 /// Times just the FFT execution (not allocation and pre-calculation)
48 /// for a given length
49 fn bench_planned_f32(b: &mut Bencher, len: usize) {
50 let mut planner = rustfft::FftPlannerScalar::new();
51 let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
52 assert_eq!(fft.len(), len);
53
54 let mut buffer = vec![Complex::zero(); len];
55 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
56 b.iter(|| {
57 fft.process_with_scratch(&mut buffer, &mut scratch);
58 });
59 }
60
61 // Powers of 4
62 #[bench]
63 fn planned32_p2_00000064(b: &mut Bencher) {
64 bench_planned_f32(b, 64);
65 }
66 #[bench]
67 fn planned32_p2_00000128(b: &mut Bencher) {
68 bench_planned_f32(b, 128);
69 }
70 #[bench]
71 fn planned32_p2_00000256(b: &mut Bencher) {
72 bench_planned_f32(b, 256);
73 }
74 #[bench]
75 fn planned32_p2_00000512(b: &mut Bencher) {
76 bench_planned_f32(b, 512);
77 }
78 #[bench]
79 fn planned32_p2_00001024(b: &mut Bencher) {
80 bench_planned_f32(b, 1024);
81 }
82 #[bench]
83 fn planned32_p2_00002048(b: &mut Bencher) {
84 bench_planned_f32(b, 2048);
85 }
86 #[bench]
87 fn planned32_p2_00004096(b: &mut Bencher) {
88 bench_planned_f32(b, 4096);
89 }
90 #[bench]
91 fn planned32_p2_00016384(b: &mut Bencher) {
92 bench_planned_f32(b, 16384);
93 }
94 #[bench]
95 fn planned32_p2_00065536(b: &mut Bencher) {
96 bench_planned_f32(b, 65536);
97 }
98 #[bench]
99 fn planned32_p2_01048576(b: &mut Bencher) {
100 bench_planned_f32(b, 1048576);
101 }
102 //#[bench] fn planned32_p2_16777216(b: &mut Bencher) { bench_planned_f32(b, 16777216); }
103
104 // Powers of 5
105 //#[bench] fn planned32_p5_00125(b: &mut Bencher) { bench_planned_f32(b, 125); }
106 //#[bench] fn planned32_p5_00625(b: &mut Bencher) { bench_planned_f32(b, 625); }
107 //#[bench] fn planned32_p5_03125(b: &mut Bencher) { bench_planned_f32(b, 3125); }
108 //#[bench] fn planned32_p5_15625(b: &mut Bencher) { bench_planned_f32(b, 15625); }
109
110 // Powers of 7
111 //#[bench] fn planned32_p7_00343(b: &mut Bencher) { bench_planned_f32(b, 343); }
112 //#[bench] fn planned32_p7_02401(b: &mut Bencher) { bench_planned_f32(b, 2401); }
113 //#[bench] fn planned32_p7_16807(b: &mut Bencher) { bench_planned_f32(b, 16807); }
114
115 // Prime lengths
116 // Prime lengths
117 //#[bench] fn planned32_prime_0005(b: &mut Bencher) { bench_planned_f32(b, 5); }
118 //#[bench] fn planned32_prime_0017(b: &mut Bencher) { bench_planned_f32(b, 17); }
119 //#[bench] fn planned32_prime_0149(b: &mut Bencher) { bench_planned_f32(b, 149); }
120 //#[bench] fn planned32_prime_0151(b: &mut Bencher) { bench_planned_f32(b, 151); }
121 //#[bench] fn planned32_prime_0251(b: &mut Bencher) { bench_planned_f32(b, 251); }
122 //#[bench] fn planned32_prime_0257(b: &mut Bencher) { bench_planned_f32(b, 257); }
123 //#[bench] fn planned32_prime_1009(b: &mut Bencher) { bench_planned_f32(b, 1009); }
124 //#[bench] fn planned32_prime_1201(b: &mut Bencher) { bench_planned_f32(b, 1201); }
125 //#[bench] fn planned32_prime_2017(b: &mut Bencher) { bench_planned_f32(b, 2017); }
126 //#[bench] fn planned32_prime_2879(b: &mut Bencher) { bench_planned_f32(b, 2879); }
127 //#[bench] fn planned32_prime_32767(b: &mut Bencher) { bench_planned_f32(b, 32767); }
128 //#[bench] fn planned32_prime_65521(b: &mut Bencher) { bench_planned_f32(b, 65521); }
129 //#[bench] fn planned32_prime_65537(b: &mut Bencher) { bench_planned_f32(b, 65537); }
130 //#[bench] fn planned32_prime_746483(b: &mut Bencher) { bench_planned_f32(b,746483); }
131 //#[bench] fn planned32_prime_746497(b: &mut Bencher) { bench_planned_f32(b,746497); }
132
133 //primes raised to a power
134 //#[bench] fn planned32_primepower_044521(b: &mut Bencher) { bench_planned_f32(b, 44521); } // 211^2
135 //#[bench] fn planned32_primepower_160801(b: &mut Bencher) { bench_planned_f32(b, 160801); } // 401^2
136
137 // numbers times powers of two
138 //#[bench] fn planned32_composite_024576(b: &mut Bencher) { bench_planned_f32(b, 24576); }
139 //#[bench] fn planned32_composite_020736(b: &mut Bencher) { bench_planned_f32(b, 20736); }
140
141 // power of 2 times large prime
142 //#[bench] fn planned32_composite_032192(b: &mut Bencher) { bench_planned_f32(b, 32192); }
143 //#[bench] fn planned32_composite_024028(b: &mut Bencher) { bench_planned_f32(b, 24028); }
144
145 // small mixed composites times a large prime
146 //#[bench] fn planned32_composite_005472(b: &mut Bencher) { bench_planned_f32(b, 5472); }
147 //#[bench] fn planned32_composite_030270(b: &mut Bencher) { bench_planned_f32(b, 30270); }
148
149 // small mixed composites
150 //#[bench] fn planned32_composite_000018(b: &mut Bencher) { bench_planned_f32(b, 00018); }
151 //#[bench] fn planned32_composite_000360(b: &mut Bencher) { bench_planned_f32(b, 00360); }
152 //#[bench] fn planned32_composite_001200(b: &mut Bencher) { bench_planned_f32(b, 01200); }
153 //#[bench] fn planned32_composite_044100(b: &mut Bencher) { bench_planned_f32(b, 44100); }
154 //#[bench] fn planned32_composite_048000(b: &mut Bencher) { bench_planned_f32(b, 48000); }
155 //#[bench] fn planned32_composite_046656(b: &mut Bencher) { bench_planned_f32(b, 46656); }
156 //#[bench] fn planned32_composite_100000(b: &mut Bencher) { bench_planned_f32(b, 100000); }
157
158 /// Times just the FFT execution (not allocation and pre-calculation)
159 /// for a given length
160 fn bench_planned_f64(b: &mut Bencher, len: usize) {
161 let mut planner = rustfft::FftPlannerScalar::new();
162 let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
163
164 let mut buffer = vec![Complex::zero(); len];
165 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
166 b.iter(|| {
167 fft.process_with_scratch(&mut buffer, &mut scratch);
168 });
169 }
170
171 #[bench]
172 fn planned64_p2_00000064(b: &mut Bencher) {
173 bench_planned_f64(b, 64);
174 }
175 #[bench]
176 fn planned64_p2_00000128(b: &mut Bencher) {
177 bench_planned_f64(b, 128);
178 }
179 #[bench]
180 fn planned64_p2_00000256(b: &mut Bencher) {
181 bench_planned_f64(b, 256);
182 }
183 #[bench]
184 fn planned64_p2_00000512(b: &mut Bencher) {
185 bench_planned_f64(b, 512);
186 }
187 #[bench]
188 fn planned64_p2_00001024(b: &mut Bencher) {
189 bench_planned_f64(b, 1024);
190 }
191 #[bench]
192 fn planned64_p2_00002048(b: &mut Bencher) {
193 bench_planned_f64(b, 2048);
194 }
195 #[bench]
196 fn planned64_p2_00004096(b: &mut Bencher) {
197 bench_planned_f64(b, 4096);
198 }
199 #[bench]
200 fn planned64_p2_00016384(b: &mut Bencher) {
201 bench_planned_f64(b, 16384);
202 }
203 #[bench]
204 fn planned64_p2_00065536(b: &mut Bencher) {
205 bench_planned_f64(b, 65536);
206 }
207 #[bench]
208 fn planned64_p2_01048576(b: &mut Bencher) {
209 bench_planned_f64(b, 1048576);
210 }
211 //#[bench] fn planned64_p2_16777216(b: &mut Bencher) { bench_planned_f64(b, 16777216); }
212
213 // Powers of 5
214 //#[bench] fn planned64_p5_00125(b: &mut Bencher) { bench_planned_f64(b, 125); }
215 //#[bench] fn planned64_p5_00625(b: &mut Bencher) { bench_planned_f64(b, 625); }
216 //#[bench] fn planned64_p5_03125(b: &mut Bencher) { bench_planned_f64(b, 3125); }
217 //#[bench] fn planned64_p5_15625(b: &mut Bencher) { bench_planned_f64(b, 15625); }
218
219 //#[bench] fn planned64_p7_00343(b: &mut Bencher) { bench_planned_f64(b, 343); }
220 //#[bench] fn planned64_p7_02401(b: &mut Bencher) { bench_planned_f64(b, 2401); }
221 //#[bench] fn planned64_p7_16807(b: &mut Bencher) { bench_planned_f64(b, 16807); }
222
223 // Prime lengths
224 //#[bench] fn planned64_prime_0005(b: &mut Bencher) { bench_planned_f64(b, 5); }
225 //#[bench] fn planned64_prime_0017(b: &mut Bencher) { bench_planned_f64(b, 17); }
226 //#[bench] fn planned64_prime_0149(b: &mut Bencher) { bench_planned_f64(b, 149); }
227 //#[bench] fn planned64_prime_0151(b: &mut Bencher) { bench_planned_f64(b, 151); }
228 //#[bench] fn planned64_prime_0251(b: &mut Bencher) { bench_planned_f64(b, 251); }
229 //#[bench] fn planned64_prime_0257(b: &mut Bencher) { bench_planned_f64(b, 257); }
230 //#[bench] fn planned64_prime_1009(b: &mut Bencher) { bench_planned_f64(b, 1009); }
231 //#[bench] fn planned64_prime_2017(b: &mut Bencher) { bench_planned_f64(b, 2017); }
232 //#[bench] fn planned64_prime_2879(b: &mut Bencher) { bench_planned_f64(b, 2879); }
233 //#[bench] fn planned64_prime_32767(b: &mut Bencher) { bench_planned_f64(b, 32767); }
234 //#[bench] fn planned64_prime_65521(b: &mut Bencher) { bench_planned_f64(b, 65521); }
235 //#[bench] fn planned64_prime_65537(b: &mut Bencher) { bench_planned_f64(b, 65537); }
236 //#[bench] fn planned64_prime_746483(b: &mut Bencher) { bench_planned_f64(b,746483); }
237 //#[bench] fn planned64_prime_746497(b: &mut Bencher) { bench_planned_f64(b,746497); }
238
239 //primes raised to a power
240 //#[bench] fn planned64_primepower_044521(b: &mut Bencher) { bench_planned_f64(b, 44521); } // 211^2
241 //#[bench] fn planned64_primepower_160801(b: &mut Bencher) { bench_planned_f64(b, 160801); } // 401^2
242
243 // numbers times powers of two
244 //#[bench] fn planned64_composite_024576(b: &mut Bencher) { bench_planned_f64(b, 24576); }
245 //#[bench] fn planned64_composite_020736(b: &mut Bencher) { bench_planned_f64(b, 20736); }
246
247 // power of 2 times large prime
248 //#[bench] fn planned64_composite_032192(b: &mut Bencher) { bench_planned_f64(b, 32192); }
249 //#[bench] fn planned64_composite_024028(b: &mut Bencher) { bench_planned_f64(b, 24028); }
250
251 // small mixed composites times a large prime
252 //#[bench] fn planned64_composite_030270(b: &mut Bencher) { bench_planned_f64(b, 30270); }
253
254 // small mixed composites
255 //#[bench] fn planned64_composite_000018(b: &mut Bencher) { bench_planned_f64(b, 00018); }
256 //#[bench] fn planned64_composite_000360(b: &mut Bencher) { bench_planned_f64(b, 00360); }
257 //#[bench] fn planned64_composite_044100(b: &mut Bencher) { bench_planned_f64(b, 44100); }
258 //#[bench] fn planned64_composite_048000(b: &mut Bencher) { bench_planned_f64(b, 48000); }
259 //#[bench] fn planned64_composite_046656(b: &mut Bencher) { bench_planned_f64(b, 46656); }
260 //#[bench] fn planned64_composite_100000(b: &mut Bencher) { bench_planned_f64(b, 100000); }
261
262 /// Times just the FFT execution (not allocation and pre-calculation)
263 /// for a given length, specific to the Good-Thomas algorithm
264 fn bench_good_thomas(b: &mut Bencher, width: usize, height: usize) {
265 let mut planner = rustfft::FftPlannerScalar::new();
266 let width_fft = planner.plan_fft_forward(width);
267 let height_fft = planner.plan_fft_forward(height);
268
269 let fft: Arc<Fft<f32>> = Arc::new(GoodThomasAlgorithm::new(width_fft, height_fft));
270
271 let mut buffer = vec![Complex::zero(); width * height];
272 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
273 b.iter(|| {
274 fft.process_with_scratch(&mut buffer, &mut scratch);
275 });
276 }
277
278 #[bench]
279 fn good_thomas_0002_3(b: &mut Bencher) {
280 bench_good_thomas(b, 2, 3);
281 }
282 #[bench]
283 fn good_thomas_0003_4(b: &mut Bencher) {
284 bench_good_thomas(b, 3, 4);
285 }
286 #[bench]
287 fn good_thomas_0004_5(b: &mut Bencher) {
288 bench_good_thomas(b, 4, 5);
289 }
290 #[bench]
291 fn good_thomas_0007_32(b: &mut Bencher) {
292 bench_good_thomas(b, 7, 32);
293 }
294 #[bench]
295 fn good_thomas_0032_27(b: &mut Bencher) {
296 bench_good_thomas(b, 32, 27);
297 }
298 //#[bench] fn good_thomas_0256_243(b: &mut Bencher) { bench_good_thomas(b, 256, 243); }
299 //#[bench] fn good_thomas_2048_3(b: &mut Bencher) { bench_good_thomas(b, 2048, 3); }
300 //#[bench] fn good_thomas_2048_2187(b: &mut Bencher) { bench_good_thomas(b, 2048, 2187); }
301
302 /// Times just the FFT setup (not execution)
303 /// for a given length, specific to the Good-Thomas algorithm
304 fn bench_good_thomas_setup(b: &mut Bencher, width: usize, height: usize) {
305 let mut planner = rustfft::FftPlannerScalar::new();
306 let width_fft = planner.plan_fft_forward(width);
307 let height_fft = planner.plan_fft_forward(height);
308
309 b.iter(|| {
310 let fft: Arc<Fft<f32>> = Arc::new(GoodThomasAlgorithm::new(
311 Arc::clone(&width_fft),
312 Arc::clone(&height_fft),
313 ));
314 test::black_box(fft);
315 });
316 }
317
318 #[bench]
319 fn good_thomas_setup_0002_3(b: &mut Bencher) {
320 bench_good_thomas_setup(b, 2, 3);
321 }
322 #[bench]
323 fn good_thomas_setup_0003_4(b: &mut Bencher) {
324 bench_good_thomas_setup(b, 3, 4);
325 }
326 #[bench]
327 fn good_thomas_setup_0004_5(b: &mut Bencher) {
328 bench_good_thomas_setup(b, 4, 5);
329 }
330 #[bench]
331 fn good_thomas_setup_0007_32(b: &mut Bencher) {
332 bench_good_thomas_setup(b, 7, 32);
333 }
334 #[bench]
335 fn good_thomas_setup_0032_27(b: &mut Bencher) {
336 bench_good_thomas_setup(b, 32, 27);
337 }
338 #[bench]
339 fn good_thomas_setup_0256_243(b: &mut Bencher) {
340 bench_good_thomas_setup(b, 256, 243);
341 }
342 #[bench]
343 fn good_thomas_setup_2048_3(b: &mut Bencher) {
344 bench_good_thomas_setup(b, 2048, 3);
345 }
346 #[bench]
347 fn good_thomas_setup_2048_2187(b: &mut Bencher) {
348 bench_good_thomas_setup(b, 2048, 2187);
349 }
350
351 /// Times just the FFT execution (not allocation and pre-calculation)
352 /// for a given length, specific to the Mixed-Radix algorithm
353 fn bench_mixed_radix(b: &mut Bencher, width: usize, height: usize) {
354 let mut planner = rustfft::FftPlannerScalar::new();
355 let width_fft = planner.plan_fft_forward(width);
356 let height_fft = planner.plan_fft_forward(height);
357
358 let fft: Arc<Fft<_>> = Arc::new(MixedRadix::new(width_fft, height_fft));
359
360 let mut buffer = vec![
361 Complex {
362 re: 0_f32,
363 im: 0_f32
364 };
365 fft.len()
366 ];
367 let mut scratch = vec![
368 Complex {
369 re: 0_f32,
370 im: 0_f32
371 };
372 fft.get_inplace_scratch_len()
373 ];
374 b.iter(|| {
375 fft.process_with_scratch(&mut buffer, &mut scratch);
376 });
377 }
378
379 #[bench]
380 fn mixed_radix_0002_3(b: &mut Bencher) {
381 bench_mixed_radix(b, 2, 3);
382 }
383 #[bench]
384 fn mixed_radix_0003_4(b: &mut Bencher) {
385 bench_mixed_radix(b, 3, 4);
386 }
387 #[bench]
388 fn mixed_radix_0004_5(b: &mut Bencher) {
389 bench_mixed_radix(b, 4, 5);
390 }
391 #[bench]
392 fn mixed_radix_0007_32(b: &mut Bencher) {
393 bench_mixed_radix(b, 7, 32);
394 }
395 #[bench]
396 fn mixed_radix_0032_27(b: &mut Bencher) {
397 bench_mixed_radix(b, 32, 27);
398 }
399 //#[bench] fn mixed_radix_0256_243(b: &mut Bencher) { bench_mixed_radix(b, 256, 243); }
400 //#[bench] fn mixed_radix_2048_3(b: &mut Bencher) { bench_mixed_radix(b, 2048, 3); }
401 //#[bench] fn mixed_radix_2048_2187(b: &mut Bencher) { bench_mixed_radix(b, 2048, 2187); }
402
403 fn plan_butterfly_fft(len: usize) -> Arc<Fft<f32>> {
404 match len {
405 2 => Arc::new(Butterfly2::new(FftDirection::Forward)),
406 3 => Arc::new(Butterfly3::new(FftDirection::Forward)),
407 4 => Arc::new(Butterfly4::new(FftDirection::Forward)),
408 5 => Arc::new(Butterfly5::new(FftDirection::Forward)),
409 6 => Arc::new(Butterfly6::new(FftDirection::Forward)),
410 7 => Arc::new(Butterfly7::new(FftDirection::Forward)),
411 8 => Arc::new(Butterfly8::new(FftDirection::Forward)),
412 16 => Arc::new(Butterfly16::new(FftDirection::Forward)),
413 32 => Arc::new(Butterfly32::new(FftDirection::Forward)),
414 _ => panic!("Invalid butterfly size: {}", len),
415 }
416 }
417
418 /// Times just the FFT execution (not allocation and pre-calculation)
419 /// for a given length, specific to the MixedRadixSmall algorithm
420 fn bench_mixed_radix_small(b: &mut Bencher, width: usize, height: usize) {
421 let width_fft = plan_butterfly_fft(width);
422 let height_fft = plan_butterfly_fft(height);
423
424 let fft: Arc<Fft<_>> = Arc::new(MixedRadixSmall::new(width_fft, height_fft));
425
426 let mut signal = vec![
427 Complex {
428 re: 0_f32,
429 im: 0_f32
430 };
431 width * height
432 ];
433 let mut spectrum = signal.clone();
434 b.iter(|| {
435 fft.process_with_scratch(&mut signal, &mut spectrum);
436 });
437 }
438
439 #[bench]
440 fn mixed_radix_small_0002_3(b: &mut Bencher) {
441 bench_mixed_radix_small(b, 2, 3);
442 }
443 #[bench]
444 fn mixed_radix_small_0003_4(b: &mut Bencher) {
445 bench_mixed_radix_small(b, 3, 4);
446 }
447 #[bench]
448 fn mixed_radix_small_0004_5(b: &mut Bencher) {
449 bench_mixed_radix_small(b, 4, 5);
450 }
451 #[bench]
452 fn mixed_radix_small_0007_32(b: &mut Bencher) {
453 bench_mixed_radix_small(b, 7, 32);
454 }
455
456 /// Times just the FFT execution (not allocation and pre-calculation)
457 /// for a given length, specific to the Mixed-Radix Double Butterfly algorithm
458 fn bench_good_thomas_small(b: &mut Bencher, width: usize, height: usize) {
459 let width_fft = plan_butterfly_fft(width);
460 let height_fft = plan_butterfly_fft(height);
461
462 let fft: Arc<Fft<_>> = Arc::new(GoodThomasAlgorithmSmall::new(width_fft, height_fft));
463
464 let mut signal = vec![
465 Complex {
466 re: 0_f32,
467 im: 0_f32
468 };
469 width * height
470 ];
471 let mut spectrum = signal.clone();
472 b.iter(|| {
473 fft.process_with_scratch(&mut signal, &mut spectrum);
474 });
475 }
476
477 #[bench]
478 fn good_thomas_small_0002_3(b: &mut Bencher) {
479 bench_good_thomas_small(b, 2, 3);
480 }
481 #[bench]
482 fn good_thomas_small_0003_4(b: &mut Bencher) {
483 bench_good_thomas_small(b, 3, 4);
484 }
485 #[bench]
486 fn good_thomas_small_0004_5(b: &mut Bencher) {
487 bench_good_thomas_small(b, 4, 5);
488 }
489 #[bench]
490 fn good_thomas_small_0007_32(b: &mut Bencher) {
491 bench_good_thomas_small(b, 7, 32);
492 }
493
494 /// Times just the FFT execution (not allocation and pre-calculation)
495 /// for a given length, specific to Rader's algorithm
496 #[allow(dead_code)]
497 fn bench_raders_scalar(b: &mut Bencher, len: usize) {
498 let mut planner = rustfft::FftPlannerScalar::new();
499 let inner_fft = planner.plan_fft_forward(len - 1);
500
501 let fft: Arc<Fft<_>> = Arc::new(RadersAlgorithm::new(inner_fft));
502
503 let mut buffer = vec![
504 Complex {
505 re: 0_f32,
506 im: 0_f32
507 };
508 len
509 ];
510 let mut scratch = vec![
511 Complex {
512 re: 0_f32,
513 im: 0_f32
514 };
515 fft.get_inplace_scratch_len()
516 ];
517 b.iter(|| {
518 fft.process_with_scratch(&mut buffer, &mut scratch);
519 });
520 }
521
522 //#[bench] fn raders_fft_scalar_prime_0005(b: &mut Bencher) { bench_raders_scalar(b, 5); }
523 //#[bench] fn raders_fft_scalar_prime_0017(b: &mut Bencher) { bench_raders_scalar(b, 17); }
524 //#[bench] fn raders_fft_scalar_prime_0149(b: &mut Bencher) { bench_raders_scalar(b, 149); }
525 //#[bench] fn raders_fft_scalar_prime_0151(b: &mut Bencher) { bench_raders_scalar(b, 151); }
526 //#[bench] fn raders_fft_scalar_prime_0251(b: &mut Bencher) { bench_raders_scalar(b, 251); }
527 //#[bench] fn raders_fft_scalar_prime_0257(b: &mut Bencher) { bench_raders_scalar(b, 257); }
528 //#[bench] fn raders_fft_scalar_prime_1009(b: &mut Bencher) { bench_raders_scalar(b, 1009); }
529 //#[bench] fn raders_fft_scalar_prime_2017(b: &mut Bencher) { bench_raders_scalar(b, 2017); }
530 //#[bench] fn raders_fft_scalar_prime_12289(b: &mut Bencher) { bench_raders_scalar(b, 12289); }
531 //#[bench] fn raders_fft_scalar_prime_18433(b: &mut Bencher) { bench_raders_scalar(b, 18433); }
532 //#[bench] fn raders_fft_scalar_prime_65521(b: &mut Bencher) { bench_raders_scalar(b, 65521); }
533 //#[bench] fn raders_fft_scalar_prime_65537(b: &mut Bencher) { bench_raders_scalar(b, 65537); }
534 //#[bench] fn raders_fft_scalar_prime_746483(b: &mut Bencher) { bench_raders_scalar(b,746483); }
535 //#[bench] fn raders_fft_scalar_prime_746497(b: &mut Bencher) { bench_raders_scalar(b,746497); }
536
537 /// Times just the FFT execution (not allocation and pre-calculation)
538 /// for a given length, specific to Bluestein's Algorithm
539 #[allow(dead_code)]
540 fn bench_bluesteins_scalar_prime(b: &mut Bencher, len: usize) {
541 let mut planner = rustfft::FftPlannerScalar::new();
542 let inner_fft = planner.plan_fft_forward((len * 2 - 1).checked_next_power_of_two().unwrap());
543 let fft: Arc<Fft<f32>> = Arc::new(BluesteinsAlgorithm::new(len, inner_fft));
544
545 let mut buffer = vec![Zero::zero(); len];
546 let mut scratch = vec![Zero::zero(); fft.get_inplace_scratch_len()];
547 b.iter(|| {
548 fft.process_with_scratch(&mut buffer, &mut scratch);
549 });
550 }
551
552 //#[bench] fn bench_bluesteins_scalar_prime_0005(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 5); }
553 //#[bench] fn bench_bluesteins_scalar_prime_0017(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 17); }
554 //#[bench] fn bench_bluesteins_scalar_prime_0149(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 149); }
555 //#[bench] fn bench_bluesteins_scalar_prime_0151(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 151); }
556 //#[bench] fn bench_bluesteins_scalar_prime_0251(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 251); }
557 //#[bench] fn bench_bluesteins_scalar_prime_0257(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 257); }
558 //#[bench] fn bench_bluesteins_scalar_prime_1009(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 1009); }
559 //#[bench] fn bench_bluesteins_scalar_prime_2017(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 2017); }
560 //#[bench] fn bench_bluesteins_scalar_prime_32767(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 32767); }
561 //#[bench] fn bench_bluesteins_scalar_prime_65521(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 65521); }
562 //#[bench] fn bench_bluesteins_scalar_prime_65537(b: &mut Bencher) { bench_bluesteins_scalar_prime(b, 65537); }
563 //#[bench] fn bench_bluesteins_scalar_prime_746483(b: &mut Bencher) { bench_bluesteins_scalar_prime(b,746483); }
564 //#[bench] fn bench_bluesteins_scalar_prime_746497(b: &mut Bencher) { bench_bluesteins_scalar_prime(b,746497); }
565
566 /// Times just the FFT execution (not allocation and pre-calculation)
567 /// for a given length, specific to Rader's algorithm
568 fn bench_radix4(b: &mut Bencher, len: usize) {
569 assert!(len % 4 == 0);
570
571 let fft = Radix4::new(len, FftDirection::Forward);
572
573 let mut signal = vec![
574 Complex {
575 re: 0_f32,
576 im: 0_f32
577 };
578 len
579 ];
580 let mut spectrum = signal.clone();
581 b.iter(|| {
582 fft.process_outofplace_with_scratch(&mut signal, &mut spectrum, &mut []);
583 });
584 }
585
586 #[bench]
587 fn radix4_______64(b: &mut Bencher) {
588 bench_radix4(b, 64);
589 }
590 #[bench]
591 fn radix4______256(b: &mut Bencher) {
592 bench_radix4(b, 256);
593 }
594 #[bench]
595 fn radix4_____1024(b: &mut Bencher) {
596 bench_radix4(b, 1024);
597 }
598 #[bench]
599 fn radix4____65536(b: &mut Bencher) {
600 bench_radix4(b, 65536);
601 }
602 //#[bench] fn radix4__1048576(b: &mut Bencher) { bench_radix4(b, 1048576); }
603 //#[bench] fn radix4_16777216(b: &mut Bencher) { bench_radix4(b, 16777216); }
604
605 /// Times just the FFT execution (not allocation and pre-calculation)
606 /// for a given length, specific to Rader's algorithm
607 fn bench_64_radix4(b: &mut Bencher, len: usize) {
608 assert!(len % 4 == 0);
609
610 let fft = Radix4::new(len, FftDirection::Forward);
611
612 let mut signal = vec![
613 Complex {
614 re: 0_f64,
615 im: 0_f64
616 };
617 len
618 ];
619 let mut spectrum = signal.clone();
620 b.iter(|| {
621 fft.process_outofplace_with_scratch(&mut signal, &mut spectrum, &mut []);
622 });
623 }
624
625 #[bench]
626 fn radix4_64____64(b: &mut Bencher) {
627 bench_64_radix4(b, 64);
628 }
629 #[bench]
630 fn radix4_64___256(b: &mut Bencher) {
631 bench_64_radix4(b, 256);
632 }
633 #[bench]
634 fn radix4_64__1024(b: &mut Bencher) {
635 bench_64_radix4(b, 1024);
636 }
637 #[bench]
638 fn radix4_64_65536(b: &mut Bencher) {
639 bench_64_radix4(b, 65536);
640 }
641 //#[bench] fn radix4__1048576(b: &mut Bencher) { bench_radix4(b, 1048576); }
642 //#[bench] fn radix4_16777216(b: &mut Bencher) { bench_radix4(b, 16777216); }
643
644 fn get_mixed_radix_power2(len: usize) -> Arc<dyn Fft<f32>> {
645 match len {
646 8 => Arc::new(Butterfly8::new(FftDirection::Forward)),
647 16 => Arc::new(Butterfly16::new(FftDirection::Forward)),
648 32 => Arc::new(Butterfly32::new(FftDirection::Forward)),
649 _ => {
650 let zeroes = len.trailing_zeros();
651 assert!(zeroes % 2 == 0);
652 let half_zeroes = zeroes / 2;
653 let inner = get_mixed_radix_power2(1 << half_zeroes);
654 Arc::new(MixedRadix::new(Arc::clone(&inner), inner))
655 }
656 }
657 }
658
659 /// Times just the FFT execution (not allocation and pre-calculation)
660 /// for a given length, specific to Rader's algorithm
661 fn bench_mixed_radix_power2(b: &mut Bencher, len: usize) {
662 let fft = get_mixed_radix_power2(len);
663
664 let mut buffer = vec![Zero::zero(); len];
665 let mut scratch = vec![Zero::zero(); fft.get_inplace_scratch_len()];
666 b.iter(|| {
667 fft.process_with_scratch(&mut buffer, &mut scratch);
668 });
669 }
670
671 #[bench]
672 fn mixed_radix_power2__00000256(b: &mut Bencher) {
673 bench_mixed_radix_power2(b, 256);
674 }
675 #[bench]
676 fn mixed_radix_power2__00001024(b: &mut Bencher) {
677 bench_mixed_radix_power2(b, 1024);
678 }
679 #[bench]
680 fn mixed_radix_power2__00004096(b: &mut Bencher) {
681 bench_mixed_radix_power2(b, 4096);
682 }
683 #[bench]
684 fn mixed_radix_power2__00065536(b: &mut Bencher) {
685 bench_mixed_radix_power2(b, 65536);
686 }
687 //#[bench] fn mixed_radix_power2__01048576(b: &mut Bencher) { bench_mixed_radix_power2(b, 1048576); }
688 //#[bench] fn mixed_radix_power2__16777216(b: &mut Bencher) { bench_mixed_radix_power2(b, 16777216); }
689
690 fn get_mixed_radix_inline_power2(len: usize) -> Arc<dyn Fft<f32>> {
691 match len {
692 8 => Arc::new(Butterfly8::new(FftDirection::Forward)),
693 16 => Arc::new(Butterfly16::new(FftDirection::Forward)),
694 32 => Arc::new(Butterfly32::new(FftDirection::Forward)),
695 _ => {
696 let zeroes = len.trailing_zeros();
697 assert!(zeroes % 2 == 0);
698 let half_zeroes = zeroes / 2;
699 let inner = get_mixed_radix_inline_power2(1 << half_zeroes);
700 Arc::new(MixedRadix::new(Arc::clone(&inner), inner))
701 }
702 }
703 }
704
705 /// Times just the FFT execution (not allocation and pre-calculation)
706 /// for a given length, specific to Rader's algorithm
707 fn bench_mixed_radix_inline_power2(b: &mut Bencher, len: usize) {
708 let fft = get_mixed_radix_inline_power2(len);
709
710 let mut buffer = vec![Zero::zero(); len];
711 let mut scratch = vec![Zero::zero(); fft.get_inplace_scratch_len()];
712 b.iter(|| {
713 fft.process_with_scratch(&mut buffer, &mut scratch);
714 });
715 }
716
717 #[bench]
718 fn mixed_radix_power2_inline__00000256(b: &mut Bencher) {
719 bench_mixed_radix_inline_power2(b, 256);
720 }
721 #[bench]
722 fn mixed_radix_power2_inline__00001024(b: &mut Bencher) {
723 bench_mixed_radix_inline_power2(b, 1024);
724 }
725 #[bench]
726 fn mixed_radix_power2_inline__00004096(b: &mut Bencher) {
727 bench_mixed_radix_inline_power2(b, 4096);
728 }
729 #[bench]
730 fn mixed_radix_power2_inline__00065536(b: &mut Bencher) {
731 bench_mixed_radix_inline_power2(b, 65536);
732 }
733 //#[bench] fn mixed_radix_power2_inline__01048576(b: &mut Bencher) { bench_mixed_radix_inline_power2(b, 1048576); }
734 //#[bench] fn mixed_radix_power2_inline__16777216(b: &mut Bencher) { bench_mixed_radix_inline_power2(b, 16777216); }
735
736 /// Times just the FFT execution (not allocation and pre-calculation)
737 /// for a given length
738 fn bench_butterfly32(b: &mut Bencher, len: usize) {
739 let mut planner = rustfft::FftPlannerScalar::new();
740 let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
741
742 let mut buffer = vec![Complex::zero(); len * 10];
743 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
744 b.iter(|| {
745 fft.process_with_scratch(&mut buffer, &mut scratch);
746 });
747 }
748
749 #[bench]
750 fn butterfly32_02(b: &mut Bencher) {
751 bench_butterfly32(b, 2);
752 }
753 #[bench]
754 fn butterfly32_03(b: &mut Bencher) {
755 bench_butterfly32(b, 3);
756 }
757 #[bench]
758 fn butterfly32_04(b: &mut Bencher) {
759 bench_butterfly32(b, 4);
760 }
761 #[bench]
762 fn butterfly32_05(b: &mut Bencher) {
763 bench_butterfly32(b, 5);
764 }
765 #[bench]
766 fn butterfly32_06(b: &mut Bencher) {
767 bench_butterfly32(b, 6);
768 }
769 #[bench]
770 fn butterfly32_07(b: &mut Bencher) {
771 bench_butterfly32(b, 7);
772 }
773 #[bench]
774 fn butterfly32_08(b: &mut Bencher) {
775 bench_butterfly32(b, 8);
776 }
777 #[bench]
778 fn butterfly32_09(b: &mut Bencher) {
779 bench_butterfly32(b, 9);
780 }
781 #[bench]
782 fn butterfly32_11(b: &mut Bencher) {
783 bench_butterfly32(b, 11);
784 }
785 #[bench]
786 fn butterfly32_12(b: &mut Bencher) {
787 bench_butterfly32(b, 12);
788 }
789 #[bench]
790 fn butterfly32_16(b: &mut Bencher) {
791 bench_butterfly32(b, 16);
792 }
793 //#[bench] fn butterfly32_24(b: &mut Bencher) { bench_butterfly32(b, 24); }
794 //#[bench] fn butterfly32_27(b: &mut Bencher) { bench_butterfly32(b, 27); }
795 //#[bench] fn butterfly32_32(b: &mut Bencher) { bench_butterfly32(b, 32); }
796 //#[bench] fn butterfly32_36(b: &mut Bencher) { bench_butterfly32(b, 36); }
797 //#[bench] fn butterfly32_48(b: &mut Bencher) { bench_butterfly32(b, 48); }
798 //#[bench] fn butterfly32_54(b: &mut Bencher) { bench_butterfly32(b, 54); }
799 //#[bench] fn butterfly32_64(b: &mut Bencher) { bench_butterfly32(b, 64); }
800 //#[bench] fn butterfly32_72(b: &mut Bencher) { bench_butterfly32(b, 72); }
801 //#[bench] fn butterfly32_128(b: &mut Bencher) { bench_butterfly32(b, 128); }
802 //#[bench] fn butterfly32_256(b: &mut Bencher) { bench_butterfly32(b, 256); }
803 //#[bench] fn butterfly32_512(b: &mut Bencher) { bench_butterfly32(b, 512); }
804
805 /// Times just the FFT execution (not allocation and pre-calculation)
806 /// for a given length
807 fn bench_butterfly64(b: &mut Bencher, len: usize) {
808 let mut planner = rustfft::FftPlannerScalar::new();
809 let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
810
811 let mut buffer = vec![Complex::zero(); len * 10];
812 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
813 b.iter(|| {
814 fft.process_with_scratch(&mut buffer, &mut scratch);
815 });
816 }
817
818 #[bench]
819 fn butterfly64_02(b: &mut Bencher) {
820 bench_butterfly64(b, 2);
821 }
822 #[bench]
823 fn butterfly64_03(b: &mut Bencher) {
824 bench_butterfly64(b, 3);
825 }
826 #[bench]
827 fn butterfly64_04(b: &mut Bencher) {
828 bench_butterfly64(b, 4);
829 }
830 #[bench]
831 fn butterfly64_05(b: &mut Bencher) {
832 bench_butterfly64(b, 5);
833 }
834 #[bench]
835 fn butterfly64_06(b: &mut Bencher) {
836 bench_butterfly64(b, 6);
837 }
838 #[bench]
839 fn butterfly64_07(b: &mut Bencher) {
840 bench_butterfly64(b, 7);
841 }
842 #[bench]
843 fn butterfly64_08(b: &mut Bencher) {
844 bench_butterfly64(b, 8);
845 }
846 #[bench]
847 fn butterfly64_09(b: &mut Bencher) {
848 bench_butterfly64(b, 9);
849 }
850 #[bench]
851 fn butterfly64_11(b: &mut Bencher) {
852 bench_butterfly64(b, 11);
853 }
854 #[bench]
855 fn butterfly64_12(b: &mut Bencher) {
856 bench_butterfly64(b, 12);
857 }
858 #[bench]
859 fn butterfly64_16(b: &mut Bencher) {
860 bench_butterfly64(b, 16);
861 }
862 //#[bench] fn butterfly64_18(b: &mut Bencher) { bench_butterfly64(b, 18); }
863 //#[bench] fn butterfly64_24(b: &mut Bencher) { bench_butterfly64(b, 24); }
864 //#[bench] fn butterfly64_27(b: &mut Bencher) { bench_butterfly64(b, 27); }
865 //#[bench] fn butterfly64_32(b: &mut Bencher) { bench_butterfly64(b, 32); }
866 //#[bench] fn butterfly64_36(b: &mut Bencher) { bench_butterfly64(b, 36); }
867 //#[bench] fn butterfly64_64(b: &mut Bencher) { bench_butterfly64(b, 64); }
868 //#[bench] fn butterfly64_128(b: &mut Bencher) { bench_butterfly64(b, 128); }
869 //#[bench] fn butterfly64_256(b: &mut Bencher) { bench_butterfly64(b, 256); }
870 //#[bench] fn butterfly64_512(b: &mut Bencher) { bench_butterfly64(b, 512); }
871
872 fn bench_bluesteins_setup(b: &mut Bencher, len: usize) {
873 let inner_len = (len * 2 - 1).next_power_of_two();
874 let inner_fft = FftPlannerScalar::<f32>::new().plan_fft_forward(inner_len);
875
876 b.iter(|| {
877 test::black_box(BluesteinsAlgorithm::new(len, Arc::clone(&inner_fft)));
878 });
879 }
880
881 #[bench]
882 fn setup_bluesteins_0017(b: &mut Bencher) {
883 bench_bluesteins_setup(b, 17);
884 }
885 #[bench]
886 fn setup_bluesteins_0055(b: &mut Bencher) {
887 bench_bluesteins_setup(b, 55);
888 }
889 #[bench]
890 fn setup_bluesteins_0117(b: &mut Bencher) {
891 bench_bluesteins_setup(b, 117);
892 }
893 #[bench]
894 fn setup_bluesteins_0555(b: &mut Bencher) {
895 bench_bluesteins_setup(b, 555);
896 }
897 #[bench]
898 fn setup_bluesteins_1117(b: &mut Bencher) {
899 bench_bluesteins_setup(b, 1117);
900 }
901 #[bench]
902 fn setup_bluesteins_5555(b: &mut Bencher) {
903 bench_bluesteins_setup(b, 5555);
904 }