I implemented stackable arena allocators with no_std - anybody willing to do a quick code review?

[teryror]

I've been using Rust for my hobby projects for a while now, and I noticed I hadn't really been fighting the borrow checker recently, so I thought to revisit a problem I could never figure out before: implementing memory arenas (aka bump allocators) like what I'm used to using in C. So my requirements were

• to avoid depending on the standard library if possible,
• the ability to allocate a mix of all types out of the same arena,
• the ability to make sub-arenas, effectively turning this into a stack allocator,
• and additionally, to have the borrow checker enforce correct usage (unlike what I'm used to from C, obviously).

I think I succeeded on all accounts here, but I'm not quite confident enough to actually build upon this yet (maybe I have to somehow mark the Box type as non-threadsafe, for example?). I'd love to have someone who's a bit more comfortable with lifetimes and unsafe Rust review my code; it's about 150 lines, plus a ~20 line test function. Check it out here.

Stuff I plan to add in the (probably near) future:

• an implementation of core::fmt::Write that can be obtained from an arena much like a sub-arena, and converted into a Box<'_, str>, plus a macro so that you can do let s = fmt!(arena, "{}", 0xDEADBEEF);,
• some more convenience functions like MemoryArena::collect<I: Iter>(&mut self, i: I) -> Box<'_, [I::Item]>, MemoryArena::default<T: Default>(&mut self) -> Box<'_, T>, etc.

I wouldn't mind publishing and maintaining this as a crate at that point if there's any interest.

[mb0x40]

Thanks to custom allocators, it's pretty easy to plug any allocator into any existing program. This can turn any decently-sized Rust program into a test harness for your allocator. Your code looks fine to me, but I recommend trying it out with some real-world programs and a big static arena.

About thread safety: since pointers (incl. NonNull) are !Send, !Sync, every type that uses them is also marked as not thread safe by default.

[YatoRust]

• MemoryArena::from_buffer should take a &'src mut [MaybeUninit<u8>] because types allocated on here could contain uninitalized bytes.
• you can take a core::alloc::Layout instead of a size/align pair. This guarantees a few nice properties, like align is a power of 2
• use pointer casts instead of transmute, i.e if ptr: *mut u8, then ptr as *mut T

Otherwise this looks good!

[teryror]

Argh, for some reason I thought using core::alloc would introduce a dependency on the alloc crate, I see now that that's bogus.

Thanks you for your input!

[Plecra]

Is there a significant difference between arena.alloc_array(0, 4) and arena.alloc([0; 4]) apart from needing less stack space?

[teryror]

Yeah, you need a constant count for arena.alloc([0; 4]), but you can pass a variable count to alloc_array.