Struct MemoryBackend 

pub struct MemoryBackend { /* private fields */ }

The in-memory backend. Its buffers are Vec<u8>: a write’s length is its buffer’s, and a read’s the most it transfers.

Implementations

impl MemoryBackend

pub fn new( submission_queue_size: NonZero<u32>, completion_queue_size: NonZero<u32>, ) -> MemoryBackend

A backend whose submission queue holds submission_queue_size submissions and whose completion queue holds completion_queue_size completions, with no registered buffers.

pub fn with_registered(self, buffers: Vec<Vec<u8>>) -> MemoryBackend

Register buffers, in order, replacing any registered before: a backend’s buffers are registered as it is built, before anything is pushed.

Panics

If a submission is queued or a completion is waiting. A queued or finished operation may name a registered region, which replacing the buffers would invalidate; asking for it is a caller’s programming error.

pub fn registered(&self, index: u32) -> Option<&[u8]>

Registered buffer index, if there is one.

pub fn registered_mut(&mut self, index: u32) -> Option<&mut [u8]>

Registered buffer index, writable, if there is one.

pub fn target(&self, key: IoTargetKey) -> Option<&MemoryTarget>

The target attached under key, if there is one.

pub fn queued(&self) -> usize

How many submissions are queued, not yet submitted.

pub fn completed(&self) -> usize

How many completions are ready, not yet popped.

Trait Implementations

impl Debug for MemoryBackend

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

Formats the value using the given formatter.

impl IoBackend for MemoryBackend

type Target = MemoryTarget

What it runs I/O for.

type Buffer = Vec<u8>

The owned buffers its submissions carry.

type Notification = MemoryNotification

What it raises when its completions go from none to some.

fn attach( &mut self, key: IoTargetKey, target: MemoryTarget, ) -> Result<(), DuplicateTarget<MemoryTarget>>

Run I/O for target under key.

fn detach(&mut self, key: IoTargetKey) -> Option<MemoryTarget>

Stop running I/O for the target under key, handing it back; None if there is none. A submission for it queued but not yet submitted still completes exactly once, through pop: with a fault, or, for a backend that cannot take a queued submission back, issued as it would have been, to the file it was pushed for. The core detaches a target only with no operation outstanding, so a driver does not meet either.

fn registered_buffers(&self) -> u32

How many registered buffers it has; a RegisteredRegion names one by its position.

fn check( &self, target: IoTargetKey, op: &SubmissionOp<Vec<u8>>, ) -> Result<(), RefusalCause>

Whether push would refuse op on target for a cause that does not depend on its queues: no target under the key, an operation it cannot perform, or one malformed for its target. The core asks before it holds an operation for its gate, so a gated operation is refused at the consumer’s push for what an ungated one would be (DI-D-54). A push this accepts may still be refused for a full queue, or by a backend that has become unusable.

fn push( &mut self, submission: Submission<Vec<u8>>, ) -> Result<(), Refused<Vec<u8>>>

Queue submission, to be issued no later than the next submit. It is the backend’s from here until it completes: only a refusal hands it back.

fn submit(&mut self) -> Result<(), RefusalCause>

Issue every queued submission.

fn pop(&mut self) -> Result<Option<Completion<Vec<u8>>>, IoFault>

Take the oldest completion, if there is one.

fn notification(&self) -> Result<MemoryNotification, IoFault>

A handle on its notification.