Struct ExecutionRecord 

pub struct ExecutionRecord {

    pub program: Arc<Program>,
    pub cpu_event_count: u32,
    pub add_events: Vec<(AluEvent, RTypeRecord)>,
    pub addw_events: Vec<(AluEvent, ALUTypeRecord)>,
    pub addi_events: Vec<(AluEvent, ITypeRecord)>,
    pub mul_events: Vec<(AluEvent, RTypeRecord)>,
    pub sub_events: Vec<(AluEvent, RTypeRecord)>,
    pub subw_events: Vec<(AluEvent, RTypeRecord)>,
    pub bitwise_events: Vec<(AluEvent, ALUTypeRecord)>,
    pub shift_left_events: Vec<(AluEvent, ALUTypeRecord)>,
    pub shift_right_events: Vec<(AluEvent, ALUTypeRecord)>,
    pub divrem_events: Vec<(AluEvent, RTypeRecord)>,
    pub lt_events: Vec<(AluEvent, ALUTypeRecord)>,
    pub memory_load_byte_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_load_half_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_load_word_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_load_x0_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_load_double_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_store_byte_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_store_half_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_store_word_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub memory_store_double_events: Vec<(MemInstrEvent, ITypeRecord)>,
    pub utype_events: Vec<(UTypeEvent, JTypeRecord)>,
    pub branch_events: Vec<(BranchEvent, ITypeRecord)>,
    pub jal_events: Vec<(JumpEvent, JTypeRecord)>,
    pub jalr_events: Vec<(JumpEvent, ITypeRecord)>,
    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 global_page_prot_initialize_events: Vec<PageProtInitializeFinalizeEvent>,
    pub global_page_prot_finalize_events: Vec<PageProtInitializeFinalizeEvent>,
    pub cpu_local_memory_access: Vec<MemoryLocalEvent>,
    pub cpu_local_page_prot_access: Vec<PageProtLocalEvent>,
    pub syscall_events: Vec<(SyscallEvent, RTypeRecord)>,
    pub global_interaction_events: Vec<GlobalInteractionEvent>,
    pub instruction_fetch_events: Vec<(InstructionFetchEvent, MemoryAccessRecord)>,
    pub instruction_decode_events: Vec<InstructionDecodeEvent>,
    pub global_cumulative_sum: Arc<Mutex<SepticDigest<u32>>>,
    pub global_interaction_event_count: u32,
    pub bump_memory_events: Vec<(MemoryRecordEnum, u64, bool)>,
    pub bump_state_events: Vec<(u64, u64, bool, u64)>,
    pub public_values: PublicValues<u32, u64, u64, u32>,
    pub next_nonce: u64,
    pub shape: Option<Shape<RiscvAirId>>,
    pub estimated_trace_area: u64,
    pub initial_timestamp: u64,
    pub last_timestamp: u64,
    pub pc_start: Option<u64>,
    pub next_pc: u64,
    pub exit_code: u32,
    pub global_dependencies_opt: bool,
}

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_event_count: u32

The number of CPU related events.

add_events: Vec<(AluEvent, RTypeRecord)>

A trace of the ADD, and ADDI events.

addw_events: Vec<(AluEvent, ALUTypeRecord)>

A trace of the ADDW events.

addi_events: Vec<(AluEvent, ITypeRecord)>

A trace of the ADDI events.

mul_events: Vec<(AluEvent, RTypeRecord)>

A trace of the MUL events.

sub_events: Vec<(AluEvent, RTypeRecord)>

A trace of the SUB events.

subw_events: Vec<(AluEvent, RTypeRecord)>

A trace of the SUBW events.

bitwise_events: Vec<(AluEvent, ALUTypeRecord)>

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

shift_left_events: Vec<(AluEvent, ALUTypeRecord)>

A trace of the SLL and SLLI events.

shift_right_events: Vec<(AluEvent, ALUTypeRecord)>

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

divrem_events: Vec<(AluEvent, RTypeRecord)>

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

lt_events: Vec<(AluEvent, ALUTypeRecord)>

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

memory_load_byte_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of load byte instructions.

memory_load_half_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of load half instructions.

memory_load_word_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of load word instructions.

memory_load_x0_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of load instructions with op_a = x0.

memory_load_double_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of load double instructions.

memory_store_byte_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of store byte instructions.

memory_store_half_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of store half instructions.

memory_store_word_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of store word instructions.

memory_store_double_events: Vec<(MemInstrEvent, ITypeRecord)>

A trace of store double instructions.

utype_events: Vec<(UTypeEvent, JTypeRecord)>

A trace of the AUIPC and LUI events.

branch_events: Vec<(BranchEvent, ITypeRecord)>

A trace of the branch events.

jal_events: Vec<(JumpEvent, JTypeRecord)>

A trace of the JAL events.

jalr_events: Vec<(JumpEvent, ITypeRecord)>

A trace of the JALR 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.

global_page_prot_initialize_events: Vec<PageProtInitializeFinalizeEvent>

A trace of the global page prot initialize events.

global_page_prot_finalize_events: Vec<PageProtInitializeFinalizeEvent>

A trace of the global page prot finalize events.

cpu_local_memory_access: Vec<MemoryLocalEvent>

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

cpu_local_page_prot_access: Vec<PageProtLocalEvent>

A trace of all the local page prot events.

syscall_events: Vec<(SyscallEvent, RTypeRecord)>

A trace of all the syscall events.

global_interaction_events: Vec<GlobalInteractionEvent>

A trace of all the global interaction events.

instruction_fetch_events: Vec<(InstructionFetchEvent, MemoryAccessRecord)>

A trace of all instruction fetch events.

instruction_decode_events: Vec<InstructionDecodeEvent>

A trace of all instruction decode events.

global_cumulative_sum: Arc<Mutex<SepticDigest<u32>>>

The global culmulative sum.

global_interaction_event_count: u32

The global interaction event count.

bump_memory_events: Vec<(MemoryRecordEnum, u64, bool)>

Memory records used to bump the timestamp of the register memory access.

bump_state_events: Vec<(u64, u64, bool, u64)>

Record where the clk >> 24 or pc >> 16 has incremented.

public_values: PublicValues<u32, u64, u64, 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.

estimated_trace_area: u64

The estimated total trace area of the proof.

initial_timestamp: u64

The initial timestamp of the shard.

last_timestamp: u64

The final timestamp of the shard.

pc_start: Option<u64>

The start program counter.

next_pc: u64

The final program counter.

exit_code: u32

The exit code.

global_dependencies_opt: bool

Use optimized generate_dependencies for global chip.

Implementations

impl ExecutionRecord

pub fn new( program: Arc<Program>, proof_nonce: [u32; 4], global_dependencies_opt: bool, ) -> Self

Create a new ExecutionRecord.

pub fn new_preallocated( program: Arc<Program>, proof_nonce: [u32; 4], global_dependencies_opt: bool, reservation_size: usize, ) -> Self

Create a new ExecutionRecord with preallocated event vecs.

pub fn defer<'a>( &mut self, retain_presets: impl IntoIterator<Item = &'a RetainedEventsPreset>, ) -> 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, done: bool, last_record: &mut ExecutionRecord, can_pack_global_memory: bool, opts: &SplitOpts, ) -> Vec<ExecutionRecord>

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

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.

deprecated: TODO: remove this method.

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.

pub fn get_local_page_prot_events( &self, ) -> impl Iterator<Item = &PageProtLocalEvent>

Get all the local page prot events.

pub fn reset(&mut self)

Reset the record, without deallocating the event vecs.

impl ExecutionRecord

pub fn finalize_public_values<F: PrimeField32>( &mut self, is_execution_shard: bool, )

Finalize the public values.

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_bit_range_check(&mut self, a: u16, b: u8)

Adds a ByteLookupEvent to verify a is less than 2^b.

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 u16s.

fn add_u16_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 u16 values.

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 DeepSizeOf for ExecutionRecord

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

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

fn eval_public_values<AB: SP1AirBuilder>(builder: &mut AB)

Constrains the public values.

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

The statistics of the record.

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

Appends two records together.

fn interactions_in_public_values() -> Vec<InteractionKind>

The interaction kinds that appear in eval_public_values. Needed so that the shard verifier knows how much randomness to allocate for the LogUpGkr beta_seed challenge.

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.