Struct ExecutionTracer 

pub struct ExecutionTracer {

    pub overflow_table: OverflowTable,
    pub overflow_replay: StackOverflowReplay,
    pub block_stack: BlockStack,
    pub block_stack_replay: BlockStackReplay,
    pub hasher_chiplet_shim: HasherChipletShim,
    pub memory_reads: MemoryReadsReplay,
    pub advice: AdviceReplay,
    pub external: MastForestResolutionReplay,
    pub range_checker: RangeCheckerReplay,
    pub memory_writes: MemoryWritesReplay,
    pub bitwise: BitwiseReplay,
    pub kernel: KernelReplay,
    pub hasher_for_chiplet: HasherRequestReplay,
    pub ace: AceReplay,
    /* private fields */
}

Builder for recording the context to generate trace fragments during execution.

Specifically, this records the information necessary to be able to generate the trace in fragments of configurable length. This requires storing state at the very beginning of the fragment before any operations are executed, as well as recording the various values read during execution in the corresponding “replays” (e.g. values read from memory are recorded in MemoryReadsReplay, values read from the advice provider are recorded in AdviceReplay, etc).

Then, to generate a trace fragment, we initialize the state of the processor using the stored snapshot from the beginning of the fragment, and replay the recorded values as they are encountered during execution (e.g. when encountering a memory read operation, we will replay the value rather than querying the memory chiplet).

Fields

overflow_table: OverflowTable

overflow_replay: StackOverflowReplay

block_stack: BlockStack

block_stack_replay: BlockStackReplay

hasher_chiplet_shim: HasherChipletShim

memory_reads: MemoryReadsReplay

advice: AdviceReplay

external: MastForestResolutionReplay

range_checker: RangeCheckerReplay

memory_writes: MemoryWritesReplay

bitwise: BitwiseReplay

kernel: KernelReplay

hasher_for_chiplet: HasherRequestReplay

ace: AceReplay

Implementations

impl ExecutionTracer

pub fn new(fragment_size: usize) -> Self

Creates a new ExecutionTracer with the given fragment size.

pub fn into_trace_generation_context( self, final_pc_transcript: PrecompileTranscript, ) -> TraceGenerationContext

Convert the ExecutionTracer into a TraceGenerationContext using the data accumulated during execution.

The final_pc_transcript parameter represents the final precompile transcript at the end of execution, which is needed for the auxiliary trace column builder.

Trait Implementations

impl Debug for ExecutionTracer

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

Formats the value using the given formatter.

impl Tracer for ExecutionTracer

fn start_clock_cycle( &mut self, processor: &FastProcessor, execution_state: NodeExecutionState, continuation_stack: &mut ContinuationStack, current_forest: &Arc<MastForest>, )

When sufficiently many clock cycles have elapsed, starts a new trace state. Also updates the internal block stack.

fn record_mast_forest_resolution( &mut self, node_id: MastNodeId, forest: &Arc<MastForest>, )

Records and replays the resolutions of crate::host::AsyncHost::get_mast_forest or crate::host::SyncHost::get_mast_forest.

fn record_hasher_permute( &mut self, input_state: [Felt; 12], output_state: [Felt; 12], )

Records the result of a call to Hasher::permute().

fn record_hasher_build_merkle_root( &mut self, node: Word, path: Option<&MerklePath>, index: Felt, output_root: Word, )

Records the result of a call to Hasher::build_merkle_root().

fn record_hasher_update_merkle_root( &mut self, old_value: Word, new_value: Word, path: Option<&MerklePath>, index: Felt, old_root: Word, new_root: Word, )

Records the result of a call to Hasher::update_merkle_root().

fn record_memory_read_element( &mut self, element: Felt, addr: Felt, ctx: ContextId, clk: RowIndex, )

Records the element read from memory at the given address.

fn record_memory_read_word( &mut self, word: Word, addr: Felt, ctx: ContextId, clk: RowIndex, )

Records the word read from memory at the given address.

fn record_memory_write_element( &mut self, element: Felt, addr: Felt, ctx: ContextId, clk: RowIndex, )

Records the element written to memory at the given address.

fn record_memory_write_word( &mut self, word: Word, addr: Felt, ctx: ContextId, clk: RowIndex, )

Records the word written to memory at the given address.

fn record_advice_pop_stack(&mut self, value: Felt)

Records the value returned by a crate::host::advice::AdviceProvider::pop_stack operation.

fn record_advice_pop_stack_word(&mut self, word: Word)

Records the value returned by a crate::host::advice::AdviceProvider::pop_stack_word operation.

fn record_advice_pop_stack_dword(&mut self, words: [Word; 2])

Records the value returned by a crate::host::advice::AdviceProvider::pop_stack_dword operation.

fn record_u32and(&mut self, a: Felt, b: Felt)

Records the operands of a u32and operation.

fn record_u32xor(&mut self, a: Felt, b: Felt)

Records the operands of a u32xor operation.

fn record_u32_range_checks(&mut self, clk: RowIndex, u32_lo: Felt, u32_hi: Felt)

Records the high and low 32-bit limbs of the result of a u32 operation for the purposes of the range checker. This is expected to result in four 16-bit range checks.

fn record_kernel_proc_access(&mut self, proc_hash: Word)

Records the procedure hash of a syscall.

fn record_circuit_evaluation( &mut self, clk: RowIndex, circuit_eval: CircuitEvaluation, )

Records the evaluation of a circuit.

fn increment_clk(&mut self)

Signals that the processor clock is being incremented.

fn increment_stack_size(&mut self, processor: &FastProcessor)

Signals that the stack depth is incremented as a result of pushing a new element.

fn decrement_stack_size(&mut self)

Signals that the stack depth is decremented as a result of popping an element off the stack.

fn start_context(&mut self)

Signals the start of a new execution context, as a result of a CALL, SYSCALL or DYNCALL operation being executed.

fn restore_context(&mut self)

Signals the end of an execution context, as a result of an END operation associated with a CALL, SYSCALL or DYNCALL.