no-std
compatible, thread-safe fixed-size memory allocator
slaballoc: A Do you need to allocate objects of a single type on a bare-metal system using #[no_std]
?
Do you have the requirement that an allocator be concurrently accessed from multiple
threads or CPU cores?
Look no further!
This crate provides a lockless no_std
compatible slab allocator, for fixed-size
allocations.
This slab allocator takes a fixed-size block of memory, as well as a [Sized] type for allocations. The slab allocator will partition the block of memory into two parts: an area for allocated objects, and an area for an allocation bitmap.
The bitmap will have a bit size of mem_size / size_of::<T>()
, such that there
is a bit for every possible slot that an object can take.
So, for a 4096 byte block of memory and objects that are 16 bytes each, the
bitmap will take 256 bits, or 32 bytes.
| objects........................................ - bitmap |
Note that the bitmap will be a little larger than necessary because it accounts for the entire block of memory (including the part that it takes up). This can be accounted for, but it's an annoying self-dependency so it'll take some iterations.
The allocation bitmap can then be accessed locklessly using atomic intrinsics. When allocating, we'll simply set a bit in the bitmap, and if successful, return the memory corresponding to that bit. When deallocating, we can simply unset the bit and the memory is freed.
Alternatives
If you're using Rust on a hosted environment with std
available, you might
be interested in using sharded-slab instead. That crate gets you the same
semantics as this one, without having to used a fixed-size memory block.