rill-core 0.5.0-beta.5

Core foundation for the Rill ecosystem — traits, math, buffers, queues, time, macros
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! # SIMD implementations for vector operations
//!
//! This module contains platform-dependent SIMD implementations of vector operations.
//!
//! ## CPU feature detection
//! The system automatically determines available SIMD instructions at runtime
//! and selects the optimal implementation.
//!
//! ## Supported architectures
//! - x86/x86_64: SSE2, SSE4.1, AVX, AVX2, AVX512
//! - ARM: NEON (AArch64)
//! - WebAssembly: SIMD128
//!
//! ## Usage
//! Users typically don't interact with this module directly,
//! but use the high-level abstractions from `vector::traits`.

#![allow(unused_imports)]
#![allow(dead_code)]

// Cross-platform SIMD implementation via the wide crate (requires simd feature)
#[cfg(feature = "simd")]
pub mod wide;

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub mod x86;

#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
pub mod arm;

#[cfg(target_arch = "wasm32")]
pub mod wasm;

/// SIMD capability detector for the CPU
pub struct SimdDetector {
    has_sse2: bool,
    has_sse4_1: bool,
    has_avx: bool,
    has_avx2: bool,
    has_avx512: bool,
    has_neon: bool,
    has_wasm_simd128: bool,
}

impl Default for SimdDetector {
    fn default() -> Self {
        Self::new()
    }
}

impl SimdDetector {
    /// Creates a detector and determines the current CPU's capabilities.
    ///
    /// Uses `std::arch::is_x86_feature_detected!` on x86/x86_64
    /// and `std::arch::is_aarch64_feature_detected!` on AArch64.
    /// On other targets, all features are reported as unavailable.
    pub fn new() -> Self {
        Self {
            #[cfg(target_arch = "x86_64")]
            has_sse2: std::arch::is_x86_feature_detected!("sse2"),
            #[cfg(target_arch = "x86")]
            has_sse2: std::arch::is_x86_feature_detected!("sse2"),
            #[cfg(target_arch = "x86_64")]
            has_sse4_1: std::arch::is_x86_feature_detected!("sse4.1"),
            #[cfg(target_arch = "x86")]
            has_sse4_1: std::arch::is_x86_feature_detected!("sse4.1"),
            #[cfg(target_arch = "x86_64")]
            has_avx: std::arch::is_x86_feature_detected!("avx"),
            #[cfg(target_arch = "x86")]
            has_avx: std::arch::is_x86_feature_detected!("avx"),
            #[cfg(target_arch = "x86_64")]
            has_avx2: std::arch::is_x86_feature_detected!("avx2"),
            #[cfg(target_arch = "x86")]
            has_avx2: std::arch::is_x86_feature_detected!("avx2"),
            #[cfg(target_arch = "x86_64")]
            has_avx512: std::arch::is_x86_feature_detected!("avx512f"),
            #[cfg(target_arch = "x86")]
            has_avx512: std::arch::is_x86_feature_detected!("avx512f"),
            #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
            has_sse2: false,
            #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
            has_sse4_1: false,
            #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
            has_avx: false,
            #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
            has_avx2: false,
            #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
            has_avx512: false,
            #[cfg(target_arch = "aarch64")]
            has_neon: std::arch::is_aarch64_feature_detected!("neon"),
            #[cfg(not(target_arch = "aarch64"))]
            has_neon: false,
            #[cfg(target_arch = "wasm32")]
            has_wasm_simd128: true,
            #[cfg(not(target_arch = "wasm32"))]
            has_wasm_simd128: false,
        }
    }

    /// Returns the maximum recommended SIMD width for the current platform.
    ///
    /// On x86_64: 8 if AVX available, 4 if SSE2 available.
    /// On AArch64: 4 if NEON available.
    /// On wasm32: 4.
    /// Fallback: 1 (scalar).
    pub fn recommended_simd_width<T: crate::Transcendental>() -> usize {
        let det = Self::new();
        if det.has_avx {
            return 8;
        }
        if det.has_sse2 || det.has_neon || det.has_wasm_simd128 {
            return 4;
        }
        1
    }
}

// Re-exports
#[cfg(feature = "simd")]
pub use wide::*;

// Platform-specific re-exports (not yet implemented)
// #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
// pub use x86::*;

// #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
// pub use arm::*;

// #[cfg(target_arch = "wasm32")]
// pub use wasm::*;