Struct DepotAllocator 

pub struct DepotAllocator<A, S, const SLOTS: usize, const CAP: usize = 128, const DEPOT_CAP: usize = 512, I: InterruptControl = NoInterruptControl> { /* private fields */ }

A per-CPU magazine cache with a shared depot tier, over a backing physical allocator. This extends MagazineAllocator with a second, shared cache tier between the per-CPU magazines and the backend.

SLOTS is the number of per-CPU magazines, CAP each magazine’s depth, and DEPOT_CAP the shared depot’s capacity in frames. CpuId::current_cpu is taken modulo SLOTS. CAP defaults to 128, DEPOT_CAP to 512. I is the InterruptControl strategy for the magazine and depot locks; it defaults to NoInterruptControl. Multi-frame requests first use the backend unchanged. On backend OOM, the wrapper progressively returns cached frames and retries, preserving cache contents once the request becomes satisfiable.

Implementations

impl<A, S, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>

pub const fn new(base_frame: PageSize, backend: A) -> Self

Create a depot cache over backend. Call init_region before use.

base_frame must match the backend’s base frame size.

Examples found in repository

examples/basic.rs (line 163)

fn compose_with_depot() {
    /// Uniprocessor selector: every CPU maps to slot 0. A real kernel returns an
    /// APIC id / `TPIDR_EL1` here.
    struct OneCpu;
    impl CpuId for OneCpu {
        fn current_cpu() -> usize {
            0
        }
    }
    const SLOTS: usize = 8; // magazines (>= CPUs you want disjoint)

    // Same const-new composability: the whole stack is one `static`-able value.
    let mag: DepotAllocator<SummaryBuddyAllocator<ORDERS, IdentityProv>, OneCpu, SLOTS> =
        DepotAllocator::new(BASE, SummaryBuddyAllocator::new(BASE));

    let pool = Region::new(SPAN_FRAMES * BASE.bytes(), MAX_BLOCK);
    // SAFETY: as above; here the whole region is usable, so the single-range
    // convenience applies.
    unsafe { mag.init_region(pool.addr(), SPAN_FRAMES * BASE.bytes()) };

    println!("\n── DepotAllocator<SummaryBuddyAllocator> ──");
    let a = mag.allocate_physical(BASE, n(1)).expect("mag alloc");
    // SAFETY: `a` came from this allocator; freed once, then not reused by us.
    unsafe { mag.deallocate_physical(BASE, n(1), a) };
    let b = mag.allocate_physical(BASE, n(1)).expect("mag re-alloc");
    println!("alloc {a:#x} -> free -> alloc {b:#x}");
    assert_eq!(a, b, "the magazine should return the just-freed frame");
    println!("re-alloc returned the cached frame (no backend round-trip).");
    // SAFETY: final free of a live frame.
    unsafe { mag.deallocate_physical(BASE, n(1), b) };
}

impl<A: PhysicalAllocator, S: CpuId, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>

pub fn flush(&self)

Return the current bounded snapshot of every cache tier to the backend. No cache lock is held while invoking the backend. Concurrent frees may repopulate a tier after its snapshot is taken.

Trait Implementations

impl<A: PhysicalAllocator, S: CpuId, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> PhysicalAllocator for DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>

fn allocate_physical( &self, ps: PageSize, count: NonZeroUsize, ) -> Result<usize, AllocError>

Allocate count contiguous frames of size ps.

unsafe fn deallocate_physical( &self, ps: PageSize, count: NonZeroUsize, phys: usize, )

Return count contiguous frames of size ps starting at phys.

impl<A: RegionInit, S, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> RegionInit for DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>

unsafe fn try_init( &self, phys_base: usize, span_len: usize, usable: &[PhysRange], ) -> Result<(), InitError>

Configure metadata over [phys_base, phys_base + span_len) and mark only the usable ranges free. Holes stay reserved.

unsafe fn add_usable(&self, base: usize, len: usize)

Transition a reserved (never-freed) in-span range to free. Repeatable after try_init. base/len must satisfy the same per-range constraints as a usable entry.

unsafe fn init(&self, phys_base: usize, span_len: usize, usable: &[PhysRange])

As try_init but panic on error.

unsafe fn try_init_region( &self, phys_base: usize, len: usize, ) -> Result<(), InitError>

Convenience: initialise from a single fully-usable contiguous region [phys_base, phys_base + len).

unsafe fn init_region(&self, phys_base: usize, len: usize)

As try_init_region but panic on error.

impl<A: Send, S, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> Send for DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>

impl<A: Sync, S, const SLOTS: usize, const CAP: usize, const DEPOT_CAP: usize, I: InterruptControl> Sync for DepotAllocator<A, S, SLOTS, CAP, DEPOT_CAP, I>