Add an estimating planner to the NEON, SSE and wasm_simd planners

Cargo.toml

@@ -31,6 +31,7 @@ avx = []
 sse = []
 neon = []
 wasm_simd = []
+tuning = []
 
 
 [dependencies]

src/lib.rs

@@ -137,6 +137,15 @@ mod math_utils;
 mod plan;
 mod twiddles;
 
+// Code shared by the SIMD backends: the `SimdVector` trait, the algorithms written against it, and
+// the planner arithmetic that goes with them
+#[cfg(any(
+    all(target_arch = "aarch64", feature = "neon"),
+    all(target_arch = "x86_64", feature = "sse"),
+    all(target_arch = "wasm32", feature = "wasm_simd"),
+))]
+mod simd;
+
 use num_complex::Complex;
 use num_traits::Zero;
 
@@ -602,5 +611,10 @@ mod wasm_simd {
 
 pub use self::wasm_simd::wasm_simd_planner::FftPlannerWasmSimd;
 
+// Internal support for the planner-tuning tools. Not part of the public API.
+#[cfg(feature = "tuning")]
+#[doc(hidden)]
+pub mod tuning;
+
 #[cfg(test)]
 mod test_utils;

src/math_utils.rs

@@ -1,5 +1,7 @@
 use num_traits::{One, PrimInt, Zero};
 
+use crate::common::RadixFactor;
+
 pub fn primitive_root(prime: u64) -> Option<u64> {
     let test_exponents: Vec<u64> = distinct_prime_factors(prime - 1)
         .iter()
@@ -185,6 +187,26 @@ impl PrimeFactors {
     pub fn get_other_factors(&self) -> &[PrimeFactor] {
         &self.other_factors
     }
+    /// How many times `value` divides this number, or zero if it isn't a factor at all.
+    /// `value` is assumed to be prime.
+    #[allow(unused)]
+    pub fn get_power_of(&self, value: usize) -> u32 {
+        match value {
+            2 => self.power_two,
+            3 => self.power_three,
+            _ => self
+                .other_factors
+                .iter()
+                .find_map(|f| {
+                    if f.value == value {
+                        Some(f.count)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or(0),
+        }
+    }
     #[allow(unused)]
     pub fn is_power_of_three(&self) -> bool {
         self.power_three > 0 && self.power_two == 0 && self.other_factors.len() == 0
@@ -487,6 +509,44 @@ impl PartialFactors {
     }
 }
 
+/// Split a RadixN cross-FFT length into the layers that make it up, or None if it has a
+/// factor no layer can handle.
+///
+/// Every planner picks its base by its own rules, but once the base is divided out the rest
+/// is the same arithmetic for all of them, so this is deliberately free of any policy.
+pub fn split_cross_len(mut cross_len: usize) -> Option<Box<[RadixFactor]>> {
+    let mut factors = Vec::new();
+    while cross_len % 7 == 0 {
+        cross_len /= 7;
+        factors.push(RadixFactor::Factor7);
+    }
+    while cross_len % 6 == 0 {
+        cross_len /= 6;
+        factors.push(RadixFactor::Factor6);
+    }
+    while cross_len % 5 == 0 {
+        cross_len /= 5;
+        factors.push(RadixFactor::Factor5);
+    }
+    while cross_len % 3 == 0 {
+        cross_len /= 3;
+        factors.push(RadixFactor::Factor3);
+    }
+    if !cross_len.is_power_of_two() {
+        return None;
+    }
+
+    // benchmarking suggests that we want to add the 4s *last*, i suspect because 4 is a
+    // better-than-usual value for the transpose
+    let cross_bits = cross_len.trailing_zeros();
+    if cross_bits % 2 == 1 {
+        factors.push(RadixFactor::Factor2);
+    }
+    factors.extend(std::iter::repeat(RadixFactor::Factor4).take(cross_bits as usize / 2));
+
+    Some(factors.into_boxed_slice())
+}
+
 #[cfg(test)]
 mod unit_tests {
     use super::*;

src/neon/mod.rs

@@ -7,6 +7,7 @@ mod neon_vector;
 pub mod neon_butterflies;
 pub mod neon_prime_butterflies;
 pub mod neon_radix4;
+pub mod neon_radixn;
 
 mod neon_utils;