tenflowers_core/simd/
mod.rs

1//! Ultra-High-Performance SIMD Optimizations powered by SciRS2-Core
2//!
3//! This module provides state-of-the-art Single Instruction, Multiple Data (SIMD)
4//! optimizations for core tensor operations, leveraging SciRS2-Core's advanced
5//! vectorization capabilities and platform-specific acceleration.
6//!
7//! ## Modular Architecture
8//!
9//! - [`basic_ops`] - Element-wise operations (add, multiply, FMA)
10//! - [`activation_functions`] - Neural network activation functions (ReLU, Sigmoid, etc.)
11//! - [`matrix_ops`] - Matrix operations (matmul, dot product, transpose)
12//! - [`math_functions`] - Mathematical functions (exp, sqrt, log, trig)
13//! - [`reduction_ops`] - Reduction operations (sum, min/max, normalization)
14//! - [`capabilities`] - Platform capabilities detection and utilities
15//! - [`benchmarks`] - Performance benchmarking utilities
16//!
17//! ## Legacy Modules (Advanced Features)
18//!
19//! - [`advanced_kernels`] - Specialized kernel implementations
20//! - [`cache_friendly_ops`] - Cache-optimized tensor operations
21//! - [`ultra_simd_engine`] - Ultra-high performance SIMD engine
22
23use crate::Result;
24
25// Import SciRS2-Core parallel processing capabilities
26#[cfg(feature = "simd")]
27use scirs2_core::parallel_ops::{par_chunks, par_join, par_scope};
28
29// New modular SIMD architecture
30pub mod activation_functions;
31pub mod basic_ops;
32pub mod benchmarks;
33pub mod capabilities;
34pub mod math_functions;
35pub mod matrix_ops;
36pub mod reduction_ops;
37
38// Legacy advanced modules
39pub mod advanced_kernels;
40pub mod cache_friendly_ops;
41pub mod ultra_simd_engine;
42
43// Re-export new modular API
44pub use activation_functions::ActivationFunctions;
45pub use basic_ops::BasicOps;
46pub use benchmarks::{BenchmarkResult, Benchmarks};
47pub use capabilities::{Capabilities, PerformanceHints, SimdCapabilities};
48pub use math_functions::MathFunctions;
49pub use matrix_ops::MatrixOps;
50pub use reduction_ops::ReductionOps;
51
52// Re-export legacy API for backward compatibility
53pub use ultra_simd_engine::{
54    global_simd_engine, ConvolutionParams, CpuFeatures, ElementWiseOp, ReductionOp,
55    SimdEngineConfig, UltraSimdEngine,
56};
57
58pub use cache_friendly_ops::{CacheFriendlyMatMul, CacheOptimizedTensorOps, MemoryAccessPattern};
59
60pub use advanced_kernels::{AdvancedKernelRegistry, KernelOptimizationStrategy, SpecializedKernel};
61
62/// SIMD-optimized tensor operations using stable Rust features
63///
64/// This is the main entry point for SIMD operations, providing a unified
65/// interface to all optimized functions while maintaining backward compatibility.
66pub struct SimdOptimizer;
67
68impl SimdOptimizer {
69    // Re-export key operations for backward compatibility with the monolithic interface
70
71    /// Fast inline element-wise addition without bounds checking (for hot paths)
72    #[inline(always)]
73    pub fn add_f32_unchecked(a: &[f32], b: &[f32], result: &mut [f32]) {
74        BasicOps::add_f32_unchecked(a, b, result)
75    }
76
77    /// Element-wise addition with SciRS2-Core SIMD auto-vectorization (safe version)
78    pub fn add_f32_optimized(a: &[f32], b: &[f32], result: &mut [f32]) -> Result<()> {
79        BasicOps::add_f32_optimized(a, b, result)
80    }
81
82    /// Auto-selection element-wise addition (chooses optimal implementation based on size)
83    pub fn add_f32_auto(a: &[f32], b: &[f32], result: &mut [f32]) -> Result<()> {
84        BasicOps::add_f32_auto(a, b, result)
85    }
86
87    /// Fast inline element-wise multiplication without bounds checking (for hot paths)
88    #[inline(always)]
89    pub fn mul_f32_unchecked(a: &[f32], b: &[f32], result: &mut [f32]) {
90        BasicOps::mul_f32_unchecked(a, b, result)
91    }
92
93    /// Element-wise multiplication with optimization hints for f32 tensors (safe version)
94    pub fn mul_f32_optimized(a: &[f32], b: &[f32], result: &mut [f32]) -> Result<()> {
95        BasicOps::mul_f32_optimized(a, b, result)
96    }
97
98    /// Element-wise subtraction with optimization hints for f32 tensors (safe version)
99    pub fn sub_f32_optimized(a: &[f32], b: &[f32], result: &mut [f32]) -> Result<()> {
100        BasicOps::sub_f32_optimized(a, b, result)
101    }
102
103    /// Optimized ReLU activation function
104    pub fn relu_f32_optimized(input: &[f32], output: &mut [f32]) -> Result<()> {
105        ActivationFunctions::relu_f32_optimized(input, output)
106    }
107
108    /// Optimized sigmoid activation with fast approximation
109    pub fn sigmoid_f32_optimized(input: &[f32], output: &mut [f32]) -> Result<()> {
110        ActivationFunctions::sigmoid_f32_optimized(input, output)
111    }
112
113    /// Advanced cache-friendly matrix multiplication using blocking
114    pub fn matmul_f32_blocked(
115        a: &[f32],
116        b: &[f32],
117        c: &mut [f32],
118        m: usize,
119        n: usize,
120        k: usize,
121        block_size: usize,
122    ) -> Result<()> {
123        MatrixOps::matmul_f32_blocked(a, b, c, m, n, k, block_size)
124    }
125
126    /// Optimized dot product for f32 vectors using Kahan summation
127    pub fn dot_product_f32_optimized(a: &[f32], b: &[f32]) -> Result<f32> {
128        MatrixOps::dot_product_f32_optimized(a, b)
129    }
130
131    /// Ultra-fast vectorized horizontal sum reduction
132    #[inline(always)]
133    pub fn sum_f32_unchecked(input: &[f32]) -> f32 {
134        ReductionOps::sum_f32_unchecked(input)
135    }
136
137    /// Vectorized maximum element finding with SIMD optimization
138    #[inline(always)]
139    pub fn max_f32_unchecked(input: &[f32]) -> f32 {
140        ReductionOps::max_f32_unchecked(input)
141    }
142
143    /// Platform-specific capabilities detection (stable approach)
144    pub fn detect_capabilities() -> SimdCapabilities {
145        Capabilities::detect_capabilities()
146    }
147
148    /// Advanced vectorized reduction operations with numerical stability
149    pub fn reduce_sum_f32_optimized(input: &[f32]) -> Result<f32> {
150        ReductionOps::reduce_sum_f32_optimized(input)
151    }
152
153    /// Vectorized min/max operations with efficient branching
154    pub fn reduce_min_max_f32_optimized(input: &[f32]) -> Result<(f32, f32)> {
155        ReductionOps::reduce_min_max_f32_optimized(input)
156    }
157
158    /// Advanced normalization with streaming computation for memory efficiency
159    pub fn normalize_f32_optimized(input: &[f32], output: &mut [f32], eps: f32) -> Result<()> {
160        ReductionOps::normalize_f32_optimized(input, output, eps)
161    }
162}
tenflowers_core/simd/mod.rs

tenflowers_core/simd/
mod.rs
