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)
}
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()));
}
}