主页 / coding / 问题 / 79127223
Accepted
Fee
Asked: 2024-10-26 04:19:18 +0800 CST

测试 bytemuck 铸造对齐问题

  • 772

我有以下带有转换逻辑的结构：

enum TagType {
  DOUBLE,
  BYTE,
}

impl TagType {
  /// byte-size actually
  fn size(&self) -> usize {
    match self {
      TagType::DOUBLE => 8,
      TagType::BYTE => 1,
    }
  }
}
/// Entry with buffered data.
///
/// Should not be used for tags where the data fits in the offset field
/// byte-order of the data should be native-endian in this buffer
#[derive(Debug, PartialEq, Clone)]
pub struct BufferedEntry {
    pub tag_type: TagType,
    pub count: u64,
    pub data: Vec<u8>,
}

impl<'a> TryFrom<&'a BufferedEntry> for &'a [f64] {
    type Error = ();

    fn try_from(val: &'a BufferedEntry) -> Result<Self, Self::Error> {
        if val.data.len() != val.tag_type.size() * usize::try_from(val.count)? {
            return Err(());
        }
        match val.tag_type {
            TagType::DOUBLE => Ok(bytemuck::cast_slice(&val.data()[..])),
            _ => Err(()),
        }
    }
}

现在，如果输入向量未正确对齐到 8 字节边界，这将导致 panic，而我无法做到这一点。或者，rkyv 有AlignedVec，这应该正是我需要的。然而，问题是：我该如何测试这一点？例如，我该如何编写一个分配非 64 对齐向量的测试？

rust

1 个回答

  1. Best Answer

    据我所知，您不能强制Allocator减少对齐。 Normal通常具有最小对齐。 相反，使用Rust，您可以使用自己的可疑对齐：AllocatornightlyAllocator

    #![feature(allocator_api)]
#![feature(ptr_metadata)]

use std::alloc::{AllocError, Allocator, Layout, System};
use std::ptr::NonNull;

fn main() {
    let unaligned = Vec::<u8, _>::with_capacity_in(1, MinimizeAlignment);

    // Ok.
    assert!(unaligned.as_ptr().addr() % 2 != 0);

    // Panic.
    bytemuck::cast_slice::<u8, f64>(&unaligned);
}

/// Allocations are aligned based on `Layout` (in
/// that accessing them is perfectly sound), but
/// not over-aligned unlike typical allocators
/// which align to several words regardless of
/// `Layout`.
struct MinimizeAlignment;

unsafe impl Allocator for MinimizeAlignment {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
        let new =
            Layout::from_size_align(layout.size() + layout.align(), layout.align() * 2).unwrap();
        let slice = System.allocate(new)?;
        let (ptr, meta) = slice.to_raw_parts();
        let slice = unsafe { NonNull::from_raw_parts(ptr.byte_add(layout.align()), meta - layout.align()) };
        Ok(slice)
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        let new =
            Layout::from_size_align(layout.size() + layout.align(), layout.align() * 2).unwrap();
        System.deallocate(unsafe { ptr.sub(layout.align()) }, new)
    }
}
    • 1

相关问题