Struct Driver 

pub struct Driver<D> { /* private fields */ }

Bounded iterative instruction driver.

Implementations

impl<D> Driver<D>

pub fn new(policy: D) -> Self

Creates a driver around consumer-owned instruction semantics.

pub fn drive<P, M, A, F>( &mut self, description: &MachineDescription<'_, P, M>, permit: &MachinePermit, frames: &mut FrameStack<F>, work: WorkLimit, ) -> DriveResult<P::InstructionId, D::Return, D::Abrupt, D::Yield, D::Interrupt, D::Fault>

where P: InstructionPolicy, P::InstructionId: Copy + Eq + Ord, A: AdmissionPolicy<P, M>, F: MachineFrame, D: InstructionDriverPolicy<P, F>,

Drives at most work instructions without recursive guest execution.

pub fn drive_with_safepoints<P, M, A, F, S>( &mut self, description: &MachineDescription<'_, P, M>, permit: &MachinePermit, frames: &mut FrameStack<F>, work: WorkLimit, root_budget: WorkLimit, observe: impl FnMut(&RootSnapshot) -> Result<(), S>, ) -> Result<DriveOutcome<P::InstructionId, D::Return, D::Abrupt, D::Yield, D::Interrupt>, SafepointDriveError<P::InstructionId, D::Fault, S>>

where P: InstructionPolicy, P::InstructionId: Copy + Eq + Ord, A: AdmissionPolicy<P, M>, F: MachineFrame + ManagedRootSource, D: InstructionDriverPolicy<P, F>,

Drives one bounded slice, publishing a complete root view immediately before every prepared instruction marked as a safepoint.

The observer owns policy: this organ neither selects nor names a reclamation implementation. Suspended caller frames remain in frames and are therefore included in every view.

pub fn drive_protected<P, M, A, F>( &mut self, description: &MachineDescription<'_, P, M>, permit: &MachinePermit, frames: &mut FrameStack<F>, work: WorkLimit, ) -> DriveResult<P::InstructionId, D::Return, D::Abrupt, D::Yield, D::Interrupt, D::Fault>

where P: InstructionPolicy, P::InstructionId: Copy + Eq + Ord, A: AdmissionPolicy<P, M>, F: MachineFrame, D: InstructionDriverPolicy<P, F>,

Drives through prepared protected regions, selecting the innermost handler.

A handled raise remains visible in the receipt, then execution continues at the validated handler boundary. The abrupt value remains consumer-owned; policies place it in their frame’s handler state before returning Raise.

pub fn drive_with_cleanup<P, M, A, F>( &mut self, description: &MachineDescription<'_, P, M>, permit: &MachinePermit, frames: &mut FrameStack<F>, work: WorkLimit, cleanups: CleanupStack<MachineUnwind<D::Return, D::Abrupt, D::Interrupt>>, ) -> DriveResult<P::InstructionId, D::Return, D::Abrupt, D::Yield, D::Interrupt, D::Fault>

where P: InstructionPolicy, P::InstructionId: Copy + Eq + Ord, A: AdmissionPolicy<P, M>, F: MachineFrame, D: InstructionDriverPolicy<P, F>, D::Return: Clone, D::Abrupt: Clone, D::Interrupt: Clone,

Runs a protected drive and unwinds registered cleanups on every abrupt or terminal path. Yield is a suspension and therefore retains its dynamic extent.