Struct MemoryConsumer 

pub struct MemoryConsumer { /* private fields */ }

The consumer/reservation half of the same pool API.

Re-exported for the same reason as MemoryPool: the executor’s map-side shuffle-write buffer has to reserve its bytes through the task engine’s pool — a buffer the pool cannot see is a buffer the container limit cannot govern — and it should not take a DataFusion dependency to do it. 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 therefore 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>) -> MemoryConsumer

Create a new empty MemoryConsumer that can be grown using MemoryReservation

pub fn clone_with_new_id(&self) -> MemoryConsumer

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) -> MemoryConsumer

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<(), Error>

Formats the value using the given formatter.

impl Eq for MemoryConsumer

impl Hash for MemoryConsumer

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

where H: Hasher,

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: &MemoryConsumer) -> bool

Equality operator ==.

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

Inequality operator !=.