copy-channels 1.0.0

//! This is an alternative implementation of everything. Its upside is that it is
//! totally free of undefined behaviour. It has some downsides:
//! 1. It's essentially uses a custom memcpy implementation which may be slower
//! 2. It's UB to read T and write to some other type if T has padding bytes, so
//!    we need to restrict the set of types.
//!
//! Types must be [`Copyable`] (which is an unsafe trait defined here). Easiest is to
//! derive [`IntoBytes`] (re-published from the [`zerocopy`] crate):
//!
//! ```rust
//! use copy_channels::atomic::*;
//!
//! #[derive(Debug, Default, Clone, Copy, IntoBytes)]
//! struct MyValue {
//!   x: u32,
//!   y: u32,
//! }
//!
//! let (mut sender, mut receiver) = watch::channel(MyValue::default());
//! sender.send_replace(MyValue { x: 1, y: 2 });
//! assert!(receiver.has_changed().unwrap());
//! assert_eq!(receiver.get().x, 1);
//! ```

/// Marker trait for copyable types.
///
/// # Safety
/// Implement this trait only for types that may safely be cast and read
/// as a series of bytes. That means the type must not have any internal
/// padding.
pub unsafe trait Copyable: Copy {}

// zerocopy::IntoBytes is just that, and comes with a nice derive macro
pub use zerocopy::IntoBytes;
unsafe impl<T: Copy + IntoBytes> Copyable for T {}

use crate::loom::sync::atomic::{AtomicUsize, Ordering, Ordering::Relaxed, fence};
use std::marker::PhantomData;
use std::mem::{MaybeUninit, size_of};

pub struct SlotItem<T> {
    cell: AtomicUsize,
    _t: PhantomData<T>,
}

pub type Slot<T> = [SlotItem<T>];

fn allocate<T>(n_items: usize) -> Box<[SlotItem<T>]> {
    std::iter::repeat_with(|| SlotItem {
        cell: AtomicUsize::new(0),
        _t: PhantomData,
    })
    .take(n_items)
    .collect::<Vec<_>>()
    .into_boxed_slice()
}

const fn required_items<T>() -> usize {
    size_of::<T>().div_ceil(size_of::<usize>())
}

pub struct AtomicSlotable;
use super::Slotable;

impl<T: Copyable> Slotable<T> for AtomicSlotable {
    type Slot = Slot<T>;
    type SlotArrayItem = SlotItem<T>;

    fn boxed_uninit_single() -> Box<Self::Slot> {
        allocate::<T>(required_items::<T>())
    }

    fn read(slot: &Self::Slot, ordering: Ordering) -> std::mem::MaybeUninit<T> {
        let n = size_of::<T>() / size_of::<usize>();
        let mut value = MaybeUninit::<T>::uninit();
        let tgt = value.as_mut_ptr() as *mut usize;
        for (i, src) in slot[0..n].iter().enumerate() {
            let x = src.cell.load(Relaxed);
            // safety: write to locally allocated MaybeUninit
            unsafe {
                tgt.add(i).write_unaligned(x);
            }
        }
        let remain = size_of::<T>() % size_of::<usize>();
        if remain != 0 {
            let part = slot[n].cell.load(Relaxed).to_ne_bytes();
            // safety: write to locally allocated MaybeUninit
            unsafe {
                tgt.add(n)
                    .cast::<u8>()
                    .copy_from_nonoverlapping(part.as_ptr(), remain);
            }
        }
        if ordering != Relaxed {
            fence(ordering);
        }
        value
    }

    fn write(slot: &Self::Slot, value: T, ordering: Ordering) {
        if ordering != Relaxed {
            fence(ordering);
        }

        let n = size_of::<T>() / size_of::<usize>();
        let src = &value as *const T as *const usize;
        for (i, tgt) in slot[0..n].iter().enumerate() {
            // safety: value contains no padding, so we can read it and write into slot
            let x = unsafe { src.add(i).read_unaligned() };
            tgt.cell.store(x, Relaxed);
        }
        let remain = size_of::<T>() % size_of::<usize>();
        if remain != 0 {
            let mut part = [0u8; size_of::<usize>()];
            // safety: value contains no padding, so we can read it and write into slot
            unsafe {
                part.as_mut_ptr()
                    .copy_from_nonoverlapping(src.add(n) as *const u8, remain);
            }
            slot[n].cell.store(usize::from_ne_bytes(part), Relaxed);
        }
    }

    fn boxed_uninit_multiple(n: usize) -> Box<[Self::SlotArrayItem]> {
        let req = required_items::<T>() * n;
        allocate(req)
    }

    fn index_in_array(items: &[Self::SlotArrayItem], index: usize) -> &Self::Slot {
        let n = required_items::<T>();
        &items[index * n..(index + 1) * n]
    }
}

crate::impl_channels!(crate::atomic::AtomicSlotable, crate::atomic::Copyable);

#[cfg(test)]
mod tests {
    use super::*;

    fn test_rw<T: Copyable + PartialEq + std::fmt::Debug>(value: T) {
        let slot = AtomicSlotable::boxed_uninit_single();
        AtomicSlotable::write(&slot, value, Ordering::Relaxed);
        let readback: T = unsafe { AtomicSlotable::read(&slot, Ordering::Relaxed).assume_init() };
        assert_eq!(readback, value);
    }

    #[test]
    fn read_write_8() {
        #[derive(Clone, Copy, PartialEq, Debug, IntoBytes)]
        struct V(u64, u64, u32, u32);
        test_rw(V(1, 2, 3, 4));
    }

    #[test]
    fn read_write_4() {
        #[derive(Clone, Copy, PartialEq, Debug, IntoBytes)]
        struct V(u32, u32, u16, u16);
        test_rw(V(1, 2, 3, 4));
    }

    #[test]
    fn read_write_1() {
        #[derive(Clone, Copy, PartialEq, Debug, IntoBytes)]
        struct V(u8, u8);
        test_rw(V(1, 2));
    }
}