Struct XlogDeviceRuntime 

pub struct XlogDeviceRuntime { /* private fields */ }

Provider-owned CUDA device runtime.

Owns the device handle, stream pool, and resource stack. Allocation and deallocation calls forward through the canonical provider-built stack: optional logging over one global byte budget and the asynchronous CUDA allocator. Tests may inject a different stack through the crate-private constructor.

Implementations

impl XlogDeviceRuntime

pub fn device_ordinal(&self) -> u32

CUDA ordinal this runtime serves.

pub fn device(&self) -> &Arc<CudaDevice>

Borrow the device handle.

pub fn stream_pool(&self) -> &Arc<StreamPool>

Borrow the stream pool.

pub fn conditional_graph_stats(&self) -> ConditionalGraphStats

Snapshot conditional-graph execution counters.

pub fn reset_conditional_graph_stats(&self)

Reset per-execution conditional-graph counters.

Handle and event lifetime counters are intentionally cumulative and are not reset because callers compare snapshots around an execution.

pub fn event_lifecycle_stats(&self) -> EventLifecycleStats

Snapshot resident completion-event lifetime counters.

pub fn resident_graph_handle_lifecycle_stats( &self, ) -> ResidentGraphHandleLifecycleStats

Snapshot resident graph-handle lifetime counters.

pub fn allocate( &self, bytes: usize, stream: StreamId, tag: AllocTag, ) -> ResourceResult<DeviceBlock>

Allocate via the underlying resource. Stream-ordered: the returned DeviceBlock is bound to stream.

pub fn deallocate(&self, block: DeviceBlock) -> ResourceResult<()>

Deallocate via the underlying resource.

pub fn bytes_outstanding(&self) -> usize

Sum of bytes currently outstanding on this device, as reported by the underlying resource.

pub fn reap_pending(&self) -> ResourceResult<()>

Drain pending async frees on the underlying resource. No-op for synchronous backends. Callers that need an accurate bytes_outstanding reading after a burst of asynchronous deallocations should call this first.

pub fn record_block_use( &self, block: &DeviceBlock, use_stream: StreamId, ) -> ResourceResult<()>

Record that work has been (or is being) submitted on use_stream that touches block. Forwards to the underlying resource stack (LoggingResource → GlobalDeviceBudget → AsyncCudaResource), where the stream-ordered backend attaches a CUDA event so block.alloc_stream waits on it before the queued cuMemFreeAsync runs. This is the production-reachable hook used by provider-recorded launches for read, write, and read_write buffer arguments. Callers that submit raw CUDA work on a stream other than block.alloc_stream must call this directly. See DeviceMemoryResource::record_block_use for the underlying contract.

pub fn supports_block_use_tracking(&self) -> bool

Whether the active resource stack tracks cross-stream uses (i.e., supports record_block_use). The launch recorder’s preflight checks this BEFORE queuing CUDA work, so a misconfigured runtime fails loudly at the boundary rather than after the launch is in flight.