Struct FastProcessor 

pub struct FastProcessor { /* private fields */ }

A fast processor which doesn’t generate any trace.

This processor is designed to be as fast as possible. Hence, it only keeps track of the current state of the processor (i.e. the stack, current clock cycle, current memory context, and free memory pointer).

Stack Management

A few key points about how the stack was designed for maximum performance:

• The stack has a fixed buffer size defined by STACK_BUFFER_SIZE.
  • This was observed to increase performance by at least 2x compared to using a Vec with push() & pop().
  • We track the stack top and bottom using indices stack_top_idx and stack_bot_idx, respectively.
• Since we are using a fixed-size buffer, we need to ensure that stack buffer accesses are not out of bounds. Naively, we could check for this on every access. However, every operation alters the stack depth by a predetermined amount, allowing us to precisely determine the minimum number of operations required to reach a stack buffer boundary, whether at the top or bottom.
  • For example, if the stack top is 10 elements away from the top boundary, and the stack bottom is 15 elements away from the bottom boundary, then we can safely execute 10 operations that modify the stack depth with no bounds check.
• When switching contexts (e.g., during a call or syscall), all elements past the first 16 are stored in an ExecutionContextInfo struct, and the stack is truncated to 16 elements. This will be restored when returning from the call or syscall.

Clock Cycle Management

• The clock cycle (clk) is managed in the same way as in Process. That is, it is incremented by 1 for every row that Process adds to the main trace.
  • It is important to do so because the clock cycle is used to determine the context ID for new execution contexts when using call or dyncall.

Implementations

impl FastProcessor

pub fn new(stack_inputs: &[Felt]) -> Self

Creates a new FastProcessor instance with the given stack inputs.

Panics

• Panics if the length of stack_inputs is greater than MIN_STACK_DEPTH.

pub fn new_with_advice_inputs( stack_inputs: &[Felt], advice_inputs: AdviceInputs, ) -> Self

Creates a new FastProcessor instance with the given stack and advice inputs.

Panics

• Panics if the length of stack_inputs is greater than MIN_STACK_DEPTH.

pub fn new_debug(stack_inputs: &[Felt], advice_inputs: AdviceInputs) -> Self

Creates a new FastProcessor instance, set to debug mode, with the given stack and advice inputs.

Panics

• Panics if the length of stack_inputs is greater than MIN_STACK_DEPTH.

pub fn stack(&self) -> &[Felt]

Returns the stack, such that the top of the stack is at the last index of the returned slice.

pub fn stack_top(&self) -> &[Felt]

Returns the top 16 elements of the stack.

pub fn stack_top_mut(&mut self) -> &mut [Felt]

Returns a mutable reference to the top 16 elements of the stack.

pub fn stack_get(&self, idx: usize) -> Felt

Returns the element on the stack at index idx.

pub fn stack_get_mut(&mut self, idx: usize) -> &mut Felt

Mutable variant of stack_get().

pub fn stack_get_word(&self, start_idx: usize) -> Word

Returns the word on the stack starting at index start_idx in “stack order”.

That is, for start_idx=0 the top element of the stack will be at the last position in the word.

For example, if the stack looks like this:

top bottom v v a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p

Then

• stack_get_word(0) returns [d, c, b, a],
• stack_get_word(1) returns [e, d, c ,b],
• etc.

pub fn stack_depth(&self) -> u32

Returns the number of elements on the stack in the current context.

pub fn stack_write(&mut self, idx: usize, element: Felt)

Writes an element to the stack at the given index.

pub fn stack_write_word(&mut self, start_idx: usize, word: &Word)

Writes a word to the stack starting at the given index.

The index is the index of the first element of the word, and the word is written in reverse order.

pub fn stack_swap(&mut self, idx1: usize, idx2: usize)

Swaps the elements at the given indices on the stack.

pub async fn execute( self, program: &Program, host: &mut impl AsyncHost, ) -> Result<ExecutionOutput, ExecutionError>

Executes the given program and returns the stack outputs as well as the advice provider.

pub async fn execute_for_trace( self, program: &Program, host: &mut impl AsyncHost, ) -> Result<(ExecutionOutput, Vec<TraceFragmentContext>), ExecutionError>

Executes the given program and returns the stack outputs, the advice provider, and information for building the trace.

pub async fn execute_with_tracer( self, program: &Program, host: &mut impl AsyncHost, tracer: &mut impl Tracer, ) -> Result<ExecutionOutput, ExecutionError>

Executes the given program with the provided tracer and returns the stack outputs, and the advice provider.

impl FastProcessor

pub fn state(&mut self) -> ProcessState<'_>

Trait Implementations

impl Debug for FastProcessor

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

Formats the value using the given formatter.