Constructing a !Sized UnsafeCell

[DzenanJupic]

Constructing a !Sized UnsafeCell

[Darksonn]

I recommend that you use a type like this one:

use loom::cell::UnsafeCell as LoomCell;
use std::cell::UnsafeCell as StdCell;
use std::mem::MaybeUninit;

struct CellSlice<T> {
    inner: LoomCell<Box<StdCell<[MaybeUninit<T>]>>>,
}

impl<T> CellSlice<T> {
    fn with<F, R>(&self, f: F) -> R
    where
        F: FnOnce(*const T, usize) -> R,
    {
        self.inner.with(|ptr| {
            let ptr = unsafe { StdCell::raw_get(&**ptr) };
            let len = unsafe { (*ptr).len() };
            f(ptr.cast(), len)
        })
    }

    fn with_mut<F, R>(&self, f: F) -> R
    where
        F: FnOnce(*mut T, usize) -> R,
    {
        self.inner.with_mut(|ptr| {
            let ptr = unsafe { StdCell::raw_get(&**ptr) };
            let len = unsafe { (*ptr).len() };
            f(ptr.cast(), len)
        })
    }
}

[DzenanJupic]

Wouldn't that lead to a test failure in case someone is reading the already initialized elements, while someone else is writing a new element? [playground]

CellSlice

use loom::cell::UnsafeCell as LoomCell;
use std::cell::UnsafeCell as StdCell;
use std::mem::{self, MaybeUninit};

struct CellSlice<T> {
    inner: LoomCell<Box<StdCell<[MaybeUninit<T>]>>>,
}

#[allow(dead_code)]
impl<T> CellSlice<T> {
    fn new() -> Self {
        let boxed: Box<StdCell<[MaybeUninit<T>]>> = unsafe {
            let boxed = mem::ManuallyDrop::new(Vec::<T>::new().into_boxed_slice());
            std::ptr::read(&boxed as *const _ as *const _)
        };

        Self {
            inner: LoomCell::new(boxed),
        }
    }

    fn with<F, R>(&self, f: F) -> R
        where
            F: FnOnce(*const T, usize) -> R,
    {
        self.inner.with(|ptr| {
            let ptr = unsafe { StdCell::raw_get(&**ptr) };
            let len = unsafe { (*ptr).len() };
            f(ptr.cast(), len)
        })
    }

    fn with_mut<F, R>(&self, f: F) -> R
        where
            F: FnOnce(*mut T, usize) -> R,
    {
        self.inner.with_mut(|ptr| {
            let ptr = unsafe { StdCell::raw_get(&**ptr) };
            let len = unsafe { (*ptr).len() };
            f(ptr.cast(), len)
        })
    }
}

#[test]
fn concurrent_read_and_write() {
    loom::model(|| {
        let cell_slice = std::sync::Arc::new(CellSlice::<String>::new());

        let read = {
            let cell_slice = cell_slice.clone();
            loom::thread::spawn(move || {
                let _ = cell_slice.with(|_, _| {});
            })
        };
        let write = {
            let cell_slice = cell_slice.clone();
            loom::thread::spawn(move || {
                let _ = cell_slice.with_mut(|_, _| {});
            })
        };

        read.join().unwrap();
        write.join().unwrap();
    });
}

[Darksonn]

True, it would not work with per-field concurrency checking. To do that, perhaps you could use a struct like this:

struct CellSlice<T> {
    fields: Box<StdCell<[MaybeUninit<T>]>>,
    loom_check: Box<[LoomCell<()>]>,
}

Then, when accessing field i, you do so inside a with or with_mut call on the ith cell in loom_check.

[DzenanJupic]

That's perfect, thanks. Even allows to keep using the 'normal' UnsafeCell interface. Should have thought about that earlier.