archx 3.0.1

High-performance CPU/GPU adaptive optimization library with SIMD and Multithreading
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

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
use crate::optimizer::scalar;

/// AVX-512 implementation of the add operation with v3.0 loop unrolling.
/// 
/// Process 32 floats per iteration (2x zmm registers) to maximize 
/// instruction-level parallelism.
pub fn add_avx512_impl(a: &[f32], b: &[f32], out: &mut [f32]) {
    let len = a.len().min(b.len()).min(out.len());
    
    // Process in chunks of 32 (2x AVX-512 registers)
    let unroll_factor = 32;
    let simd_len = len / unroll_factor;
    let main_loop_len = simd_len * unroll_factor;

    #[cfg(target_arch = "x86_64")]
    {
        unsafe {
            for i in (0..main_loop_len).step_by(unroll_factor) {
                let a_ptr = a.as_ptr().add(i);
                let b_ptr = b.as_ptr().add(i);
                let out_ptr = out.as_mut_ptr().add(i);

                // Quad-load for pipeline saturation
                let va1 = _mm512_loadu_ps(a_ptr);
                let va2 = _mm512_loadu_ps(a_ptr.add(16));
                
                let vb1 = _mm512_loadu_ps(b_ptr);
                let vb2 = _mm512_loadu_ps(b_ptr.add(16));
                
                let vres1 = _mm512_add_ps(va1, vb1);
                let vres2 = _mm512_add_ps(va2, vb2);
                
                _mm512_storeu_ps(out_ptr, vres1);
                _mm512_storeu_ps(out_ptr.add(16), vres2);
            }
        }
    }

    // Handle remainder
    if main_loop_len < len {
        scalar::add_impl(
            &a[main_loop_len..len],
            &b[main_loop_len..len],
            &mut out[main_loop_len..len],
        );
    }
}