Struct StreamOrderModel 

pub struct StreamOrderModel { /* private fields */ }

The stream-ordered allocation engine.

All accounting is in virtual bytes; no host or device memory is actually reserved. The engine is deterministic: identical operation sequences produce identical pointers and statistics.

Implementations

impl StreamOrderModel

pub fn new(limits: ModelLimits) -> Self

Create a fresh model with the given pool limits.

pub fn set_release_threshold(&mut self, threshold: usize)

Mirror an updated release threshold from the pool configuration.

pub fn alloc( &mut self, size: usize, stream: StreamOrderId, ) -> CudaResult<ModelAllocation>

Allocate size bytes ordered on stream.

Returns a ModelAllocation describing the (possibly reused) block and the sequence number at which it becomes valid on the stream.

Errors

• CudaError::InvalidValue if size == 0.
• CudaError::OutOfMemory if satisfying the request would push reserved past max_pool_size.

pub fn free(&mut self, ptr: u64, stream: StreamOrderId) -> CudaResult<()>

Record a stream-ordered free of ptr on stream.

The block is not returned to the free list until stream reaches the free point; until then it remains counted in reserved but no longer in used.

Errors

• CudaError::InvalidValue if ptr is not a live allocation (covers double-free and free of a foreign pointer).

pub fn is_live(&self, ptr: u64) -> bool

Returns true if ptr is a currently-live allocation in this model.

pub fn synchronize(&mut self, stream: StreamOrderId)

Advance a stream to its head: every operation submitted so far is now complete (model of cuStreamSynchronize). Completed frees are reclaimed into the free list.

pub fn is_ready_same_stream(&self, alloc: &ModelAllocation) -> bool

Returns true if the allocation alloc is valid for use on its own ordering stream (i.e. the stream has executed past the allocation point). This is the same-stream visibility rule.

pub fn is_ready_cross_stream( &self, alloc: &ModelAllocation, consumer: StreamOrderId, wait_seq: u64, ) -> bool

Returns true if alloc (made on stream A) is safe to use on consumer (stream B) given that B has been ordered after sequence wait_seq on A (the sequence captured by an event B waited on).

Cross-stream use is only safe when the event was recorded after the allocation became ready (wait_seq > ready_seq) and consumer != A degenerates to the same-stream rule when they are equal.

pub fn record_event(&mut self, stream: StreamOrderId) -> u64

Record an event on stream, returning the sequence number it captures.

A later cuStreamWaitEvent on another stream is ordered after every operation submitted on stream before this point — modelled by handing back the stream’s current submit position.

pub fn trim_to(&mut self, min_bytes_to_keep: usize)

Explicit trim (model of cuMemPoolTrimTo): keep at least min_bytes_to_keep reserved, releasing free-list blocks above that.

pub fn reset_peaks(&mut self)

Reset the peak (reserved_high / used_high) statistics to the current values.

pub fn reserved(&self) -> usize

Current reserved byte count.

pub fn used(&self) -> usize

Current used byte count.

pub fn reserved_high(&self) -> usize

Peak reserved byte count.

pub fn used_high(&self) -> usize

Peak used byte count.

pub fn active(&self) -> usize

Number of currently-live allocations.

pub fn peak_active(&self) -> usize

Peak number of concurrent live allocations.

pub fn free_block_count(&self) -> usize

Number of reuse-eligible free blocks currently held.

pub fn pending_free_count(&self) -> usize

Number of pending (not-yet-complete) stream-ordered frees.

Trait Implementations

impl Debug for StreamOrderModel

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

Formats the value using the given formatter.