[Suggestion]: Implement `alloc::alloc::Allocator` Trait with Problem.

[lvyuemeng]

Description

I want to use the experiment feature allocator_api by implement the trait Allocator for Arena.
Here my code:

use rarena_allocator::Allocator as RAllocator;

unsafe impl Allocator for ShmArena {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
        let size = layout.size();
        RAllocator::alloc_aligned_bytes_owned::<u8>(&self.0, size as u32)
            .map(|b| b.deref().into())
            .map_err(|_| core::alloc::AllocError)
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        let size = layout.size();
        unsafe {
            let offset = RAllocator::offset(&self.0, ptr.as_ptr());
            RAllocator::dealloc(&self.0, offset as u32, size as u32);
        }
    }
}

But it turns out a wrong approach, I try to test it with:

        // shm_arena: Arena;
        let layout = Layout::new::<u8>();
        unsafe {
            let m: NonNull<u8> = shm_arena.allocate(layout).unwrap().cast();
            let data = m.as_ptr();
            let mut b = Box::from_raw_in(data, shm_arena.clone());
            *b = 2; // <- panic!
            assert_eq!(*b, 2);
        }

        // shm_arena: Arena;
        let layout = Layout::new::<u8>();
        unsafe {
            let m: NonNull<u8> = shm_arena.allocate(layout).unwrap().cast();
            m.write(1); // <- panic!
        }

Which yields (exit code: 0xc0000005, STATUS_ACCESS_VIOLATION).

I don't know how to implement a correct version for alloc::Allocator, it would be better to be implemented natively.

[al8n]

You should invoke detach, by default, the buffer allocated from Arena will automatically be garbage collected when the buffer is dropped.

unsafe impl Allocator for ShmArena {
    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
        let size = layout.size();
        RAllocator::alloc_aligned_bytes_owned::<u8>(&self.0, size as u32)
            .map(|mut b| {
                b.detach();
                NonNull::new_unchecked(b.as_mut_ptr())
            })
            .map_err(|_| core::alloc::AllocError)
    }

    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
        let size = layout.size();
        unsafe {
            let offset = RAllocator::offset(&self.0, ptr.as_ptr());
            RAllocator::dealloc(&self.0, offset as u32, size as u32);
        }
    }
}

[lvyuemeng]

@al8n
Your code won't yield correct type due to the type of b.as_mut_ptr() is u8 rather [u8], I try to amend this by previous b.deref().into().

    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
        let size = layout.size();
        RAllocator::alloc_aligned_bytes_owned::<u8>(&self.0, size as u32)
            .map(|mut b| unsafe {
                b.detach();
                b.deref().into()
            })
            .map_err(|_| core::alloc::AllocError)
    }

Here is the modified code. But it's still incorrect. The test code reports same error.

[lvyuemeng]

Addition

This code is incorrect if allocate() contains detach(), else it's correct.

        // shm_arena: Arena;
        unsafe {
            let arr = shm_arena.allocate(layout).unwrap().as_mut();
            for slot in arr.iter_mut() {
                *slot = 1;
            }
            for slot in arr.iter() {
                assert_eq!(*slot, 1);
            }
        }

[lvyuemeng]

It seems that achieve the alloc::Allocator trait to allocate data would breaking the send+sync
advantage from Owned 🤔, but I don't know how to reconcile this.

Maybe a related issue upon could refactor such experiment feature.

[lvyuemeng]

@al8n Is there a nightly feature to develop this or such problem haven't solved yet?
I would like to see this, but it has been 6 months after last update.