Crate light_arena [−] [src]
A lightweight, placement based memory arena for any types which are Sized + Copy
.
This crate uses the placement in syntax and placement new protocol and
thus requires nightly Rust.
This crate is written to solve a specific problem I have in
tray_rust, where I want to
store trait objects and f32 arrays in a memory arena which is then reset
and reused for each pixel rendered (but not free'd and reallocated!).
The key features to enable this are the use of the nightly placement new feature, letting us
actually construct objects in place instead of copying from a stack temporary,
and reusing the previously allocated space via the Allocator
scopes.
If you have a similar problem, this might be the right crate for you!
Examples
Allocations in a MemoryArena
are made using an allocator and the
placement in syntax. The Allocator
grants exclusive access to the
arena while it's in scope, allowing to make allocations. Once the Allocator
is dropped the space used is marked available again for subsequent allocations.
Note that Drop is never called on objects allocated in the arena,
and thus the restriction that T: Sized + Copy
.
#![feature(placement_in_syntax)] use light_arena; let mut arena = light_arena::MemoryArena::new(8); let alloc = arena.allocator(); // This would overflow the stack without placement new! let bytes: &[u8] = &alloc <- [0u8; 8 * 1024 * 1024];
The arena is untyped and can store anything which is Sized + Copy
.
#![feature(placement_in_syntax)] trait Foo { fn speak(&self); } #[derive(Copy, Clone)] struct Bar(i32); impl Foo for Bar { fn speak(&self) { println!("Bar! val = {}", self.0); } } #[derive(Copy, Clone)] struct Baz; impl Foo for Baz { fn speak(&self) { println!("Baz!"); } } let mut arena = light_arena::MemoryArena::new(2); let allocator = arena.allocator(); let a: &Foo = &allocator <- Baz; let b: &Foo = &allocator <- Bar(10); let c: &Foo = &allocator <- Bar(14); a.speak(); b.speak(); c.speak(); // Storing 0-sized types can give some interesting results println!("a = {:p}", a as *const Foo); println!("b = {:p}", b as *const Foo); println!("c = {:p}", c as *const Foo);
Blockers
- placement_in_syntax and placement_new_protocol are required, see https://github.com/rust-lang/rust/issues/27779
Structs
Allocator |
The allocator provides exclusive access to the memory arena, allowing for allocation of objects in the arena. |
AllocatorPlacer |
Object representing a place to put a newly requested allocation. |
MemoryArena |
Provides the backing storage to serve allocations requested by an |