rustalign_simd/

cpu.rs

//! CPU feature detection
//!
//! This module provides runtime CPU feature detection,
//! matching the C++ ProcessorSupport class and __builtin_cpu_supports.

/// Detected CPU features for SIMD dispatch
#[derive(Debug, Clone, Copy)]
pub struct CpuFeatures {
    /// SSE2 support
    pub sse2: bool,
    /// SSE4.2 support
    pub sse4_2: bool,
    /// POPCNT instruction support
    pub popcnt: bool,
    /// AVX support
    pub avx: bool,
    /// AVX2 support
    pub avx2: bool,
    /// NEON support (AArch64 only)
    #[cfg(target_arch = "aarch64")]
    pub neon: bool,
}

impl CpuFeatures {
    /// Detect CPU features at runtime
    ///
    /// This matches the C++ ProcessorSupport::POPCNTenabled() method
    /// and extends it to detect all SIMD features used by RustAlign.
    pub fn detect() -> Self {
        Self {
            sse2: cfg!(not(target_arch = "aarch64")) && detect_sse2(),
            sse4_2: cfg!(not(target_arch = "aarch64")) && detect_sse4_2(),
            popcnt: detect_popcnt(),
            avx: cfg!(not(target_arch = "aarch64")) && detect_avx(),
            avx2: cfg!(not(target_arch = "aarch64")) && detect_avx2(),
            #[cfg(target_arch = "aarch64")]
            neon: detect_neon(),
        }
    }

    /// Check if x86-64-v3 (AVX2) is supported
    ///
    /// This matches the C++ __builtin_cpu_supports("x86-64-v3") check.
    pub fn x86_64_v3(&self) -> bool {
        self.avx2
    }

    /// Get the best available SIMD width
    pub fn simd_width(&self) -> usize {
        if self.avx2 {
            32
        } else if self.sse2 {
            16
        } else {
            0 // Scalar
        }
    }
}

impl Default for CpuFeatures {
    fn default() -> Self {
        Self::detect()
    }
}

#[cfg(target_arch = "x86_64")]
#[allow(unused_imports)]
use std::arch::x86_64::*;

/// Detect SSE2 support (x86_64 only)
#[cfg(target_arch = "x86_64")]
fn detect_sse2() -> bool {
    is_x86_feature_detected!("sse2")
}

/// Detect SSE4.2 support (x86_64 only)
#[cfg(target_arch = "x86_64")]
fn detect_sse4_2() -> bool {
    is_x86_feature_detected!("sse4.2")
}

/// Detect POPCNT support
#[cfg(target_arch = "x86_64")]
fn detect_popcnt() -> bool {
    is_x86_feature_detected!("popcnt")
}

/// Detect AVX support (x86_64 only)
#[cfg(target_arch = "x86_64")]
fn detect_avx() -> bool {
    is_x86_feature_detected!("avx")
}

/// Detect AVX2 support (x86_64 only)
#[cfg(target_arch = "x86_64")]
fn detect_avx2() -> bool {
    is_x86_feature_detected!("avx2")
}

/// Fallback implementations for non-x86_64
#[cfg(not(target_arch = "x86_64"))]
fn detect_sse2() -> bool {
    false
}

#[cfg(not(target_arch = "x86_64"))]
fn detect_sse4_2() -> bool {
    false
}

#[cfg(not(target_arch = "x86_64"))]
fn detect_popcnt() -> bool {
    true // Most modern CPUs support popcnt
}

#[cfg(not(target_arch = "x86_64"))]
fn detect_avx() -> bool {
    false
}

#[cfg(not(target_arch = "x86_64"))]
fn detect_avx2() -> bool {
    false
}

/// Detect NEON support (aarch64 only)
#[cfg(target_arch = "aarch64")]
fn detect_neon() -> bool {
    // NEON is always available on aarch64
    true
}

/// Convenience functions for individual feature detection
pub fn has_sse2() -> bool {
    detect_sse2()
}

/// Check if SSE4.2 is available
pub fn has_sse4_2() -> bool {
    detect_sse4_2()
}

/// Check if POPCNT is available
pub fn has_popcnt() -> bool {
    detect_popcnt()
}

/// Check if AVX is available (x86_64)
#[cfg(target_arch = "x86_64")]
#[allow(dead_code)]
pub fn has_avx() -> bool {
    detect_avx()
}

/// Check if AVX2 is available (x86_64)
#[cfg(target_arch = "x86_64")]
pub fn has_avx2() -> bool {
    detect_avx2()
}

/// Check if NEON is available (always false on x86_64)
#[cfg(target_arch = "x86_64")]
pub fn has_neon() -> bool {
    false
}

/// Check if NEON is available (aarch64)
#[cfg(target_arch = "aarch64")]
pub fn has_neon() -> bool {
    detect_neon()
}

/// Check if AVX is available (always false on aarch64)
#[cfg(target_arch = "aarch64")]
#[allow(dead_code)]
pub fn has_avx() -> bool {
    false
}

/// Check if AVX2 is available (always false on aarch64)
#[cfg(target_arch = "aarch64")]
pub fn has_avx2() -> bool {
    false
}

/// Stub implementations for non-x86_64, non-aarch64 platforms
#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
#[allow(dead_code)]
pub fn has_avx() -> bool {
    false
}

/// Check if AVX2 is available (stub for unsupported platforms)
#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
pub fn has_avx2() -> bool {
    false
}

/// Check if NEON is available (stub for unsupported platforms)
#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
pub fn has_neon() -> bool {
    false
}

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

    #[test]
    fn test_cpu_features_detect() {
        let features = CpuFeatures::detect();
        // At minimum, we should have a valid detection result
        // (may be all false on non-x86_64 without NEON)
        let _ = features.sse2;
        let _ = features.sse4_2;
        let _ = features.popcnt;
    }

    #[test]
    fn test_x86_64_v3() {
        let features = CpuFeatures::detect();
        let _ = features.x86_64_v3();
    }

    #[test]
    fn test_simd_width() {
        let features = CpuFeatures::detect();
        let width = features.simd_width();
        // Width should be 0, 16, or 32
        assert!(width == 0 || width == 16 || width == 32);
    }
}