Struct GpuMemoryManager 

pub struct GpuMemoryManager { /* private fields */ }

Budget-enforced device allocation. Every view retains actual storage. Runtime-backed managers use the canonical resource stack. Native allocations share its raw owner: post-malloc failures retain storage and budget together.

Implementations

impl GpuMemoryManager

pub fn reserve_bytes( self: &Arc<Self>, bytes: u64, ) -> Result<GpuMemoryReservation>

Atomically reserve bytes for one bounded multi-allocation request.

The returned token owns the complete local-budget claim. A runtime-backed manager also reserves the same bytes against the runtime resource stack’s finite global budget before touching local accounting; runtimes without a reservable global budget are refused. Creating the token performs no device allocation and does not increment alloc_count.

pub fn runtime(&self) -> Option<&Arc<XlogDeviceRuntime>>

Borrow the attached device runtime, if any. None when the manager was constructed via [new].

This accessor is the supported bridge for provider operations that receive runtime-owned allocations through the memory manager and must submit recorded work through crate::launch::LaunchRecorder. Code that already owns the runtime should use that Arc<XlogDeviceRuntime> directly.

pub fn reap_pending_deallocations(&self) -> Result<()>

Complete stream-ordered frees that are pending in the attached device runtime.

Diagnostic transactions use this after dropping temporary buffers on an error path so a later operation observes the restored byte budget.

pub fn alloc<T: DeviceRepr>( self: &Arc<Self>, len: usize, ) -> Result<TrackedCudaSlice<T>>

Allocate len elements through the attached runtime or the shared raw allocator. Allocation completes before publication; retained failures keep their actual allocation and local byte claim.

pub fn check_budget(&self, bytes: u64) -> Result<()>

Check if an allocation of bytes would exceed the budget

Arguments

• bytes - Number of bytes to allocate

Returns

Ok(()) if allocation is within budget

Errors

XlogError::ResourceExhausted if allocation would exceed budget

pub fn allocated_bytes(&self) -> u64

Get the current allocated memory in bytes

pub fn deallocation_failure_count(&self) -> u64

Number of runtime deallocations that returned an error. Their bytes remain charged locally because physical release was not proven.

pub fn deallocation_failure_bytes(&self) -> u64

Total bytes retained in local accounting after runtime deallocation errors.

pub fn peak_bytes(&self) -> u64

High-water mark of successful manager-accounted reservations since construction or the last reset_peak. Direct CUDA allocations that bypass this manager are not included.

pub fn reset_peak(&self)

Reset the peak high-water mark to the current allocated level, so a measurement window starts from live state rather than zero. Measurement-harness API.

pub fn alloc_count(&self) -> u64

Number of alloc calls issued so far (device allocation requests). The GPU-resident MC engine snapshots this around the measured region to prove per_operator_host_allocations == 0 (all arenas pre-allocated).

pub fn reset_alloc_count(&self)

Reset the allocation-request counter to zero.

pub fn budget(&self) -> &MemoryBudget

Get the memory budget

pub fn budget_limit_bytes(&self) -> u64

Total local budget enforced jointly by this manager and any overlays.

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

Get the underlying CUDA device

pub fn record_free(&self, bytes: u64) -> Result<()>

Validate a caller-requested manual accounting release.

Tracked allocations release themselves through their private owner path. A public caller cannot authenticate ownership, so nonzero manual releases are refused while bytes are live and underflow is rejected without mutating either counter.

pub fn alloc_raw( self: &Arc<Self>, bytes: usize, tag: AllocTag, ) -> Result<RuntimeAllocBlock>

v0.6 device-runtime entry point: allocate bytes raw bytes through the attached XlogDeviceRuntime.

Returns a RuntimeAllocBlock that owns the allocation. On drop, the block deallocates through the runtime and updates both the manager’s local allocated counter and the runtime’s bookkeeping.

Both budgets apply: the manager’s local MemoryBudget::device_bytes AND any GlobalDeviceBudget stacked above the runtime’s underlying resource. Either rejecting the request returns an XlogError. On runtime rejection the local reservation is rolled back so subsequent allocations see consistent state.

Errors

• XlogError::Kernel if no runtime is attached.
• XlogError::ResourceExhausted if the local budget cannot accommodate the request.
• XlogError::ResourceExhausted if the runtime’s budget rejects the request. Other runtime errors are reported as XlogError::Kernel.

pub fn remaining_bytes(&self) -> u64

Get remaining budget in bytes

pub fn reset_tracking(&self) -> Result<()>

Reset diagnostic tracking only when no tracked bytes are live.