Struct alloc_compose::Fallback

pub struct Fallback<Primary, Secondary> {
    pub primary: Primary,
    pub secondary: Secondary,
}

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 Fallback is useful for fast, special-purpose allocators backed up by general-purpose allocators like Global or System.

Example

#![feature(allocator_api, slice_ptr_get)]

use alloc_compose::{region::Region, Fallback, Owns};
use std::{
    alloc::{AllocRef, Layout, System},
    mem::MaybeUninit,
};

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

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

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.as_non_null_ptr(), Layout::new::<[u32; 64]>());
    alloc.dealloc(small_memory.as_non_null_ptr(), Layout::new::<u32>());
};

Fields

primary: Primary

The primary allocator

secondary: Secondary

The fallback allocator

Trait Implementations

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

pub fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

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

Attempts to allocate a block of memory.

pub fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

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

Behaves like alloc, but also ensures that the returned memory is zero-initialized.

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

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

Deallocates the memory referenced by ptr.

pub unsafe fn grow(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

Attempts to extend the memory block.

pub unsafe fn grow_zeroed(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

Behaves like grow, but also ensures that the new contents are set to zero before being returned.

pub unsafe fn shrink(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

Attempts to shrink the memory block.

pub fn by_ref(&self) -> &Self

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

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

pub fn owns(&self, memory: NonNull<[u8]>) -> bool

Returns if the allocator owns the passed memory.