Debian Codegraph @

.cargo/vendor/rustfft/benches/bench_rustfft_wasm_simd.rs

raw
1 #![feature(test)]
2 /// Unfortunately, `cargo bench` does not permit running these benchmarks out-of-the-box
3 /// on a WebAssembly virtual machine.
4 ///
5 /// Follow these steps to run these benchmarks:
6 /// 0. Prerequisites: Install the `wasm32-wasi` target and `wasmer`
7 ///
8 ///
9 /// 1. Build these benchmarks
10 /// ```bash
11 /// cargo build --bench=bench_rustfft_wasm_simd --release --target wasm32-wasi --features "wasm_simd"
12 /// ```
13 ///
14 /// After cargo built the bench binary, cargo stores it inside the
15 /// `<PROJECT_ROOT>/target/wasm32-wasi/release/deps` directory.
16 /// The file name of this binary follows this format: `bench_rustfft_wasm_simd-<CHECKSUM>.wasm`.
17 /// For instance, it could be named
18 /// `target/wasm32-wasi/release/deps/bench_rustfft_scalar-6d2b3d5a567416f5.wasm`
19 ///
20 /// 2. Copy the most recently built WASM binary to hex.wasm
21 /// ```bash
22 /// cp `ls -t target/wasm32-wasi/release/deps/*.wasm | head -n 1` hex.wasm
23 /// ```
24 ///
25 /// 3. Run these benchmark e. g. with [wasmer](https://github.com/wasmerio/wasmer)
26 /// ```bash
27 /// wasmer run --dir=. hex.wasm -- --bench
28 /// ```
29 ///
30 /// For more information, refer to [Criterion's user guide](https://github.com/bheisler/criterion.rs/blob/dc2b06cd31f7aa34cff6a83a00598e0523186dad/book/src/user_guide/wasi.md)
31 /// which should be mostly applicable to our use case.
32 extern crate rustfft;
33 extern crate test;
34
35 use rustfft::num_complex::Complex;
36 use rustfft::num_traits::Zero;
37 use rustfft::Fft;
38 use std::sync::Arc;
39 use test::Bencher;
40
41 /// Times just the FFT execution (not allocation and pre-calculation)
42 /// for a given length
43 fn bench_planned_f32(b: &mut Bencher, len: usize) {
44 let mut planner = rustfft::FftPlannerWasmSimd::new().unwrap();
45 let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
46 assert_eq!(fft.len(), len);
47
48 let mut buffer = vec![Complex::zero(); len];
49 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
50 b.iter(|| {
51 fft.process_with_scratch(&mut buffer, &mut scratch);
52 });
53 }
54 fn bench_planned_f64(b: &mut Bencher, len: usize) {
55 let mut planner = rustfft::FftPlannerWasmSimd::new().unwrap();
56 let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
57 assert_eq!(fft.len(), len);
58
59 let mut buffer = vec![Complex::zero(); len];
60 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
61 b.iter(|| {
62 fft.process_with_scratch(&mut buffer, &mut scratch);
63 });
64 }
65
66 /// Times just the FFT execution (not allocation and pre-calculation)
67 /// for a given length.
68 /// Run the fft on a 10*len vector, similar to how the butterflies are often used.
69 fn bench_planned_multi_f32(b: &mut Bencher, len: usize) {
70 let mut planner = rustfft::FftPlannerWasmSimd::new().unwrap();
71 let fft: Arc<dyn Fft<f32>> = planner.plan_fft_forward(len);
72
73 let mut buffer = vec![Complex::zero(); len * 10];
74 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
75 b.iter(|| {
76 fft.process_with_scratch(&mut buffer, &mut scratch);
77 });
78 }
79 fn bench_planned_multi_f64(b: &mut Bencher, len: usize) {
80 let mut planner = rustfft::FftPlannerWasmSimd::new().unwrap();
81 let fft: Arc<dyn Fft<f64>> = planner.plan_fft_forward(len);
82
83 let mut buffer = vec![Complex::zero(); len * 10];
84 let mut scratch = vec![Complex::zero(); fft.get_inplace_scratch_len()];
85 b.iter(|| {
86 fft.process_with_scratch(&mut buffer, &mut scratch);
87 });
88 }
89
90 // All butterflies
91 #[bench]
92 fn wasm_simd_butterfly32_02(b: &mut Bencher) {
93 bench_planned_multi_f32(b, 2);
94 }
95 #[bench]
96 fn wasm_simd_butterfly32_03(b: &mut Bencher) {
97 bench_planned_multi_f32(b, 3);
98 }
99 #[bench]
100 fn wasm_simd_butterfly32_04(b: &mut Bencher) {
101 bench_planned_multi_f32(b, 4);
102 }
103 #[bench]
104 fn wasm_simd_butterfly32_05(b: &mut Bencher) {
105 bench_planned_multi_f32(b, 5);
106 }
107 #[bench]
108 fn wasm_simd_butterfly32_06(b: &mut Bencher) {
109 bench_planned_multi_f32(b, 6);
110 }
111 #[bench]
112 fn wasm_simd_butterfly32_07(b: &mut Bencher) {
113 bench_planned_multi_f32(b, 7);
114 }
115 #[bench]
116 fn wasm_simd_butterfly32_08(b: &mut Bencher) {
117 bench_planned_multi_f32(b, 8);
118 }
119 #[bench]
120 fn wasm_simd_butterfly32_09(b: &mut Bencher) {
121 bench_planned_multi_f32(b, 9);
122 }
123 #[bench]
124 fn wasm_simd_butterfly32_10(b: &mut Bencher) {
125 bench_planned_multi_f32(b, 10);
126 }
127 #[bench]
128 fn wasm_simd_butterfly32_11(b: &mut Bencher) {
129 bench_planned_multi_f32(b, 11);
130 }
131 #[bench]
132 fn wasm_simd_butterfly32_12(b: &mut Bencher) {
133 bench_planned_multi_f32(b, 12);
134 }
135 #[bench]
136 fn wasm_simd_butterfly32_13(b: &mut Bencher) {
137 bench_planned_multi_f32(b, 13);
138 }
139 #[bench]
140 fn wasm_simd_butterfly32_15(b: &mut Bencher) {
141 bench_planned_multi_f32(b, 15);
142 }
143 #[bench]
144 fn wasm_simd_butterfly32_16(b: &mut Bencher) {
145 bench_planned_multi_f32(b, 16);
146 }
147 #[bench]
148 fn wasm_simd_butterfly32_17(b: &mut Bencher) {
149 bench_planned_multi_f32(b, 17);
150 }
151 #[bench]
152 fn wasm_simd_butterfly32_19(b: &mut Bencher) {
153 bench_planned_multi_f32(b, 19);
154 }
155 #[bench]
156 fn wasm_simd_butterfly32_23(b: &mut Bencher) {
157 bench_planned_multi_f32(b, 23);
158 }
159 #[bench]
160 fn wasm_simd_butterfly32_29(b: &mut Bencher) {
161 bench_planned_multi_f32(b, 29);
162 }
163 #[bench]
164 fn wasm_simd_butterfly32_31(b: &mut Bencher) {
165 bench_planned_multi_f32(b, 31);
166 }
167 #[bench]
168 fn wasm_simd_butterfly32_32(b: &mut Bencher) {
169 bench_planned_multi_f32(b, 32);
170 }
171
172 #[bench]
173 fn wasm_simd_butterfly64_02(b: &mut Bencher) {
174 bench_planned_multi_f64(b, 2);
175 }
176 #[bench]
177 fn wasm_simd_butterfly64_03(b: &mut Bencher) {
178 bench_planned_multi_f64(b, 3);
179 }
180 #[bench]
181 fn wasm_simd_butterfly64_04(b: &mut Bencher) {
182 bench_planned_multi_f64(b, 4);
183 }
184 #[bench]
185 fn wasm_simd_butterfly64_05(b: &mut Bencher) {
186 bench_planned_multi_f64(b, 5);
187 }
188 #[bench]
189 fn wasm_simd_butterfly64_06(b: &mut Bencher) {
190 bench_planned_multi_f64(b, 6);
191 }
192 #[bench]
193 fn wasm_simd_butterfly64_07(b: &mut Bencher) {
194 bench_planned_multi_f64(b, 7);
195 }
196 #[bench]
197 fn wasm_simd_butterfly64_08(b: &mut Bencher) {
198 bench_planned_multi_f64(b, 8);
199 }
200 #[bench]
201 fn wasm_simd_butterfly64_09(b: &mut Bencher) {
202 bench_planned_multi_f64(b, 9);
203 }
204 #[bench]
205 fn wasm_simd_butterfly64_10(b: &mut Bencher) {
206 bench_planned_multi_f64(b, 10);
207 }
208 #[bench]
209 fn wasm_simd_butterfly64_11(b: &mut Bencher) {
210 bench_planned_multi_f64(b, 11);
211 }
212 #[bench]
213 fn wasm_simd_butterfly64_12(b: &mut Bencher) {
214 bench_planned_multi_f64(b, 12);
215 }
216 #[bench]
217 fn wasm_simd_butterfly64_13(b: &mut Bencher) {
218 bench_planned_multi_f64(b, 13);
219 }
220 #[bench]
221 fn wasm_simd_butterfly64_15(b: &mut Bencher) {
222 bench_planned_multi_f64(b, 15);
223 }
224 #[bench]
225 fn wasm_simd_butterfly64_16(b: &mut Bencher) {
226 bench_planned_multi_f64(b, 16);
227 }
228 #[bench]
229 fn wasm_simd_butterfly64_17(b: &mut Bencher) {
230 bench_planned_multi_f64(b, 17);
231 }
232 #[bench]
233 fn wasm_simd_butterfly64_19(b: &mut Bencher) {
234 bench_planned_multi_f64(b, 19);
235 }
236 #[bench]
237 fn wasm_simd_butterfly64_23(b: &mut Bencher) {
238 bench_planned_multi_f64(b, 23);
239 }
240 #[bench]
241 fn wasm_simd_butterfly64_29(b: &mut Bencher) {
242 bench_planned_multi_f64(b, 29);
243 }
244 #[bench]
245 fn wasm_simd_butterfly64_31(b: &mut Bencher) {
246 bench_planned_multi_f64(b, 31);
247 }
248 #[bench]
249 fn wasm_simd_butterfly64_32(b: &mut Bencher) {
250 bench_planned_multi_f64(b, 32);
251 }
252
253 // Powers of 2
254 #[bench]
255 fn wasm_simd_planned32_p2_00000064(b: &mut Bencher) {
256 bench_planned_f32(b, 64);
257 }
258 #[bench]
259 fn wasm_simd_planned32_p2_00000128(b: &mut Bencher) {
260 bench_planned_f32(b, 128);
261 }
262 #[bench]
263 fn wasm_simd_planned32_p2_00000256(b: &mut Bencher) {
264 bench_planned_f32(b, 256);
265 }
266 #[bench]
267 fn wasm_simd_planned32_p2_00000512(b: &mut Bencher) {
268 bench_planned_f32(b, 512);
269 }
270 #[bench]
271 fn wasm_simd_planned32_p2_00001024(b: &mut Bencher) {
272 bench_planned_f32(b, 1024);
273 }
274 #[bench]
275 fn wasm_simd_planned32_p2_00002048(b: &mut Bencher) {
276 bench_planned_f32(b, 2048);
277 }
278 #[bench]
279 fn wasm_simd_planned32_p2_00004096(b: &mut Bencher) {
280 bench_planned_f32(b, 4096);
281 }
282 #[bench]
283 fn wasm_simd_planned32_p2_00016384(b: &mut Bencher) {
284 bench_planned_f32(b, 16384);
285 }
286 #[bench]
287 fn wasm_simd_planned32_p2_00065536(b: &mut Bencher) {
288 bench_planned_f32(b, 65536);
289 }
290 #[bench]
291 fn wasm_simd_planned32_p2_01048576(b: &mut Bencher) {
292 bench_planned_f32(b, 1048576);
293 }
294
295 #[bench]
296 fn wasm_simd_planned64_p2_00000064(b: &mut Bencher) {
297 bench_planned_f64(b, 64);
298 }
299 #[bench]
300 fn wasm_simd_planned64_p2_00000128(b: &mut Bencher) {
301 bench_planned_f64(b, 128);
302 }
303 #[bench]
304 fn wasm_simd_planned64_p2_00000256(b: &mut Bencher) {
305 bench_planned_f64(b, 256);
306 }
307 #[bench]
308 fn wasm_simd_planned64_p2_00000512(b: &mut Bencher) {
309 bench_planned_f64(b, 512);
310 }
311 #[bench]
312 fn wasm_simd_planned64_p2_00001024(b: &mut Bencher) {
313 bench_planned_f64(b, 1024);
314 }
315 #[bench]
316 fn wasm_simd_planned64_p2_00002048(b: &mut Bencher) {
317 bench_planned_f64(b, 2048);
318 }
319 #[bench]
320 fn wasm_simd_planned64_p2_00004096(b: &mut Bencher) {
321 bench_planned_f64(b, 4096);
322 }
323 #[bench]
324 fn wasm_simd_planned64_p2_00016384(b: &mut Bencher) {
325 bench_planned_f64(b, 16384);
326 }
327 #[bench]
328 fn wasm_simd_planned64_p2_00065536(b: &mut Bencher) {
329 bench_planned_f64(b, 65536);
330 }
331 #[bench]
332 fn wasm_simd_planned64_p2_01048576(b: &mut Bencher) {
333 bench_planned_f64(b, 1048576);
334 }
335
336 // Powers of 7
337 #[bench]
338 fn wasm_simd_planned32_p7_00343(b: &mut Bencher) {
339 bench_planned_f32(b, 343);
340 }
341 #[bench]
342 fn wasm_simd_planned32_p7_02401(b: &mut Bencher) {
343 bench_planned_f32(b, 2401);
344 }
345 #[bench]
346 fn wasm_simd_planned32_p7_16807(b: &mut Bencher) {
347 bench_planned_f32(b, 16807);
348 }
349
350 #[bench]
351 fn wasm_simd_planned64_p7_00343(b: &mut Bencher) {
352 bench_planned_f64(b, 343);
353 }
354 #[bench]
355 fn wasm_simd_planned64_p7_02401(b: &mut Bencher) {
356 bench_planned_f64(b, 2401);
357 }
358 #[bench]
359 fn wasm_simd_planned64_p7_16807(b: &mut Bencher) {
360 bench_planned_f64(b, 16807);
361 }
362
363 // Prime lengths
364 #[bench]
365 fn wasm_simd_planned32_prime_0149(b: &mut Bencher) {
366 bench_planned_f32(b, 149);
367 }
368 #[bench]
369 fn wasm_simd_planned32_prime_0151(b: &mut Bencher) {
370 bench_planned_f32(b, 151);
371 }
372 #[bench]
373 fn wasm_simd_planned32_prime_0251(b: &mut Bencher) {
374 bench_planned_f32(b, 251);
375 }
376 #[bench]
377 fn wasm_simd_planned32_prime_0257(b: &mut Bencher) {
378 bench_planned_f32(b, 257);
379 }
380 #[bench]
381 fn wasm_simd_planned32_prime_2017(b: &mut Bencher) {
382 bench_planned_f32(b, 2017);
383 }
384 #[bench]
385 fn wasm_simd_planned32_prime_2879(b: &mut Bencher) {
386 bench_planned_f32(b, 2879);
387 }
388 #[bench]
389 fn wasm_simd_planned32_prime_65521(b: &mut Bencher) {
390 bench_planned_f32(b, 65521);
391 }
392 #[bench]
393 fn wasm_simd_planned32_prime_746497(b: &mut Bencher) {
394 bench_planned_f32(b, 746497);
395 }
396
397 #[bench]
398 fn wasm_simd_planned64_prime_0149(b: &mut Bencher) {
399 bench_planned_f64(b, 149);
400 }
401 #[bench]
402 fn wasm_simd_planned64_prime_0151(b: &mut Bencher) {
403 bench_planned_f64(b, 151);
404 }
405 #[bench]
406 fn wasm_simd_planned64_prime_0251(b: &mut Bencher) {
407 bench_planned_f64(b, 251);
408 }
409 #[bench]
410 fn wasm_simd_planned64_prime_0257(b: &mut Bencher) {
411 bench_planned_f64(b, 257);
412 }
413 #[bench]
414 fn wasm_simd_planned64_prime_2017(b: &mut Bencher) {
415 bench_planned_f64(b, 2017);
416 }
417 #[bench]
418 fn wasm_simd_planned64_prime_2879(b: &mut Bencher) {
419 bench_planned_f64(b, 2879);
420 }
421 #[bench]
422 fn wasm_simd_planned64_prime_65521(b: &mut Bencher) {
423 bench_planned_f64(b, 65521);
424 }
425 #[bench]
426 fn wasm_simd_planned64_prime_746497(b: &mut Bencher) {
427 bench_planned_f64(b, 746497);
428 }
429
430 // small mixed composites
431 #[bench]
432 fn wasm_simd_planned32_composite_000018(b: &mut Bencher) {
433 bench_planned_f32(b, 00018);
434 }
435 #[bench]
436 fn wasm_simd_planned32_composite_000360(b: &mut Bencher) {
437 bench_planned_f32(b, 00360);
438 }
439 #[bench]
440 fn wasm_simd_planned32_composite_001200(b: &mut Bencher) {
441 bench_planned_f32(b, 01200);
442 }
443 #[bench]
444 fn wasm_simd_planned32_composite_044100(b: &mut Bencher) {
445 bench_planned_f32(b, 44100);
446 }
447 #[bench]
448 fn wasm_simd_planned32_composite_048000(b: &mut Bencher) {
449 bench_planned_f32(b, 48000);
450 }
451 #[bench]
452 fn wasm_simd_planned32_composite_046656(b: &mut Bencher) {
453 bench_planned_f32(b, 46656);
454 }
455
456 #[bench]
457 fn wasm_simd_planned64_composite_000018(b: &mut Bencher) {
458 bench_planned_f64(b, 00018);
459 }
460 #[bench]
461 fn wasm_simd_planned64_composite_000360(b: &mut Bencher) {
462 bench_planned_f64(b, 00360);
463 }
464 #[bench]
465 fn wasm_simd_planned64_composite_001200(b: &mut Bencher) {
466 bench_planned_f64(b, 01200);
467 }
468 #[bench]
469 fn wasm_simd_planned64_composite_044100(b: &mut Bencher) {
470 bench_planned_f64(b, 44100);
471 }
472 #[bench]
473 fn wasm_simd_planned64_composite_048000(b: &mut Bencher) {
474 bench_planned_f64(b, 48000);
475 }
476 #[bench]
477 fn wasm_simd_planned64_composite_046656(b: &mut Bencher) {
478 bench_planned_f64(b, 46656);
479 }