Compiler Explorer

Source code

use std::{
    mem::size_of,
    sync::atomic::*,
    cell::UnsafeCell,
};

#[derive(Clone, Copy)]
#[repr(align(8))]
pub struct A<T>(T);

// 01..09: same
// 09..17: -2 movups +4 mov
// 17..25: -2 movups +4 mov
// 25..33: -4 movups +8 mov
// 33..41: -4 movups +8 mov
// 41..49: -6 movups +12 mov
// 49..57: -6 movups +12 mov
// 57..65: -8 movups +16 mov
// 65..73: -8 movups +16 mov
// 73..81: -10 movups +20 mov
// 81..89: -10 movups +20 mov
// 89..97: -12 movups +24 mov
//
// 129..: -memcpy +mov
//
// 289..: -memcpy +loop
pub type Ty = A<[u8; 1]>;

#[inline(never)]
pub fn read(src: &UnsafeCell<Ty>, dst: &mut Ty) {
    *dst = unsafe { *src.get() };
}

#[inline(never)]
pub fn aread(src: &UnsafeCell<Ty>, dst: &mut Ty) {
    unsafe { atomic_read(src.get(), dst) }
}

#[inline(never)]
pub fn write(src: &Ty, dst: &UnsafeCell<Ty>) {
    unsafe { dst.get().write(*src) }
}

#[inline(never)]
pub fn awrite(src: &Ty, dst: &UnsafeCell<Ty>) {
    unsafe { atomic_write(src, dst.get()) }
}

unsafe fn atomic_read<T>(src: *const T, dst: *mut T) {
    let size = size_of::<T>();

let start = 0;
    let end = if align_of::<T>() >= align_of::<u64>() {
        size / size_of::<u64>()
    } else {
        0
    };
    {
        let src = src as *const AtomicU64;
        let dst = dst as *mut u64;

for offset in start..end {
            let src = unsafe { &*src.add(offset) };
            let dst = unsafe { dst.add(offset) };
            unsafe { dst.write(src.load(Ordering::Relaxed)) };
        }
    }

let start = end * size_of::<u64>() / size_of::<u32>();
    let end = if align_of::<T>() >= align_of::<u32>() {
        size / size_of::<u32>()
    } else {
        0
    };
    {
        let src = src as *const AtomicU32;
        let dst = dst as *mut u32;

let start = end * size_of::<u32>() / size_of::<u16>();
    let end = if align_of::<T>() >= align_of::<u16>() {
        size / size_of::<u16>()
    } else {
        0
    };
    {
        let src = src as *const AtomicU16;
        let dst = dst as *mut u16;

let start = end * size_of::<u16>() / size_of::<u8>();
    let end = size / size_of::<u8>();
    {
        let src = src as *const AtomicU8;
        let dst = dst as *mut u8;

for offset in start..end {
            let src = unsafe { &*src.add(offset) };
            let dst = unsafe { dst.add(offset) };
            unsafe { dst.write(src.load(Ordering::Relaxed)) };
        }
    }
}

unsafe fn atomic_write<T>(src: *const T, dst: *mut T) {
    let size = size_of::<T>();

let start = 0;
    let end = if align_of::<T>() >= align_of::<u64>() {
        size / size_of::<u64>()
    } else {
        0
    };
    {
        let src = src as *const u64;
        let dst = dst as *const AtomicU64;

for offset in start..end {
            let src = unsafe { *src.add(offset) };
            let dst = unsafe { &*dst.add(offset) };
            dst.store(src, Ordering::Relaxed);
        }
    }

let start = end * size_of::<u64>() / size_of::<u32>();
    let end = if align_of::<T>() >= align_of::<u32>() {
        size / size_of::<u32>()
    } else {
        0
    };
    {
        let src = src as *const u32;
        let dst = dst as *const AtomicU32;

for offset in start..end {
            let src = unsafe { *src.add(offset) };
            let dst = unsafe { &*dst.add(offset) };
            dst.store(src, Ordering::Relaxed);
        }
    }

let start = end * size_of::<u32>() / size_of::<u16>();
    let end = if align_of::<T>() >= align_of::<u16>() {
        size / size_of::<u16>()
    } else {
        0
    };
    {
        let src = src as *const u16;
        let dst = dst as *const AtomicU16;

for offset in start..end {
            let src = unsafe { *src.add(offset) };
            let dst = unsafe { &*dst.add(offset) };
            dst.store(src, Ordering::Relaxed);
        }
    }

let start = end * size_of::<u16>() / size_of::<u8>();
    let end = size / size_of::<u8>();
    {
        let src = src as *const u8;
        let dst = dst as *const AtomicU8;

for offset in start..end {
            let src = unsafe { *src.add(offset) };
            let dst = unsafe { &*dst.add(offset) };
            dst.store(src, Ordering::Relaxed);
        }
    }
}