Struct ExecutionRecord

pub struct ExecutionRecord {

    pub program: Arc<Program>,
    pub cpu_events: Vec<CpuEvent>,
    pub add_events: Vec<AluEvent>,
    pub mul_events: Vec<AluEvent>,
    pub sub_events: Vec<AluEvent>,
    pub bitwise_events: Vec<AluEvent>,
    pub shift_left_events: Vec<AluEvent>,
    pub shift_right_events: Vec<AluEvent>,
    pub divrem_events: Vec<AluEvent>,
    pub lt_events: Vec<AluEvent>,
    pub memory_instr_events: Vec<MemInstrEvent>,
    pub auipc_events: Vec<AUIPCEvent>,
    pub branch_events: Vec<BranchEvent>,
    pub jump_events: Vec<JumpEvent>,
    pub byte_lookups: HashMap<ByteLookupEvent, usize>,
    pub precompile_events: PrecompileEvents,
    pub global_memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub global_memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub cpu_local_memory_access: Vec<MemoryLocalEvent>,
    pub syscall_events: Vec<SyscallEvent>,
    pub global_interaction_events: Vec<GlobalInteractionEvent>,
    pub public_values: PublicValues<u32, u32>,
    pub next_nonce: u64,
    pub shape: Option<Shape<RiscvAirId>>,
    pub counts: Option<EnumMap<RiscvAirId, u64>>,
}

A record of the execution of a program.

The trace of the execution is represented as a list of “events” that occur every cycle.

Fields

program: Arc<Program>

The program.

cpu_events: Vec<CpuEvent>

A trace of the CPU events which get emitted during execution.

add_events: Vec<AluEvent>

A trace of the ADD, and ADDI events.

mul_events: Vec<AluEvent>

A trace of the MUL events.

sub_events: Vec<AluEvent>

A trace of the SUB events.

bitwise_events: Vec<AluEvent>

A trace of the XOR, XORI, OR, ORI, AND, and ANDI events.

shift_left_events: Vec<AluEvent>

A trace of the SLL and SLLI events.

shift_right_events: Vec<AluEvent>

A trace of the SRL, SRLI, SRA, and SRAI events.

divrem_events: Vec<AluEvent>

A trace of the DIV, DIVU, REM, and REMU events.

lt_events: Vec<AluEvent>

A trace of the SLT, SLTI, SLTU, and SLTIU events.

memory_instr_events: Vec<MemInstrEvent>

A trace of the memory instructions.

auipc_events: Vec<AUIPCEvent>

A trace of the AUIPC events.

branch_events: Vec<BranchEvent>

A trace of the branch events.

jump_events: Vec<JumpEvent>

A trace of the jump events.

byte_lookups: HashMap<ByteLookupEvent, usize>

A trace of the byte lookups that are needed.

precompile_events: PrecompileEvents

A trace of the precompile events.

global_memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>

A trace of the global memory initialize events.

global_memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>

A trace of the global memory finalize events.

cpu_local_memory_access: Vec<MemoryLocalEvent>

A trace of all the shard’s local memory events.

syscall_events: Vec<SyscallEvent>

A trace of all the syscall events.

global_interaction_events: Vec<GlobalInteractionEvent>

A trace of all the global interaction events.

public_values: PublicValues<u32, u32>

The public values.

next_nonce: u64

The next nonce to use for a new lookup.

shape: Option<Shape<RiscvAirId>>

The shape of the proof.

counts: Option<EnumMap<RiscvAirId, u64>>

The predicted counts of the proof.

Implementations

impl ExecutionRecord

pub fn new(program: Arc<Program>) -> Self

Create a new ExecutionRecord.

pub fn defer(&mut self) -> ExecutionRecord

Take out events from the ExecutionRecord that should be deferred to a separate shard.

Note: we usually defer events that would increase the recursion cost significantly if included in every shard.

pub fn split( &mut self, last: bool, last_record: Option<&mut ExecutionRecord>, opts: SplitOpts, ) -> Vec<ExecutionRecord>

Splits the deferred ExecutionRecord into multiple ExecutionRecords, each which contain a “reasonable” number of deferred events.

The optional last_record will be provided if there are few enough deferred events that they can all be packed into the already existing last record.

pub fn fixed_log2_rows<F: PrimeField, A: MachineAir<F>>( &self, air: &A, ) -> Option<usize>

Return the number of rows needed for a chip, according to the proof shape specified in the struct.

pub fn contains_cpu(&self) -> bool

Determines whether the execution record contains CPU events.

pub fn add_precompile_event( &mut self, syscall_code: SyscallCode, syscall_event: SyscallEvent, event: PrecompileEvent, )

Add a precompile event to the execution record.

pub fn get_precompile_events( &self, syscall_code: SyscallCode, ) -> &Vec<(SyscallEvent, PrecompileEvent)>

Get all the precompile events for a syscall code.

pub fn get_local_mem_events(&self) -> impl Iterator<Item = &MemoryLocalEvent>

Get all the local memory events.

Trait Implementations

impl ByteRecord for ExecutionRecord

fn add_byte_lookup_event(&mut self, blu_event: ByteLookupEvent)

Adds a new ByteLookupEvent to the record.

fn add_byte_lookup_events_from_maps( &mut self, new_events: Vec<&HashMap<ByteLookupEvent, usize>>, )

Adds a list of ByteLookupEvent maps to the record.

fn add_byte_lookup_events(&mut self, blu_events: Vec<ByteLookupEvent>)

Adds a list of ByteLookupEvents to the record.

fn add_u8_range_check(&mut self, a: u8, b: u8)

Adds a ByteLookupEvent to verify a and b are indeed bytes to the shard.

fn add_u16_range_check(&mut self, a: u16)

Adds a ByteLookupEvent to verify a is indeed u16.

fn add_u8_range_checks(&mut self, bytes: &[u8])

Adds ByteLookupEvents to verify that all the bytes in the input slice are indeed bytes.

fn add_u8_range_checks_field<F: PrimeField32>(&mut self, field_values: &[F])

Adds ByteLookupEvents to verify that all the field elements in the input slice are indeed bytes.

fn add_u16_range_checks(&mut self, ls: &[u16])

Adds ByteLookupEvents to verify that all the bytes in the input slice are indeed bytes.

fn lookup_or(&mut self, b: u8, c: u8)

Adds a ByteLookupEvent to compute the bitwise OR of the two input values.

impl Clone for ExecutionRecord

fn clone(&self) -> ExecutionRecord

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExecutionRecord

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

Formats the value using the given formatter.

impl Default for ExecutionRecord

fn default() -> ExecutionRecord

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExecutionRecord

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MachineRecord for ExecutionRecord

fn public_values<F: AbstractField>(&self) -> Vec<F>

Retrieves the public values. This method is needed for the MachineRecord trait, since

type Config = SP1CoreOpts

The configuration of the machine.

fn stats(&self) -> HashMap<String, usize>

The statistics of the record.

fn append(&mut self, other: &mut ExecutionRecord)

Appends two records together.

fn register_nonces(&mut self, _opts: &Self::Config)

Registers the nonces of the record.

impl Serialize for ExecutionRecord

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.