转换任意类型以使用的安全性

Question

我写了一些代码。它有效...但是它安全吗？

use std::mem;
use std::ptr;
use std::marker::PhantomData;

struct Atomic<T: Copy>(AtomicUsize, PhantomData<T>);

impl<T: Copy> Atomic<T> {
    unsafe fn encode(src: T) -> usize {
        assert!(mem::size_of::<T>() <= mem::size_of::<usize>());

        let mut dst = 0;
        ptr::write(&mut dst as *mut usize as *mut T, src);
        dst
    }

    unsafe fn decode(src: usize) -> T {
        assert!(mem::size_of::<T>() <= mem::size_of::<usize>());
        ptr::read(&src as *const usize as *const T)
    }

    fn new(val: T) -> Atomic<T> {
        unsafe {
            Atomic(AtomicUsize::new(Self::encode(val)), PhantomData)
        }
    }

    fn load(&self, order: Ordering) -> T {
        unsafe { Self::decode(self.0.load(order)) }
    }

    fn store(&self, val: T, order: Ordering) {
        unsafe { self.0.store(Self::encode(val), order) }
    }
}

impl<T: Copy + Default> Default for Atomic<T> {
    fn default() -> Atomic<T> {
        Self::new(T::default())
    }
}

如您所见，我将足够小的任意 Copy 值写入 usize，然后在 Atomic 中发送。然后我将其作为新值读出。

本质上我使用 usize 作为大小为 size_of::<usize>() 的内存块。

如果这是安全的，下一步就是考虑更高级的操作。

unsafe trait PackedInt {}
unsafe impl PackedInt for u8  {}
unsafe impl PackedInt for i8  {}
unsafe impl PackedInt for u32 {}
unsafe impl PackedInt for i32 {}
unsafe impl PackedInt for u64 {}
unsafe impl PackedInt for i64 {}

impl<T: Copy + PackedInt> Atomic<T> {
    fn compare_and_swap(&self, current: T, new: T, order: Ordering) -> T {
        unsafe {
            Self::decode(self.0.compare_and_swap(
                Self::encode(current),
                Self::encode(new),
                order
            ))
        }
    }

    fn fetch_add(&self, val: T, order: Ordering) -> T {
        unsafe {
            Self::decode(self.0.fetch_add(Self::encode(val), order))
        }
    }

    fn fetch_sub(&self, val: T, order: Ordering) -> T {
        unsafe {
            Self::decode(self.0.fetch_sub(Self::encode(val), order))
        }
    }
}

这些当然在溢出时并不总是特别敏感（因为两个 "equal" 值可能由于 T 之外的位而比较不相等），但它们似乎仍然定义明确......我觉得。

那么，这样安全吗？为什么？

Answer 1

这几乎是安全的……但不完全是。您可能只想到人们将 Atomic 与整数和浮点数一起使用，但引用也是 Copy。用户在 Atomic<&&u32>.

上使用宽松的加载和存储很容易导致崩溃

附带说明一下，您的 fetch_add 和 fetch_sub 在大端系统上无法正常工作。

转换任意类型以使用的安全性

Safety of casting arbitrary types to usize

casting

atomic

undefined-behavior

rust