Struct alloc_compose::FallbackAlloc

pub struct FallbackAlloc<Primary, Fallback> {
    pub primary: Primary,
    pub fallback: Fallback,
}

An allocator equivalent of an "or" operator in algebra.

An allocation request is first attempted with the Primary allocator. If that fails, the request is forwarded to the Fallback allocator. All other requests are dispatched appropriately to one of the two allocators.

A FallbackAlloc is useful for fast, special-purpose allocators backed up by general-purpose allocators like Global or System.

Example

#![feature(allocator_api)]

use alloc_compose::{FallbackAlloc, Owns, Region};
use std::alloc::{AllocInit, AllocRef, Layout, System};

let mut data = [0; 32];
let mut alloc = FallbackAlloc {
    primary: Region::new(&mut data),
    fallback: System,
};

let small_memory = alloc.alloc(Layout::new::<u32>(), AllocInit::Uninitialized)?;
let big_memory = alloc.alloc(Layout::new::<[u32; 64]>(), AllocInit::Uninitialized)?;

assert!(alloc.primary.owns(small_memory));
assert!(!alloc.primary.owns(big_memory));

unsafe {
    // `big_memory` was allocated from `System`, we can dealloc it directly
    System.dealloc(big_memory.ptr, Layout::new::<[u32; 64]>());
    alloc.dealloc(small_memory.ptr, Layout::new::<u32>());
};

Fields

primary: Primary

The primary allocator

fallback: Fallback

The fallback allocator

Trait Implementations

impl<Primary, Fallback> AllocRef for FallbackAlloc<Primary, Fallback> where
    Primary: AllocRef + Owns,
    Fallback: AllocRef, 

fn alloc(
    &mut self,
    layout: Layout,
    init: AllocInit
) -> Result<MemoryBlock, AllocErr>

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

Attempts to allocate a block of memory.

unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout)

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

Deallocates the memory referenced by ptr.

unsafe fn grow(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize,
    placement: ReallocPlacement,
    init: AllocInit
) -> Result<MemoryBlock, AllocErr>

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

Attempts to extend the memory block.

unsafe fn shrink(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize,
    placement: ReallocPlacement
) -> Result<MemoryBlock, AllocErr>

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

Attempts to shrink the memory block.

fn by_ref(&mut self) -> &mut Self

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

Creates a "by reference" adaptor for this instance of AllocRef.

impl<Primary: Clone, Fallback: Clone> Clone for FallbackAlloc<Primary, Fallback>

fn clone(&self) -> FallbackAlloc<Primary, Fallback>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Primary: Copy, Fallback: Copy> Copy for FallbackAlloc<Primary, Fallback>

impl<Primary: Debug, Fallback: Debug> Debug for FallbackAlloc<Primary, Fallback>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Primary, Fallback> Owns for FallbackAlloc<Primary, Fallback> where
    Primary: Owns,
    Fallback: Owns, 

fn owns(&self, memory: MemoryBlock) -> bool

Returns if the allocator owns the passed MemoryBlock.