Struct alloc_compose::Proxy

pub struct Proxy<A, C> {
    pub alloc: A,
    pub callbacks: C,
}

Calls the provided callbacks when invoking methods on AllocRef.

A typical use case for a Proxy allocator is collecting statistics. alloc-compose provides different implementations for CallbackRef.

Examples

#![feature(allocator_api, slice_ptr_get)]

use alloc_compose::{stats, CallbackRef, Proxy};
use std::alloc::{AllocRef, Layout, System};

let counter = stats::Counter::default();
let mut alloc = Proxy {
    alloc: System,
    callbacks: counter.by_ref(),
};

unsafe {
    let memory = alloc.alloc(Layout::new::<u32>())?;
    alloc.dealloc(memory.as_non_null_ptr(), Layout::new::<u32>());
}

assert_eq!(counter.num_allocs(), 1);
assert_eq!(counter.num_deallocs(), 1);

If more information is needed, one can either implement CallbackRef itself or use a more fine-grained callback:

use alloc_compose::{
    region::Region,
    stats::{AllocInitFilter, ResultFilter},
};
use core::mem::MaybeUninit;

let counter = stats::FilteredCounter::default();
let mut data = [MaybeUninit::new(0); 32];
let mut alloc = Proxy {
    alloc: Region::new(&mut data),
    callbacks: counter.by_ref(),
};

unsafe {
    let memory = alloc.alloc(Layout::new::<u32>())?;
    alloc.dealloc(memory.as_non_null_ptr(), Layout::new::<u32>());

    alloc.alloc_zeroed(Layout::new::<[u32; 64]>()).unwrap_err();
}

assert_eq!(counter.num_allocates(), 2);
assert_eq!(
    counter.num_allocates_filter(AllocInitFilter::None, ResultFilter::Ok),
    1
);
assert_eq!(
    counter.num_allocates_filter(AllocInitFilter::Zeroed, ResultFilter::Err),
    1
);

Fields

alloc: A

callbacks: C

Trait Implementations

impl<A: AllocRef, C: CallbackRef> AllocRef for Proxy<A, C>

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<A: AllocateAll, C: CallbackRef> AllocateAll for Proxy<A, C>

pub fn allocate_all(&self) -> Result<NonNull<[u8]>, AllocError>

Attempts to allocate all of the memory the allocator can provide.

pub fn allocate_all_zeroed(&self) -> Result<NonNull<[u8]>, AllocError>

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

pub fn deallocate_all(&self)

Deallocates all the memory the allocator had allocated.

pub fn capacity(&self) -> usize

Returns the total capacity available in this allocator.

pub fn capacity_left(&self) -> usize

Returns the free capacity left for allocating.

pub fn is_empty(&self) -> bool

Returns if the allocator is currently not holding memory.

pub fn is_full(&self) -> bool

Returns if the allocator has no more capacity left.

impl<A: Clone, C: Clone> Clone for Proxy<A, C>

pub fn clone(&self) -> Proxy<A, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy, C: Copy> Copy for Proxy<A, C>

impl<A: Debug, C: Debug> Debug for Proxy<A, C>

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

Formats the value using the given formatter.

impl<A: Eq, C: Eq> Eq for Proxy<A, C>

impl<A: Hash, C: Hash> Hash for Proxy<A, C>

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<A: Ord, C: Ord> Ord for Proxy<A, C>

pub fn cmp(&self, other: &Proxy<A, C>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<A: Owns, C: CallbackRef> Owns for Proxy<A, C>

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

Returns if the allocator owns the passed memory.

impl<A: PartialEq, C: PartialEq> PartialEq<Proxy<A, C>> for Proxy<A, C>

pub fn eq(&self, other: &Proxy<A, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Proxy<A, C>) -> bool

This method tests for !=.

impl<A: PartialOrd, C: PartialOrd> PartialOrd<Proxy<A, C>> for Proxy<A, C>

pub fn partial_cmp(&self, other: &Proxy<A, C>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Proxy<A, C>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Proxy<A, C>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Proxy<A, C>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Proxy<A, C>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A: ReallocateInPlace, C: CallbackRef> ReallocateInPlace for Proxy<A, C>

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

Attempts to extend the memory block.

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

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

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

Attempts to shrink the memory block.

impl<A, C> StructuralEq for Proxy<A, C>

impl<A, C> StructuralPartialEq for Proxy<A, C>