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);
}
}