simd_vector_engine/
aligned.rs1use 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 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}