Struct CpuDeviceRuntime 

pub struct CpuDeviceRuntime { /* private fields */ }

Implementations

impl CpuDeviceRuntime

pub fn resident_bytes(&self) -> u64

pub fn peak_resident_bytes(&self) -> u64

Trait Implementations

impl DeviceRuntime for CpuDeviceRuntime

type Buffer = CpuDeviceBuffer

type Stream = CpuDeviceStream

type Command = CpuDeviceCommand

type Fence = CpuDeviceFence

type Error = CpuRuntimeError

fn descriptor(&self) -> &DeviceDescriptor

fn attention_execution_policy(&self) -> AttentionExecutionPolicy

Resolved attention provider-family policy installed by this runtime composition. Auto is never valid after composition.

fn allocate( &self, permit: DeviceAllocationPermit<'_>, ) -> Result<Self::Buffer, Self::Error>

Allocates only after the resource transaction has authorized the exact request. DeviceAllocationPermit has no public constructor and borrows the live transaction context, so raw device allocation cannot bypass admission or outlive the transaction action that authorized it.

fn buffer_descriptor(&self, buffer: &Self::Buffer) -> BufferDescriptor

fn create_stream(&self) -> Result<Self::Stream, Self::Error>

fn stream_state(&self, stream: &Self::Stream) -> StreamState

fn encode_copy( &self, source: &Self::Buffer, destination: &Self::Buffer, region: CopyRegion, ) -> Result<Self::Command, Self::Error>

fn encode_upload( &self, source: &[u8], layout: HostTransferLayout, destination: &Self::Buffer, offset: u64, ) -> Result<Self::Command, Self::Error>

fn encode_zero( &self, destination: &Self::Buffer, offset: u64, size: u64, ) -> Result<Self::Command, Self::Error>

fn submit( &self, stream: &mut Self::Stream, commands: DeviceCommandBatch<Self::Command>, ) -> Result<Self::Fence, DefinitelyNotSubmitted<Self::Error>>

Submits one non-empty ordered command batch and returns its exact completion fence. A backend must preserve command order and must not manufacture intermediate host-visible completion boundaries.

fn submission_attribution( &self, fence: &Self::Fence, ) -> Option<DeviceSubmissionAttribution>

Returns backend-observed native work for an already submitted fence. Attribution may be requested explicitly for correctness evidence or by a diagnostic timing mode. The returned rows never grant completion or resource-release authority.

fn query_fence(&self, fence: &Self::Fence) -> FenceQuery<Self::Error>

Observes a fence without blocking. Indeterminate is not terminal and therefore cannot release command-owned resources.

fn wait_fence( &self, fence: &Self::Fence, ) -> Result<DeviceTerminalReceipt<Self::Error>, FenceIndeterminate<Self::Error>>

Waits for a quiescent terminal. Failure to prove quiescence retains the fence and every resource reachable from the submitted invocation.

fn synchronize(&self, stream: &mut Self::Stream) -> Result<(), Self::Error>

fn readback( &self, stream: &mut Self::Stream, source: &Self::Buffer, region: CopyRegion, layout: HostTransferLayout, ) -> Result<Vec<u8>, Self::Error>

fn describe_error( &self, error: &Self::Error, ) -> Result<DeviceErrorReport, VNextError>

fn begin_static_weight_import( &self, ) -> Option<Result<Box<dyn StaticWeightImportSession<Self::Buffer, Self::Error> + '_>, Self::Error>>

Begins an optional all-or-nothing static-weight import transaction. Returning None selects the portable zero-and-upload path. The default preserves existing CUDA, CPU, and test runtime behavior.

fn encode_static_weight_transform( &self, _request: StaticWeightTransformRequest<'_, '_, Self::Buffer>, ) -> Option<Result<Self::Command, Self::Error>>

Encode a required source-to-execution static weight transform.

fn configure_reusable_executables( &self, _stream: &mut Self::Stream, _plan: DeviceReusableExecutionPlan, ) -> Result<DeviceReusableExecutionPreparation, Self::Error>

Opens the bounded cold-path preparation window for one stream. Backends without reusable executable support retain the no-op receipt.

fn seal_reusable_executables( &self, _stream: &mut Self::Stream, ) -> Result<DeviceReusableExecutionPreparation, Self::Error>

Permanently closes the preparation window for this stream. A sealed stream may replay or fall back to eager execution but cannot capture on a later product request.

fn reusable_executable_preparation( &self, _stream: &Self::Stream, ) -> Result<DeviceReusableExecutionPreparation, Self::Error>

Returns the current preparation receipt without changing lifecycle state. Product startup uses two snapshots to prove that its validation pass replayed stable executables instead of compiling more work.

fn reusable_execution_catalog( &self, _stream: &Self::Stream, ) -> Result<Vec<DeviceReusableExecutionProgram>, Self::Error>

Returns the immutable direct-submit catalog after preparation is sealed.

fn encode_reusable_execution( &self, _invocation: DeviceReusableExecutionInvocation, ) -> Result<Option<Self::Command>, Self::Error>

Encodes one lightweight reference to a resident reusable segment.

fn trim_reusable_executables( &self, _stream: &mut Self::Stream, ) -> Result<DeviceReusableExecutionTrim, Self::Error>

Releases reusable executable cache entries on a proven-quiescent stream. Backends without such a cache retain the no-op default.

fn coalesce_program_bindings( &self, commands: Vec<Self::Command>, ) -> Result<Vec<Self::Command>, Self::Error>

Coalesces independent provider binding writes into a wave prelude.

fn submit_with_timing<S>( &self, stream: &mut Self::Stream, commands: DeviceCommandBatch<Self::Command>, timing_sink: &S, ) -> Result<Self::Fence, DefinitelyNotSubmitted<Self::Error>>

where Self: Sized, S: DeviceSubmissionTimingSink,

Profile-attached submission entrypoint. Backends override this only when they can expose typed internal boundaries without changing submission ownership or error semantics.