[][src]Struct static_alloc::Slab

pub struct Slab<T> { /* fields omitted */ }

An allocator whose memory resource has static storage duration.

The type parameter T is used mostly to annotate the required size and alignment of the region and has no futher use. Note that in particular there is no safe way to retrieve or unwrap an inner instance even if the Slab was not constructed as a shared global static.

Usage as global allocator

You can use the stable rust attribute to use an instance of this type as the global allocator.

use static_alloc::Slab;

static A: Slab<[u8; 1 << 16]> = Slab::uninit();

fn main() { }

Take care, some runtime features of Rust will allocator some memory before or after your own code. In particular, it was found to be be tricky to find out more on the usage of the builtin test framework which seemingly allocates some structures per test.

Usage as a (local) bag of bits

It is of course entirely possible to use a local instance instead of a single global allocator. For example you could utilize the pointer interface directly to build a #[no_std] dynamic data structure in an environment without extern lib alloc. This feature was the original motivation behind the crate but no such data structures are provided here so a quick sketch of the idea must do:

use core::alloc;
use static_alloc::Slab;

struct PageTable {
    // some non-trivial type.

impl PageTable {
    pub unsafe fn new(into: *mut u8) -> &'static mut Self {
        // ...

// Allocator for pages for page tables. Provides 64 pages. When the
// program/kernel is provided as an ELF the bootloader reserves
// memory for us as part of the loading process that we can use
// purely for page tables. Replaces asm `paging: .BYTE <size>;`
static Paging: Slab<[u8; 1 << 18]> = Slab::uninit();

fn main() {
    let layout = alloc::Layout::new::<PageTable>();
    let memory = Paging.alloc(layout).unwrap();
    let table = unsafe {

A similar structure would of course work to allocate some non-'static' objects from a temporary Slab`.

More insights

WIP: May want to wrap moving values into an allocate region into a safe abstraction with correct lifetimes. This would include slices.


impl<T> Slab<T>[src]

pub const fn uninit() -> Self[src]

Make a new allocatable slab of certain byte size and alignment.

The storage will contain uninitialized bytes.

pub fn zeroed() -> Self[src]

Make a new allocatable slab of certain byte size and alignment.

The storage will contain zeroed bytes. This is not yet available as a const fn which currently limits its potential usefulness but there is no good reason not to provide it regardless.

pub const fn new(storage: T) -> Self[src]

Make a new allocatable slab provided with some bytes it can hand out.

Note that storage will never be dropped and there is no way to get it back.

pub fn alloc(&self, layout: Layout) -> Option<*mut u8>[src]

Allocate a region of memory.

This is a safe alternative to GlobalAlloc::alloc.


This function will panic if the requested layout has a size of 0. For the use in a GlobalAlloc this is explicitely forbidden to request and would allow any behaviour but we instead strictly check it.

Trait Implementations

impl<T> Sync for Slab<T>[src]

impl<T> GlobalAlloc for Slab<T>[src]

unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u81.28.0[src]

Behaves like alloc, but also ensures that the contents are set to zero before being returned. Read more

unsafe fn realloc(
    ptr: *mut u8,
    layout: Layout,
    new_size: usize
) -> *mut u8

Shrink or grow a block of memory to the given new_size. The block is described by the given ptr pointer and layout. Read more

Auto Trait Implementations

impl<T> Send for Slab<T> where
    T: Send

impl<T> Unpin for Slab<T> where
    T: Unpin

Blanket Implementations

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> From<T> for T[src]

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> Any for T where
    T: 'static + ?Sized