Struct MemoryConsumer 

pub struct MemoryConsumer { /* private fields */ }

A memory consumer is a named allocation traced by a particular MemoryReservation in a MemoryPool. All allocations are registered to a particular MemoryConsumer;

Each MemoryConsumer is identifiable by a process-unique id, and is therefor not cloneable, If you want a clone of a MemoryConsumer, you should look into MemoryConsumer::clone_with_new_id, but note that this MemoryConsumer may be treated as a separate entity based on the used pool, and is only guaranteed to share the name and inner properties.

For help with allocation accounting, see the proxy module.

Implementations

impl MemoryConsumer

pub fn new(name: impl Into<String>) -> Self

Create a new empty MemoryConsumer that can be grown using MemoryReservation

pub fn clone_with_new_id(&self) -> Self

Returns a clone of this MemoryConsumer with a new unique id, which can be registered with a MemoryPool, This new consumer is separate from the original.

pub fn id(&self) -> usize

Return the unique id of this MemoryConsumer

pub fn with_can_spill(self, can_spill: bool) -> Self

Set whether this allocation can be spilled to disk

pub fn can_spill(&self) -> bool

Returns true if this allocation can spill to disk

pub fn name(&self) -> &str

Returns the name associated with this allocation

pub fn register(self, pool: &Arc<dyn MemoryPool>) -> MemoryReservation

Registers this MemoryConsumer with the provided MemoryPool returning a MemoryReservation that can be used to grow or shrink the memory reservation

Trait Implementations

impl Debug for MemoryConsumer

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

Formats the value using the given formatter.

impl Hash for MemoryConsumer

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 PartialEq for MemoryConsumer

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

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

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 Eq for MemoryConsumer