Struct MemoryReservation 

pub struct MemoryReservation { /* private fields */ }

A memory reservation for a single operator

Tracks memory usage for one operator (sort, aggregate, join, etc.) and automatically releases memory when dropped.

Example

let controller = Arc::new(MemoryController::with_budget(1024 * 1024 * 1024));
let mut reservation = controller.create_reservation();

// Accumulate memory as we process data
for batch in batches {
    let batch_size = batch.size_in_bytes();

    if !reservation.try_grow(batch_size) {
        // Memory exhausted - spill current data to disk
        spill_to_disk(&accumulated_data);
        reservation.shrink(accumulated_data.size_in_bytes());
    }

    // Process batch...
}

Implementations

impl MemoryReservation

pub fn reserved(&self) -> usize

Get the amount of memory reserved by this operator

pub fn try_grow(&mut self, additional: usize) -> bool

Try to grow the reservation by the specified amount

Returns true if the memory was reserved, false if there’s not enough budget available. The caller should spill to disk if this returns false.

pub fn shrink(&mut self, bytes: usize)

Shrink the reservation by the specified amount

Call this after spilling data to disk to free up budget for new data.

pub fn release_all(&mut self)

Release all reserved memory

Equivalent to shrink(self.reserved())

pub fn should_spill(&self) -> bool

Check if memory pressure is high and spilling is recommended

pub fn would_exceed_budget(&self, additional: usize) -> bool

Check if trying to grow by the given amount would exceed budget

This is a non-mutating check useful for deciding whether to accumulate more data or trigger a spill first.

pub fn budget(&self) -> usize

Get the controller’s budget

pub fn temp_directory(&self) -> &PathBuf

Get the temporary directory for spill files

pub fn target_partition_bytes(&self) -> usize

Get the target partition size

pub fn record_spill(&self, bytes: usize)

Record that data was spilled to disk

Trait Implementations

impl Drop for MemoryReservation

fn drop(&mut self)

Executes the destructor for this type.