Struct sp1_core::runtime::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<ECAddEvent>,
    pub ed_decompress_events: Vec<EdDecompressEvent>,
    pub secp256k1_add_events: Vec<ECAddEvent>,
    pub secp256k1_double_events: Vec<ECDoubleEvent>,
    pub bn254_add_events: Vec<ECAddEvent>,
    pub bn254_double_events: Vec<ECDoubleEvent>,
    pub k256_decompress_events: Vec<ECDecompressEvent>,
    pub bls12381_add_events: Vec<ECAddEvent>,
    pub bls12381_double_events: Vec<ECDoubleEvent>,
    pub uint256_mul_events: Vec<Uint256MulEvent>,
    pub memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>,
    pub bls12381_decompress_events: Vec<ECDecompressEvent>,
    pub public_values: PublicValues<u32, u32>,
    pub nonce_lookup: HashMap<u128, 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>>

All byte lookups that are needed.

The layout is shard -> (event -> count). Byte lookups are sharded to prevent the multiplicities from overflowing.

sha_extend_events: Vec<ShaExtendEvent>

sha_compress_events: Vec<ShaCompressEvent>

keccak_permute_events: Vec<KeccakPermuteEvent>

ed_add_events: Vec<ECAddEvent>

ed_decompress_events: Vec<EdDecompressEvent>

secp256k1_add_events: Vec<ECAddEvent>

secp256k1_double_events: Vec<ECDoubleEvent>

bn254_add_events: Vec<ECAddEvent>

bn254_double_events: Vec<ECDoubleEvent>

k256_decompress_events: Vec<ECDecompressEvent>

bls12381_add_events: Vec<ECAddEvent>

bls12381_double_events: Vec<ECDoubleEvent>

uint256_mul_events: Vec<Uint256MulEvent>

memory_initialize_events: Vec<MemoryInitializeFinalizeEvent>

memory_finalize_events: Vec<MemoryInitializeFinalizeEvent>

bls12381_decompress_events: Vec<ECDecompressEvent>

public_values: PublicValues<u32, u32>

The public values.

nonce_lookup: HashMap<u128, u32>

Implementations

impl ExecutionRecord

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

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

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

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

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>>>, )

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: u32, 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: u32, a: u32)

Adds a ByteLookupEvent to verify a is indeed u16.

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

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

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

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

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

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

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.