simd-vector-engine 0.1.0

Runtime-dispatched SIMD kernels for scanning i32/f32 slices: count, sum, find and stream compaction on AVX-512, AVX2, NEON with a scalar fallback
Documentation
// Детекция наборов инструкций. is_x86_feature_detected! делает CPUID и XGETBV:
// без XGETBV можно получить #UD на VEX, если ОС не сохраняет YMM/ZMM.
// CPUID сериализует конвейер, поэтому результат кэшируется.

use std::sync::OnceLock;

/// Порядок вариантов значим: больше == шире.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Isa {
    Scalar = 0,
    Neon = 1,
    Avx2 = 2,
    Avx512 = 3,
}

impl Isa {
    pub const fn name(self) -> &'static str {
        match self {
            Isa::Scalar => "Scalar",
            Isa::Neon => "NEON",
            Isa::Avx2 => "AVX2",
            Isa::Avx512 => "AVX-512",
        }
    }

    pub const fn register_bits(self) -> usize {
        match self {
            Isa::Scalar => 32,
            Isa::Neon => 128,
            Isa::Avx2 => 256,
            Isa::Avx512 => 512,
        }
    }

    pub const fn lanes_32bit(self) -> usize {
        self.register_bits() / 32
    }
}

#[derive(Debug, Clone, Copy, Default)]
pub struct CpuFeatures {
    pub sse2: bool,
    pub sse42: bool,
    pub avx: bool,
    pub avx2: bool,
    pub fma: bool,
    pub popcnt: bool,
    pub avx512f: bool,
    pub avx512bw: bool,
    pub avx512dq: bool,
    pub avx512vl: bool,
    pub neon: bool,
}

impl CpuFeatures {
    pub fn enabled(&self) -> Vec<&'static str> {
        let mut v = Vec::new();
        for (on, name) in [
            (self.sse2, "sse2"),
            (self.sse42, "sse4.2"),
            (self.popcnt, "popcnt"),
            (self.avx, "avx"),
            (self.avx2, "avx2"),
            (self.fma, "fma"),
            (self.avx512f, "avx512f"),
            (self.avx512bw, "avx512bw"),
            (self.avx512dq, "avx512dq"),
            (self.avx512vl, "avx512vl"),
            (self.neon, "neon"),
        ] {
            if on {
                v.push(name);
            }
        }
        v
    }
}

fn detect() -> CpuFeatures {
    let mut f = CpuFeatures::default();

    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
    {
        f.sse2 = is_x86_feature_detected!("sse2");
        f.sse42 = is_x86_feature_detected!("sse4.2");
        f.popcnt = is_x86_feature_detected!("popcnt");
        f.avx = is_x86_feature_detected!("avx");
        f.avx2 = is_x86_feature_detected!("avx2");
        f.fma = is_x86_feature_detected!("fma");
        f.avx512f = is_x86_feature_detected!("avx512f");
        f.avx512bw = is_x86_feature_detected!("avx512bw");
        f.avx512dq = is_x86_feature_detected!("avx512dq");
        f.avx512vl = is_x86_feature_detected!("avx512vl");
    }

    #[cfg(target_arch = "aarch64")]
    {
        f.neon = std::arch::is_aarch64_feature_detected!("neon");
    }

    f
}

pub fn features() -> &'static CpuFeatures {
    static CACHE: OnceLock<CpuFeatures> = OnceLock::new();
    CACHE.get_or_init(detect)
}

/// `SVE_ISA=scalar|avx2|avx512|neon` переопределяет выбор.
pub fn best_isa() -> Isa {
    static CACHE: OnceLock<Isa> = OnceLock::new();
    *CACHE.get_or_init(|| {
        if let Ok(forced) = std::env::var("SVE_ISA") {
            let want = match forced.to_ascii_lowercase().as_str() {
                "scalar" => Some(Isa::Scalar),
                "neon" => Some(Isa::Neon),
                "avx2" => Some(Isa::Avx2),
                "avx512" | "avx-512" => Some(Isa::Avx512),
                _ => None,
            };
            if let Some(w) = want {
                if available_isas().contains(&w) {
                    return w;
                }
            }
        }
        *available_isas().last().unwrap_or(&Isa::Scalar)
    })
}

/// По возрастанию ширины.
pub fn available_isas() -> Vec<Isa> {
    let f = features();
    let mut v = vec![Isa::Scalar];
    if f.neon {
        v.push(Isa::Neon);
    }
    if f.avx2 {
        v.push(Isa::Avx2);
    }
    if f.avx512f {
        v.push(Isa::Avx512);
    }
    v
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn detection_never_panics_and_is_monotonic() {
        let isas = available_isas();
        assert!(isas.contains(&Isa::Scalar));
        let mut sorted = isas.clone();
        sorted.sort();
        assert_eq!(isas, sorted);
        assert!(isas.contains(&best_isa()));
    }
}