Struct TalcCell 

pub struct TalcCell<S: Source, B: Binning> { /* private fields */ }

TalcCell implements GlobalAlloc and Allocator without locking, but is !Sync.

This type has similar semantics to a Cell.

Example

use allocator_api2::alloc::{Allocator, Layout};
use allocator_api2::vec::Vec;
use talc::{TalcCell, source::*};

static mut HEAP: [u8; 2048] = [0; 2048];

let talc = TalcCell::new(unsafe { Claim::array(&raw mut HEAP) });

let mut my_vec = Vec::<u32, _>::with_capacity_in(42, &talc);
my_vec.push(123);

Safety

TalcCell’s API does not expose references to the inner Talc within an UnsafeCell and is !Sync, so it’s safe to mutate the inner data through a shared reference.

There is an exception to this; a reference to the inner Talc is exposed to sources. Source is thus an unsafe trait to implement, and the implementation must uphold that they don’t use the TalcCell/TalcLock directly or indirectly (e.g. calling dbg! in Source::resize when TalcLock is the global allocator) in the implementation. This requirement is not unique to TalcCell. If TalcLock is used in the source impl, it’ll deadlock.

To help catch bad Source implementations, TalcCell tracks borrows when debug_assertions are enabled, similar to a RefCell.

Implementations

impl<S: Source, B: Binning> TalcCell<S, B>

pub const fn new(source: S) -> Self

Create a new TalcCell.

pub fn get_mut(&mut self) -> &mut Talc<S, B>

Returns a mutable reference to the inner Talc.

pub fn into_inner(self) -> Talc<S, B>

Consumes the TalcCell, returning the inner Talc.

pub fn replace_source(&self, source: S) -> S

Swaps out the source for another.

If you just want to clone the source, see TalcCell::clone_source.

pub fn counters(&self) -> Counters

Available on crate feature counters only.

Obtain the inner allocation statistics.

pub unsafe fn reserved(&self, heap_end: NonNull<u8>) -> Reserved

See Talc::reserved for documentation details.

pub unsafe fn claim(&self, base: *mut u8, size: usize) -> Option<NonNull<u8>>

See Talc::claim for documentation details.

pub unsafe fn extend( &self, heap_end: NonNull<u8>, new_end: *mut u8, ) -> NonNull<u8>

See Talc::extend for documentation details.

pub unsafe fn truncate( &self, heap_end: NonNull<u8>, new_end: *mut u8, ) -> Option<NonNull<u8>>

See Talc::truncate for documentation details.

pub unsafe fn resize( &self, heap_end: NonNull<u8>, new_end: *mut u8, ) -> Option<NonNull<u8>>

See Talc::resize for documentation details.

impl<S: Source + Clone, B: Binning> TalcCell<S, B>

pub fn clone_source(&self) -> S

Returns a clone of Talc’s source.

To set the source instead, use TalcCell::replace_source.

Trait Implementations

impl<S: Source, B: Binning> Allocator for TalcCell<S, B>

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

Attempts to allocate a block of memory.

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

Deallocates the memory referenced by ptr.

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

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

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

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

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

Attempts to extend the memory block.

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

Attempts to shrink the memory block.

fn by_ref(&self) -> &Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Allocator.

impl<S: Debug + Source, B: Debug + Binning> Debug for TalcCell<S, B>

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

Formats the value using the given formatter.

impl<S: Source, B: Binning> GlobalAlloc for TalcCell<S, B>

unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocates memory as described by the given layout.

unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)

Deallocates the block of memory at the given ptr pointer with the given layout.

unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

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

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

Shrinks or grows a block of memory to the given new_size in bytes. The block is described by the given ptr pointer and layout.