Struct SlabAllocator 

pub struct SlabAllocator<T, L: RawLock = RawMutex, const SLAB_SIZE: usize = DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE, const TRACK_OBJECT_COUNT: bool = false> { /* private fields */ }

A slab-style allocator for a given object type T.

Generics

• T: The type of object allocated by this allocator.
• L: The synchronization primitive (defaults to RawMutex).
• SLAB_SIZE: The size of each memory slab in bytes (defaults to 16KB).
• TRACK_OBJECT_COUNT: Enable allocation tracking (e.g. obj_count, max_obj_count).

Examples

Instanced Allocation with UniquePtr

use fbl::{
    SlabAllocator, RawMutex, impl_instanced_slab_allocatable, UniquePtr,
    DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE,
};
use core::cell::Cell;

use fbl::SlabOrigin;
struct MyObject {
    value: i32,
    // Required field for tracking origin
    slab_origin: SlabOrigin<MyObject, RawMutex, DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE>,
}

impl_instanced_slab_allocatable!(MyObject, RawMutex, DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE);

fn example() {
    let allocator = SlabAllocator::<
        MyObject, RawMutex, DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE
    >::try_new(4, true, RawMutex::INIT).unwrap();
    let mut list = std::collections::VecDeque::new();

    for i in 0..10 {
        let obj = allocator.new_unique(MyObject {
            value: i,
            slab_origin: SlabOrigin::new(),
        }).unwrap();
        list.push_front(obj);
    }
    // Memory is automatically returned to the allocator when elements are dropped.
}

Static Allocation with UniquePtr

use fbl::{
    SlabAllocator, RawMutex, impl_static_slab_allocatable, UniquePtr,
    DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE
};

struct MyObject {
    value: i32,
}

static MY_ALLOCATOR: SlabAllocator<MyObject, RawMutex, DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE> =
    SlabAllocator::const_new(64, RawMutex::INIT);

impl_static_slab_allocatable!(
    MyObject, RawMutex, DEFAULT_SLAB_ALLOCATOR_SLAB_SIZE, MY_ALLOCATOR);

fn example() {
    let obj = UniquePtr::try_new(MyObject { value: 42 }).unwrap();
    // obj will automatically recycle back to MY_ALLOCATOR.
}

Implementations

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

pub fn project<'__pin>( self: Pin<&'__pin mut Self>, ) -> SlabAllocatorProjection<'__pin, T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

Pin-projects all fields of Self.

These fields are structurally pinned:

• mu

These fields are not structurally pinned:

• free_list
• slab_list
• slab_count
• obj_count
• max_obj_count
• max_slabs
• _phantom

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

pub fn lock_mu( &self, ) -> impl PinInit<SlabAllocatorMuGuard<'_, T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>, Infallible>

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

pub const ALLOC_ALIGN: usize

pub const ALLOC_SIZE: usize

pub const STORAGE_OFFSET: usize

pub const ALLOCS_PER_SLAB: usize

The number of objects of type T that can fit in a single slab.

pub fn preallocate(&self) -> Result<(), AllocError>

Pre-allocates the first slab.

This can be used to guarantee O(1) execution times for all future allocations if max_slabs is at least 1.

pub const fn const_new(max_slabs: usize, lock: L) -> Self

Creates a new SlabAllocator that can be initialized in const contexts.

Note: Slabs are not pre-allocated during const-construction.

pub fn init(max_slabs: usize) -> impl PinInit<Self, Infallible>

Creates a new PinInit initializer for SlabAllocator for dynamic initialization.

pub fn alloc_raw(&self) -> Result<NonNull<T>, AllocError>

Allocates raw, uninitialized memory for a single object of type T.

pub unsafe fn return_to_free_list(&self, ptr: NonNull<T>)

Returns raw memory to the free list.

Safety

ptr must have been previously allocated from this allocator, and must not have been returned already.

pub fn new_unique(&self, value: T) -> Result<UniquePtr<T>, AllocError>

where T: Recyclable + InstancedSlabAllocated<L, SLAB_SIZE, TRACK_OBJECT_COUNT>,

Constructs an object in a UniquePtr using memory allocated from this instanced allocator.

pub fn new_ref(&self, value: T) -> Result<RefPtr<T>, AllocError>

where T: HasRefCount + Recyclable + InstancedSlabAllocated<L, SLAB_SIZE, TRACK_OBJECT_COUNT>,

Constructs a ref-counted object in a RefPtr using memory allocated from this instanced allocator.

pub unsafe fn delete(&self, ptr: NonNull<T>)

Destructs and deallocates an unmanaged object.

Safety

ptr must point to a valid object allocated from this allocator.

pub fn obj_count(&self) -> usize

Returns the number of currently allocated objects.

pub fn max_obj_count(&self) -> usize

Returns the maximum number of objects allocated simultaneously over the life of the allocator.

pub fn slab_count(&self) -> usize

Returns the number of slabs allocated.

pub fn max_slabs(&self) -> usize

Returns the maximum number of slabs this allocator is allowed to allocate.

pub fn reset_max_obj_count(&self)

Resets the maximum object count tracker to the current object count.

Trait Implementations

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> Drop for SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> HasPinData for SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

type PinData = __ThePinData<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

unsafe fn __pin_data() -> Self::PinData

impl<T, L: RawLock, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> PinnedDrop for SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

fn drop(self: Pin<&mut Self>, _: OnlyCallFromDrop)

Executes the pinned destructor of this type.

impl<T, L: RawLock + Send, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> Send for SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>

impl<T, L: RawLock + Sync, const SLAB_SIZE: usize, const TRACK_OBJECT_COUNT: bool> Sync for SlabAllocator<T, L, SLAB_SIZE, TRACK_OBJECT_COUNT>