Struct FixedSizeAllocator

pub struct FixedSizeAllocator<const S: usize, const N: usize> { /* private fields */ }

Implementations

impl<const S: usize, const N: usize> FixedSizeAllocator<S, N>

where Assert<{ _ }>: IsTrue,

pub unsafe fn new_unpinned(zero_initialized: bool) -> Self

Construct a new fixed-size allocator on the stack and return it. Optionally, you can initialize the heap with 0 bytes by setting the zero_initialized flag. !This doesn’t mean that the allocator is initialized! The returned allocator struct must immediately be pinned via pin!(). Using an unpinned allocator created on the stack is undefined behavior. This function is marked as unsafe because it’s the programmer’s responsibility to correctly instantiate and pin an allocator on the stack.

pub fn new(zero_initialized: bool) -> Pin<Box<Self>>

Create a new fixed-size allocator on the heap using the standard system allocator. Optionally, you can initialize the heap with 0 bytes by setting the zero_initialized flag. Note that the returned allocator is pinned, meaning it cannot be moved once it’s created. This is why a Pin<Box<>> is returned instead.

pub const fn heap_size(&self) -> usize

Return the total size of the heap in bytes.

pub const fn block_count(&self) -> usize

Return the total number of memory blocks.

pub const fn block_size(&self) -> usize

Return the size of a memory block.

pub const fn total_free(&self) -> usize

Return the total amount of free memory in bytes.

pub const fn total_allocated(&self) -> usize

Return the total amount of memory allocated in bytes.

pub fn free_blocks(&self) -> usize

Return how many blocks are free.

pub fn allocated_blocks(&self) -> usize

Return how many blocks are allocated (not free).

pub unsafe fn alloc_untyped(self: Pin<&mut Self>) -> Option<NonNull<u8>>

pub fn alloc<T>(self: Pin<&mut Self>) -> Option<NonNull<T>>

where Assert<{ _ }>: IsTrue,

Try to allocate a memory block of that fits T, where T is S-sized.

pub fn free_nonnull<T>( self: Pin<&mut Self>, ptr: NonNull<T>, ) -> Result<(), FreeError>

Free the given non-null pointer. Note that the pointer must be aligned to the block’s start address.

pub fn free<T>(self: Pin<&mut Self>, ptr: *const T) -> Result<(), FreeError>

Free the given pointer. Note that the pointer must be aligned to the block’s start address.

pub unsafe fn free_all(self: Pin<&mut Self>)

Free all the memory blocks. This function is inherently unsafe because it invalidates all pointers to previously allocated blocks.