Skip to main content

simd_vector_engine/
aligned.rs

1// Буферы под векторные загрузки. 64 байта = линия кэша = ширина ZMM.
2// Невыровненный адрес в vmovdqa/vmovdqa64 — это #GP, поэтому проверка обязательна.
3
4use std::alloc::{alloc_zeroed, dealloc, handle_alloc_error, Layout};
5use std::ops::{Deref, DerefMut};
6
7pub const SIMD_ALIGN: usize = 64;
8
9#[inline(always)]
10pub fn is_aligned<T>(ptr: *const T, align: usize) -> bool {
11    debug_assert!(align.is_power_of_two());
12    (ptr as usize) & (align - 1) == 0
13}
14
15#[repr(align(64))]
16#[derive(Clone, Copy, Debug, Default)]
17pub struct Align64<T>(pub T);
18
19pub struct AlignedVec<T: Copy> {
20    ptr: *mut T,
21    len: usize,
22    layout: Layout,
23}
24
25unsafe impl<T: Copy + Send> Send for AlignedVec<T> {}
26unsafe impl<T: Copy + Sync> Sync for AlignedVec<T> {}
27
28impl<T: Copy> AlignedVec<T> {
29    pub fn zeroed(len: usize) -> Self {
30        let size = len
31            .checked_mul(std::mem::size_of::<T>())
32            .expect("AlignedVec: переполнение размера")
33            .max(1);
34        // округление вверх — запас под хвостовые загрузки
35        let size = (size + SIMD_ALIGN - 1) & !(SIMD_ALIGN - 1);
36        let layout = Layout::from_size_align(size, SIMD_ALIGN).expect("AlignedVec: плохой layout");
37        let ptr = unsafe { alloc_zeroed(layout) } as *mut T;
38        if ptr.is_null() {
39            handle_alloc_error(layout);
40        }
41        Self { ptr, len, layout }
42    }
43
44    pub fn from_fn(len: usize, mut f: impl FnMut(usize) -> T) -> Self {
45        let v = Self::zeroed(len);
46        for i in 0..len {
47            unsafe { v.ptr.add(i).write(f(i)) };
48        }
49        v
50    }
51
52    #[inline(always)]
53    pub fn as_slice(&self) -> &[T] {
54        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
55    }
56
57    #[inline(always)]
58    pub fn as_mut_slice(&mut self) -> &mut [T] {
59        unsafe { std::slice::from_raw_parts_mut(self.ptr, self.len) }
60    }
61
62    pub fn actual_alignment(&self) -> usize {
63        let addr = self.ptr as usize;
64        if addr == 0 {
65            return 0;
66        }
67        1usize << addr.trailing_zeros().min(12)
68    }
69}
70
71impl<T: Copy> Deref for AlignedVec<T> {
72    type Target = [T];
73    #[inline(always)]
74    fn deref(&self) -> &[T] {
75        self.as_slice()
76    }
77}
78
79impl<T: Copy> DerefMut for AlignedVec<T> {
80    #[inline(always)]
81    fn deref_mut(&mut self) -> &mut [T] {
82        self.as_mut_slice()
83    }
84}
85
86impl<T: Copy> Drop for AlignedVec<T> {
87    fn drop(&mut self) {
88        if !self.ptr.is_null() {
89            unsafe { dealloc(self.ptr as *mut u8, self.layout) };
90        }
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97
98    #[test]
99    fn alignment_is_64() {
100        for len in [1usize, 7, 64, 1000, 100_003] {
101            let v = AlignedVec::<i32>::zeroed(len);
102            assert!(is_aligned(v.as_slice().as_ptr(), SIMD_ALIGN));
103            assert_eq!(v.len(), len);
104        }
105    }
106
107    #[test]
108    fn from_fn_fills() {
109        let v = AlignedVec::from_fn(10, |i| i as i32 * 2);
110        assert_eq!(v[9], 18);
111    }
112}