simd-vector-engine 0.1.0

Runtime-dispatched SIMD kernels for scanning i32/f32 slices: count, sum, find and stream compaction on AVX-512, AVX2, NEON with a scalar fallback
Documentation
// Буферы под векторные загрузки. 64 байта = линия кэша = ширина ZMM.
// Невыровненный адрес в vmovdqa/vmovdqa64 — это #GP, поэтому проверка обязательна.

use std::alloc::{alloc_zeroed, dealloc, handle_alloc_error, Layout};
use std::ops::{Deref, DerefMut};

pub const SIMD_ALIGN: usize = 64;

#[inline(always)]
pub fn is_aligned<T>(ptr: *const T, align: usize) -> bool {
    debug_assert!(align.is_power_of_two());
    (ptr as usize) & (align - 1) == 0
}

#[repr(align(64))]
#[derive(Clone, Copy, Debug, Default)]
pub struct Align64<T>(pub T);

pub struct AlignedVec<T: Copy> {
    ptr: *mut T,
    len: usize,
    layout: Layout,
}

unsafe impl<T: Copy + Send> Send for AlignedVec<T> {}
unsafe impl<T: Copy + Sync> Sync for AlignedVec<T> {}

impl<T: Copy> AlignedVec<T> {
    pub fn zeroed(len: usize) -> Self {
        let size = len
            .checked_mul(std::mem::size_of::<T>())
            .expect("AlignedVec: переполнение размера")
            .max(1);
        // округление вверх — запас под хвостовые загрузки
        let size = (size + SIMD_ALIGN - 1) & !(SIMD_ALIGN - 1);
        let layout = Layout::from_size_align(size, SIMD_ALIGN).expect("AlignedVec: плохой layout");
        let ptr = unsafe { alloc_zeroed(layout) } as *mut T;
        if ptr.is_null() {
            handle_alloc_error(layout);
        }
        Self { ptr, len, layout }
    }

    pub fn from_fn(len: usize, mut f: impl FnMut(usize) -> T) -> Self {
        let v = Self::zeroed(len);
        for i in 0..len {
            unsafe { v.ptr.add(i).write(f(i)) };
        }
        v
    }

    #[inline(always)]
    pub fn as_slice(&self) -> &[T] {
        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
    }

    #[inline(always)]
    pub fn as_mut_slice(&mut self) -> &mut [T] {
        unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
    }

    pub fn actual_alignment(&self) -> usize {
        let addr = self.ptr as usize;
        if addr == 0 {
            return 0;
        }
        1usize << addr.trailing_zeros().min(12)
    }
}

impl<T: Copy> Deref for AlignedVec<T> {
    type Target = [T];
    #[inline(always)]
    fn deref(&self) -> &[T] {
        self.as_slice()
    }
}

impl<T: Copy> DerefMut for AlignedVec<T> {
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut [T] {
        self.as_mut_slice()
    }
}

impl<T: Copy> Drop for AlignedVec<T> {
    fn drop(&mut self) {
        if !self.ptr.is_null() {
            unsafe { dealloc(self.ptr as *mut u8, self.layout) };
        }
    }
}

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

    #[test]
    fn alignment_is_64() {
        for len in [1usize, 7, 64, 1000, 100_003] {
            let v = AlignedVec::<i32>::zeroed(len);
            assert!(is_aligned(v.as_slice().as_ptr(), SIMD_ALIGN));
            assert_eq!(v.len(), len);
        }
    }

    #[test]
    fn from_fn_fills() {
        let v = AlignedVec::from_fn(10, |i| i as i32 * 2);
        assert_eq!(v[9], 18);
    }
}