1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#![feature(test)]
extern crate rustfft;
extern crate test;
use paste::paste;
use rustfft::num_complex::Complex;
use rustfft::num_traits::Zero;
use rustfft::Fft;
use std::sync::Arc;
use test::Bencher;
// Make fft using scalar planner
fn bench_scalar_32(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerScalar::new();
let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f32>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f32>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Make fft using scalar planner
fn bench_scalar_64(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerScalar::new();
let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f64>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f64>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Make fft using sse planner
fn bench_sse_32(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerSse::new().unwrap();
let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f32>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f32>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Make fft using sse planner
fn bench_sse_64(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerSse::new().unwrap();
let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f64>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f64>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Make fft using sse planner
fn bench_avx_32(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerAvx::new().unwrap();
let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f32>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f32>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Make fft using sse planner
fn bench_avx_64(b: &mut Bencher, len: usize) {
let mut planner = rustfft::FftPlannerAvx::new().unwrap();
let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
let mut buffer: Vec<Complex<f64>> = vec![Complex::zero(); len];
let mut scratch: Vec<Complex<f64>> = vec![Complex::zero(); fft.get_inplace_scratch_len()];
b.iter(|| {
fft.process_with_scratch(&mut buffer, &mut scratch);
});
}
// Create benches using functions taking one argument
macro_rules! make_benches {
($name:ident, { $($len:literal),* }) => {
paste! {
$(
#[bench]
fn [<$name _ $len _f32_scalar>](b: &mut Bencher) {
[<bench_scalar_32>](b, $len);
}
#[bench]
fn [<$name _ $len _f64_scalar>](b: &mut Bencher) {
[<bench_scalar_64>](b, $len);
}
#[bench]
fn [<$name _ $len _f32_sse>](b: &mut Bencher) {
[<bench_sse_32>](b, $len);
}
#[bench]
fn [<$name _ $len _f64_sse>](b: &mut Bencher) {
[<bench_sse_64>](b, $len);
}
#[bench]
fn [<$name _ $len _f32_avx>](b: &mut Bencher) {
[<bench_avx_32>](b, $len);
}
#[bench]
fn [<$name _ $len _f64_avx>](b: &mut Bencher) {
[<bench_avx_64>](b, $len);
}
)*
}
}
}
make_benches!(comparison, {16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 });
make_benches!(comparison, {65536, 131072, 262144, 524288, 1048576, 2097152, 4194304 });
|
