Struct ring_alloc::RingAlloc

#[repr(transparent)]
pub struct RingAlloc<A: Allocator = Global> { /* private fields */ }

Thread-local ring-allocator.

This allocator uses underlying allocator to allocate memory chunks.

Allocator uses ring buffer of chunks to allocate memory in front chunk, moving it to back if chunk is full. If next chunk is still occupied by previous allocation, allocator will allocate new chunk.

Implementations

impl RingAlloc

pub fn new() -> Self

Returns new RingAlloc that uses [Global] allocator.

impl<A> RingAlloc<A>where A: Allocator,

pub fn new_in(allocator: A) -> Self

Returns new RingAlloc that uses given allocator.

pub fn try_new_in(allocator: A) -> Result<Self, AllocError>

Attempts to create new RingAlloc that uses given allocator.

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

Attempts to allocate a block of memory with this ring-allocator. Returns a pointer to the beginning of the block if successful.

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

Deallocates the memory referenced by ptr.

Safety

• ptr must denote a block of memory currently allocated via RingAlloc::allocate, and
• layout must fit that block of memory.

pub fn flush(&self)

Free all unused chunks back to underlying allocator.

Trait Implementations

impl<A> Allocator for RingAlloc<A>where A: Allocator,

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( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout ) -> Result<NonNull<[u8]>, AllocError>

Attempts to extend the memory block.

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 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) -> &Selfwhere Self: Sized,

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

impl<A> Clone for RingAlloc<A>where A: Allocator,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Default for RingAlloc<A>where A: Allocator + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<A> Drop for RingAlloc<A>where A: Allocator,

fn drop(&mut self)

Executes the destructor for this type.

impl<A> Hash for RingAlloc<A>where A: Allocator,

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<A> PartialEq<RingAlloc<A>> for RingAlloc<A>where A: Allocator,

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.