Struct sp1_core_executor::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 byte_lookups: HashMap<u32, HashMap<ByteLookupEvent, usize>>,
    pub sha_extend_events: Vec<ShaExtendEvent>,
    pub sha_compress_events: Vec<ShaCompressEvent>,
    pub keccak_permute_events: Vec<KeccakPermuteEvent>,
    pub ed_add_events: Vec<EllipticCurveAddEvent>,
    pub ed_decompress_events: Vec<EdDecompressEvent>,
    pub secp256k1_add_events: Vec<EllipticCurveAddEvent>,
    pub secp256k1_double_events: Vec<EllipticCurveDoubleEvent>,
    pub bn254_add_events: Vec<EllipticCurveAddEvent>,
    pub bn254_double_events: Vec<EllipticCurveDoubleEvent>,
    pub k256_decompress_events: Vec<EllipticCurveDecompressEvent>,
    pub bls12381_add_events: Vec<EllipticCurveAddEvent>,
    pub bls12381_double_events: Vec<EllipticCurveDoubleEvent>,
    pub uint256_mul_events: Vec<Uint256MulEvent>,
    pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub bls12381_decompress_events: Vec<EllipticCurveDecompressEvent>,
    pub bls12381_fp_events: Vec<FpOpEvent>,
    pub bls12381_fp2_addsub_events: Vec<Fp2AddSubEvent>,
    pub bls12381_fp2_mul_events: Vec<Fp2MulEvent>,
    pub bn254_fp_events: Vec<FpOpEvent>,
    pub bn254_fp2_addsub_events: Vec<Fp2AddSubEvent>,
    pub bn254_fp2_mul_events: Vec<Fp2MulEvent>,
    pub public_values: PublicValues<u32, u32>,
    pub nonce_lookup: HashMap<LookupId, u32>,
}

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.

byte_lookups: HashMap<u32, HashMap<ByteLookupEvent, usize>>

A trace of the byte lookups that are needed.

sha_extend_events: Vec<ShaExtendEvent>

A trace of the sha256 extend events.

sha_compress_events: Vec<ShaCompressEvent>

A trace of the sha256 compress events.

keccak_permute_events: Vec<KeccakPermuteEvent>

A trace of the keccak256 permute events.

ed_add_events: Vec<EllipticCurveAddEvent>

A trace of the edwards add events.

ed_decompress_events: Vec<EdDecompressEvent>

A trace of the edwards decompress events.

secp256k1_add_events: Vec<EllipticCurveAddEvent>

A trace of the secp256k1 add events.

secp256k1_double_events: Vec<EllipticCurveDoubleEvent>

A trace of the secp256k1 double events.

bn254_add_events: Vec<EllipticCurveAddEvent>

A trace of the bn254 add events.

bn254_double_events: Vec<EllipticCurveDoubleEvent>

A trace of the bn254 double events.

k256_decompress_events: Vec<EllipticCurveDecompressEvent>

A trace of the k256 decompress events.

bls12381_add_events: Vec<EllipticCurveAddEvent>

A trace of the bls12381 add events.

bls12381_double_events: Vec<EllipticCurveDoubleEvent>

A trace of the bls12381 double events.

uint256_mul_events: Vec<Uint256MulEvent>

A trace of the uint256 mul events.

memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>

A trace of the memory initialize events.

memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>

A trace of the memory finalize events.

bls12381_decompress_events: Vec<EllipticCurveDecompressEvent>

A trace of the bls12381 decompress events.

bls12381_fp_events: Vec<FpOpEvent>

A trace of the bls12381 fp events.

bls12381_fp2_addsub_events: Vec<Fp2AddSubEvent>

A trace of the bls12381 fp2 add/sub events.

bls12381_fp2_mul_events: Vec<Fp2MulEvent>

A trace of the bls12381 fp2 mul events.

bn254_fp_events: Vec<FpOpEvent>

A trace of the bn254 fp events.

bn254_fp2_addsub_events: Vec<Fp2AddSubEvent>

A trace of the bn254 fp2 add/sub events.

bn254_fp2_mul_events: Vec<Fp2MulEvent>

A trace of the bn254 fp2 mul events.

public_values: PublicValues<u32, u32>

The public values.

nonce_lookup: HashMap<LookupId, u32>

The nonce lookup.

Implementations

impl ExecutionRecord

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

Create a new ExecutionRecord.

pub fn add_mul_event(&mut self, mul_event: AluEvent)

Add a mul event to the execution record.

pub fn add_lt_event(&mut self, lt_event: AluEvent)

Add a lt event to the execution record.

pub fn add_alu_events(&mut self, alu_events: HashMap<Opcode, Vec<AluEvent>>)

Add a batch of alu events to the execution record.

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, opts: SplitOpts) -> Vec<ExecutionRecord>

Splits the deferred ExecutionRecord into multiple ExecutionRecords, each which contain a “reasonable” number of deferred 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_sharded_byte_lookup_events( &mut self, new_events: Vec<&HashMap<u32, HashMap<ByteLookupEvent, usize>>>, )

Adds a list of sharded ByteLookupEvents 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, shard: u32, channel: u8, 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, shard: u32, channel: u8, a: u16)

Adds a ByteLookupEvent to verify a is indeed u16.

fn add_u8_range_checks(&mut self, shard: u32, channel: u8, 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, shard: u32, channel: u8, 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, shard: u32, channel: u8, ls: &[u16])

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

fn lookup_or(&mut self, shard: u32, channel: u8, 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 copy 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.