Struct CpuRefBackend 

pub struct CpuRefBackend;

Dispatch backend backed by vyre_reference::reference_eval.

Trait Implementations

impl Clone for CpuRefBackend

fn clone(&self) -> CpuRefBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CpuRefBackend

impl Debug for CpuRefBackend

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

Formats the value using the given formatter.

impl Default for CpuRefBackend

fn default() -> CpuRefBackend

Returns the “default value” for a type.

impl Sealed for CpuRefBackend

impl VyreBackend for CpuRefBackend

fn id(&self) -> &'static str

Stable backend identifier used for logging, certificates, and adapter selection.

fn version(&self) -> &'static str

Backend implementation version string used for certificates and regression tracking.

fn dispatch( &self, program: &Program, inputs: &[Vec<u8>], config: &DispatchConfig, ) -> Result<Vec<Vec<u8>>, BackendError>

Executes the program with the given input buffers and returns the output buffers.

fn supported_ops(&self) -> &HashSet<OpId>

Operation ids this backend can execute without further lowering.

fn max_workgroup_size(&self) -> [u32; 3]

Maximum supported workgroup size per axis [x, y, z].

fn max_compute_workgroups_per_dimension(&self) -> u32

Maximum number of compute workgroups the backend can launch in one dispatch dimension.

fn dispatch_borrowed( &self, program: &Program, inputs: &[&[u8]], config: &DispatchConfig, ) -> Result<Vec<Vec<u8>>, BackendError>

Executes the program with borrowed input buffers.

fn dispatch_borrowed_timed( &self, program: &Program, inputs: &[&[u8]], config: &DispatchConfig, ) -> Result<TimedDispatchResult, BackendError>

Executes a borrowed-input dispatch and returns backend-owned timing.

fn dispatch_borrowed_into( &self, program: &Program, inputs: &[&[u8]], config: &DispatchConfig, outputs: &mut Vec<Vec<u8>>, ) -> Result<(), BackendError>

Executes the program with borrowed input buffers and writes outputs into caller-owned storage.

fn allocate_resident(&self, _byte_len: usize) -> Result<Resource, BackendError>

Allocate a backend-resident buffer and return a stable resource handle.

fn upload_resident( &self, _resource: &Resource, _bytes: &[u8], ) -> Result<(), BackendError>

Upload bytes into a backend-resident resource.

fn upload_resident_many( &self, _uploads: &[(&Resource, &[u8])], ) -> Result<(), BackendError>

Upload several backend-resident resources as one logical staging operation.

fn upload_resident_at( &self, _resource: &Resource, _dst_offset_bytes: usize, _bytes: &[u8], ) -> Result<(), BackendError>

Upload bytes into a subrange of a backend-resident resource.

fn upload_resident_at_many( &self, _uploads: &[(&Resource, usize, &[u8])], ) -> Result<(), BackendError>

Upload several resident subranges as one logical staging operation.

fn download_resident( &self, resource: &Resource, ) -> Result<Vec<u8>, BackendError>

Download a backend-resident resource into a new host buffer.

fn download_resident_into( &self, _resource: &Resource, _out: &mut Vec<u8>, ) -> Result<(), BackendError>

Download a backend-resident resource into caller-owned storage.

fn download_resident_range( &self, resource: &Resource, byte_offset: usize, byte_len: usize, ) -> Result<Vec<u8>, BackendError>

Download a byte range from a backend-resident resource into a new host buffer.

fn download_resident_range_into( &self, _resource: &Resource, _byte_offset: usize, _byte_len: usize, _out: &mut Vec<u8>, ) -> Result<(), BackendError>

Download a byte range from a backend-resident resource into caller-owned storage.

fn download_resident_ranges_into( &self, ranges: &[(&Resource, usize, usize)], outputs: &mut [&mut Vec<u8>], ) -> Result<(), BackendError>

Download several byte ranges from backend-resident resources into caller-owned storage as one logical readback operation.

fn free_resident(&self, _resource: Resource) -> Result<(), BackendError>

Free a backend-resident resource previously returned by VyreBackend::allocate_resident.

fn dispatch_resident_timed( &self, _program: &Program, _resources: &[Resource], _config: &DispatchConfig, ) -> Result<TimedDispatchResult, BackendError>

Dispatch using backend-resident resources and return backend-owned timing.

fn dispatch_resident_sequence_read_ranges_into( &self, steps: &[ResidentDispatchStep<'_>], read_ranges: &[ResidentReadRange<'_>], outputs: &mut [&mut Vec<u8>], ) -> Result<(), BackendError>

Dispatch an ordered sequence of resident-buffer programs and read selected resident byte ranges into caller-owned storage.

fn dispatch_resident_sequence_read_ranges_timed_into( &self, steps: &[ResidentDispatchStep<'_>], read_ranges: &[ResidentReadRange<'_>], outputs: &mut [&mut Vec<u8>], ) -> Result<ResidentSequenceTiming, BackendError>

Timed variant of VyreBackend::dispatch_resident_sequence_read_ranges_into.

fn dispatch_resident_repeated_sequence_read_ranges_into( &self, prefix_steps: &[ResidentDispatchStep<'_>], repeated_steps: &[ResidentDispatchStep<'_>], repeat_count: u32, read_ranges: &[ResidentReadRange<'_>], outputs: &mut [&mut Vec<u8>], ) -> Result<(), BackendError>

Dispatch a resident prefix, repeat a resident sub-sequence, and read selected resident byte ranges into caller-owned storage.

fn compile_native( &self, _program: &Program, _config: &DispatchConfig, ) -> Result<Option<Arc<dyn CompiledPipeline>>, BackendError>

Optional pre-compilation hook for the pipeline-mode API.

fn compile_native_shared( &self, program: Arc<Program>, config: &DispatchConfig, ) -> Result<Option<Arc<dyn CompiledPipeline>>, BackendError>

Optional pre-compilation hook for callers that already own a shared program allocation.

fn pipeline_cache_snapshot(&self) -> Option<PipelineCacheSnapshot>

Optional compiled-pipeline cache counters for compile telemetry.

fn backend_metric_snapshot(&self) -> Vec<(&'static str, u64)>

Optional backend-specific numeric telemetry for release evidence.

fn dispatch_async( &self, program: &Program, inputs: &[Vec<u8>], config: &DispatchConfig, ) -> Result<Box<dyn PendingDispatch>, BackendError>

Non-blocking dispatch primitive.

fn dispatch_borrowed_async( &self, program: &Program, inputs: &[&[u8]], config: &DispatchConfig, ) -> Result<Box<dyn PendingDispatch>, BackendError>

Non-blocking dispatch with borrowed input buffers.

fn supports_subgroup_ops(&self) -> bool

Whether this backend’s lowering path emits subgroup / wave intrinsics AND the current adapter exposes them.

fn supports_f16(&self) -> bool

Whether this backend lowers IEEE 754 binary16 (DataType::F16) natively rather than emulating through f32.

fn supports_bf16(&self) -> bool

Whether this backend lowers bfloat16 (DataType::BF16) natively.

fn supports_tensor_cores(&self) -> bool

Whether this backend emits tensor-core / matrix-engine intrinsics for supported tensor shapes.

fn supports_async_compute(&self) -> bool

Whether this backend overlaps copies and compute via independent queues or async engines.

fn supports_indirect_dispatch(&self) -> bool

Whether this backend supports indirect dispatch (Node::IndirectDispatch).

fn supports_speculation(&self) -> bool

Whether this backend supports speculative dispatch - a fused prefilter + confirmer kernel with commit-gated output and a counter tail read back by the host.

fn supports_persistent_thread_dispatch(&self) -> bool

Whether this backend supports device-side persistent-thread dispatch (a long-running kernel that polls a work queue).

fn supports_grid_sync(&self) -> bool

Whether this backend can satisfy Node::Barrier { ordering: MemoryOrdering::GridSync } inside a single dispatch - i.e. every thread in the entire grid waits at the barrier and every prior write is globally visible afterwards. Backends that lack a native grid barrier (workgroup-only fences) must return false; registration-based dispatch may lower a GridSync barrier to a host-orchestrated kernel split only when VyreBackend::allows_host_grid_sync_split also returns true.

fn cooperative_grid_sync_fits( &self, _program: &Program, _inputs: &[&[u8]], _config: &DispatchConfig, ) -> Result<bool, BackendError>

Whether a native cooperative grid-sync launch of program with these inputs and config can be made fully resident on this device.

fn allows_host_grid_sync_split(&self) -> bool

Whether the shared registry wrapper may emulate whole-grid synchronization for this backend by splitting one program into multiple host-dispatched kernels.

fn supports_resident_dispatch(&self) -> bool

Whether this backend implements the resident half of the contract (allocate_resident / upload_resident / dispatch_resident_timed / dispatch_resident_repeated_sequence_read_ranges_into / download_resident_* / free_resident) well enough to run a device-resident dispatch sequence.

fn is_distributed(&self) -> bool

Whether this backend partitions a program across more than one physical device / node.

fn supports_distributed_collectives(&self) -> bool

Whether this backend lowers distributed collective communication nodes (AllReduce, AllGather, ReduceScatter, Broadcast).

fn max_compute_invocations_per_workgroup(&self) -> u32

Maximum total invocations allowed in a single workgroup.

fn subgroup_size(&self) -> Option<u32>

Native subgroup size for the backing device when the backend knows it. Returning None tells the dispatch planner the backend can’t report a subgroup width - the planner falls back to max_workgroup_size for its sizing heuristic.

fn max_storage_buffer_bytes(&self) -> u64

Maximum size in bytes of a single storage buffer the backend accepts. 0 means the backend has not reported a limit, not “unlimited”.

fn device_profile(&self) -> DeviceProfile

Unified backend-neutral device profile.

fn prepare(&self) -> Result<(), BackendError>

Pre-dispatch warmup. Called before the first dispatch on a new program so the backend can warm caches, compile ahead-of-time, or acquire a device handle without paying that cost on the hot path.

fn flush(&self) -> Result<(), BackendError>

Flush any queued work to the device and wait for it to complete.

fn shutdown(&self) -> Result<(), BackendError>

Release device resources held by this backend. After shutdown returns the backend is in an unspecified state and may not be used for further dispatches.

fn device_lost(&self) -> bool

Probe whether the underlying device has been lost since the last successful dispatch.

fn try_recover(&self) -> Result<(), BackendError>

Attempt to recover from device loss by reacquiring the underlying device and invalidating pipeline caches.

fn allocate_device_buffer( &self, _byte_len: usize, ) -> Result<Box<dyn DeviceBuffer>, BackendError>

Allocate a backend-owned device buffer of byte_len bytes.

fn upload_device_buffer( &self, _buffer: &mut (dyn DeviceBuffer + 'static), _bytes: &[u8], ) -> Result<(), BackendError>

Upload host bytes into a previously-allocated device buffer.

fn download_device_buffer( &self, _buffer: &(dyn DeviceBuffer + 'static), ) -> Result<Vec<u8>, BackendError>

Download bytes from a device buffer back to a host Vec<u8>.

fn free_device_buffer( &self, _buffer: Box<dyn DeviceBuffer>, ) -> Result<(), BackendError>

Free a device buffer previously returned by Self::allocate_device_buffer. Explicit-free is required because the substrate does not assume reference-counted backend handles; consumers are responsible for calling this when done.

fn dispatch_with_device_buffers( &self, _program: &Program, _inputs: &[&(dyn DeviceBuffer + 'static)], _outputs: &mut [&mut (dyn DeviceBuffer + 'static)], _config: &DispatchConfig, ) -> Result<(), BackendError>

Dispatch a Program with backend-owned device buffers as inputs and outputs.