Struct FaultAccelerator 

pub struct FaultAccelerator<A> { /* private fields */ }

Accelerator wrapper driven by a validated deterministic fault script.

Implementations

impl<A> FaultAccelerator<A>

pub fn new(inner: A, script: FaultScript) -> Self

pub const fn inner(&self) -> &A

pub fn control(&self) -> FaultControl

Trait Implementations

impl<A: Accelerator> Accelerator for FaultAccelerator<A>

type Context = FaultContext<<A as Accelerator>::Context>

Owned context handle. It may be a native value and need not be boxed, cloneable, or thread safe.

type Buffer = FaultBuffer<<A as Accelerator>::Buffer>

Owned handle for the exact allocation described by its accompanying [BufferInfo].

type Program = FaultProgram<<A as Accelerator>::Program>

Owned resident-program handle with no borrow of its source artifact.

type Queue = FaultQueue<<A as Accelerator>::Queue>

Owned accelerator execution-queue handle.

type Event = FaultEvent<<A as Accelerator>::Event>

Owned submission and completion token with no borrow of the submitted binding slice.

fn device_info(&self) -> Result<DeviceInfo, BackendError>

Return immutable identity, capability, and limit metadata.

fn create_context( &self, desc: ContextDesc, ) -> Result<Self::Context, BackendError>

Create one context from prevalidated intent.

fn destroy_context( &self, context: Self::Context, ) -> Result<(), ReleaseFailure<Self::Context>>

Destroy an empty context.

fn allocate_buffer( &self, context: &Self::Context, desc: BufferDesc, ) -> Result<AllocatedBuffer<Self::Buffer>, BackendError>

Allocate one exact provider-owned buffer backing.

fn write_buffer( &self, buffer: &mut Self::Buffer, offset: u64, data: &dyn ByteSource, ) -> Result<(), BackendError>

Perform one explicit host-to-buffer transfer.

fn read_buffer( &self, buffer: &Self::Buffer, offset: u64, data: &mut dyn ByteSink, ) -> Result<(), BackendError>

Perform one explicit buffer-to-host transfer.

fn free_buffer( &self, buffer: Self::Buffer, ) -> Result<(), ReleaseFailure<Self::Buffer>>

Release an unreferenced buffer and its exact backing allocation.

fn load_program( &self, context: &Self::Context, artifact: ArtifactRef<'_>, ) -> Result<Self::Program, BackendError>

Create a resident program from an opaque, possibly segmented artifact.

fn unload_program( &self, program: Self::Program, ) -> Result<(), ReleaseFailure<Self::Program>>

Release an unreferenced resident program.

fn create_queue( &self, context: &Self::Context, desc: QueueDesc, ) -> Result<Self::Queue, BackendError>

Create one accelerator execution queue.

fn destroy_queue( &self, queue: Self::Queue, ) -> Result<(), ReleaseFailure<Self::Queue>>

Release an unreferenced execution queue.

fn submit( &self, queue: &Self::Queue, program: &Self::Program, bindings: &[BindingRef<'_, Self::Buffer>], timeout: Timeout, ) -> Result<Self::Event, SubmitFailure<Self::Event>>

Attempt to admit one program execution and return its event.

fn poll_event(&self, event: &Self::Event) -> Result<EventState, BackendError>

Observe event state without blocking or driving an executor.

fn cancel_event(&self, event: &Self::Event) -> Result<(), BackendError>

Attempt to make a pending event terminal as [EventState::Cancelled].

fn destroy_event( &self, event: Self::Event, ) -> Result<(), ReleaseFailure<Self::Event>>

Release one terminal event and its provider invocation state.