Struct OneRingAlloc

pub struct OneRingAlloc;

Global ring-allocator.

This allocator uses global 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.

This type is ZST and data is stored in static variables, removing size overhead in collections.

Each thread will use thread-local rings to rotate over chunks. On thread exit all unused chunks are freed and the rest is moved to global ring.

When thread-local ring cannot allocate memory it will steal global ring or allocate new chunk from global allocator if global ring is empty.

Implementations

impl OneRingAlloc

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

Attempts to allocate a block of memory with global 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 [allocate] or OneRingAlloc::allocate, and
• layout must fit that block of memory.

pub fn clean_global(&self)

Cleans global shared rings.

When thread exists it frees all chunks that it allocated, except those that are still in use by currently allocated blocks. Chunks that are still in use are put to global shared rings.

Those get stolen by thread if thread needs new chunk.

This function frees all chunks that are in global shared rings if they are not in use by currently allocated blocks.

This function may reduce memory overhead if threads exist and blocks allocated by them is freed later, while all other threads are warm.

pub fn clean_local(&self)

Cleans local rings.

Thread frees chunks that it allocated when it exists. While thread is running chunks are stored in thread-local rings and reused in circular manner without deallocation.

This method frees all chunks that are not in use by currently allocated blocks in the local rings. Call this when thread’s memory usage drops significantly and you want to reduce memory overhead.

Trait Implementations

impl Allocator for OneRingAlloc

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) -> &Self

where Self: Sized,

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

impl Clone for OneRingAlloc

fn clone(&self) -> OneRingAlloc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OneRingAlloc

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

Formats the value using the given formatter.

impl Default for OneRingAlloc

fn default() -> OneRingAlloc

Returns the “default value” for a type.

impl Hash for OneRingAlloc

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 Ord for OneRingAlloc

fn cmp(&self, other: &OneRingAlloc) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for OneRingAlloc

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for OneRingAlloc

fn partial_cmp(&self, other: &OneRingAlloc) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for OneRingAlloc

impl Eq for OneRingAlloc

impl StructuralPartialEq for OneRingAlloc