chore: fvs circuit statistics tracers interface

eravm-stable-interface/src/state_interface.rs

@@ -4,6 +4,7 @@ pub trait StateInterface {
     fn read_register(&self, register: u8) -> (U256, bool);
     fn set_register(&mut self, register: u8, value: U256, is_pointer: bool);
 
+    fn current_frame(&mut self) -> impl CallframeInterface + '_;
     fn number_of_callframes(&self) -> usize;
     /// zero is the current frame, one is the frame before that etc.
     fn callframe(&mut self, n: usize) -> impl CallframeInterface + '_;
@@ -132,6 +133,10 @@ impl StateInterface for DummyState {
         unimplemented!()
     }
 
+    fn current_frame(&mut self) -> impl CallframeInterface + '_ {
+        DummyState
+    }
+
     fn number_of_callframes(&self) -> usize {
         unimplemented!()
     }

eravm-stable-interface/src/tracer_interface.rs

@@ -208,6 +208,19 @@ impl<T: opcodes::TypeLevelReturnType> OpcodeType for opcodes::Ret<T> {
 pub trait Tracer {
     fn before_instruction<OP: OpcodeType, S: StateInterface>(&mut self, _state: &mut S) {}
     fn after_instruction<OP: OpcodeType, S: StateInterface>(&mut self, _state: &mut S) {}
+
+    fn on_extra_prover_cycles(&mut self, _stats: CycleStats) {}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum CycleStats {
+    Keccak256(u32),
+    Sha256(u32),
+    EcRecover(u32),
+    Secp256k1Verify(u32),
+    Decommit(u32),
+    StorageRead,
+    StorageWrite,
 }
 
 impl Tracer for () {}
@@ -223,6 +236,11 @@ impl<A: Tracer, B: Tracer> Tracer for (A, B) {
         self.0.after_instruction::<OP, S>(state);
         self.1.after_instruction::<OP, S>(state);
     }
+
+    fn on_extra_prover_cycles(&mut self, stats: CycleStats) {
+        self.0.on_extra_prover_cycles(stats);
+        self.1.on_extra_prover_cycles(stats);
+    }
 }
 
 #[cfg(test)]

src/decommit.rs

@@ -1,13 +1,15 @@
 use crate::{program::Program, world_diff::WorldDiff, World};
+use eravm_stable_interface::{CycleStats, Tracer};
 use u256::{H160, U256};
 use zkevm_opcode_defs::{
     ethereum_types::Address, system_params::DEPLOYER_SYSTEM_CONTRACT_ADDRESS_LOW,
 };
 
 impl WorldDiff {
-    pub(crate) fn decommit<T>(
+    pub(crate) fn decommit<T: Tracer>(
         &mut self,
         world: &mut impl World<T>,
+        tracer: &mut T,
         address: U256,
         default_aa_code_hash: [u8; 32],
         evm_interpreter_code_hash: [u8; 32],
@@ -19,8 +21,12 @@ impl WorldDiff {
         let mut is_evm = false;
 
         let mut code_info = {
-            let code_info =
-                self.read_storage_without_refund(world, deployer_system_contract_address, address);
+            let code_info = self.read_storage_without_refund(
+                world,
+                tracer,
+                deployer_system_contract_address,
+                address,
+            );
             let mut code_info_bytes = [0; 32];
             code_info.to_big_endian(&mut code_info_bytes);
 
@@ -81,21 +87,25 @@ impl WorldDiff {
     /// Returns the decommitted contract code and a flag set to `true` if this is a fresh decommit (i.e.,
     /// the code wasn't decommitted previously in the same VM run).
     #[doc(hidden)] // should be used for testing purposes only; can break VM operation otherwise
-    pub fn decommit_opcode<T>(
+    pub fn decommit_opcode<T: Tracer>(
         &mut self,
         world: &mut impl World<T>,
+        tracer: &mut T,
         code_hash: U256,
     ) -> (Vec<u8>, bool) {
-        let was_decommitted = self.decommitted_hashes.as_ref().get(&code_hash) == Some(&true);
-        if !was_decommitted {
-            self.decommitted_hashes.insert(code_hash, true);
+        let is_new = self.decommitted_hashes.insert(code_hash, true) != Some(true);
+        let code = world.decommit_code(code_hash);
+        if is_new {
+            // Decommitter can process two words per cycle
+            tracer.on_extra_prover_cycles(CycleStats::Decommit((code.len() as u32 + 63) / 64));
         }
-        (world.decommit_code(code_hash), !was_decommitted)
+        (code, is_new)
     }
 
-    pub(crate) fn pay_for_decommit<T, W: World<T>>(
+    pub(crate) fn pay_for_decommit<T: Tracer, W: World<T>>(
         &mut self,
         world: &mut W,
+        tracer: &mut T,
         decommit: UnpaidDecommit,
         gas: &mut u32,
     ) -> Option<Program<T, W>> {
@@ -107,9 +117,17 @@ impl WorldDiff {
             return None;
         }
 
-        self.decommitted_hashes.insert(decommit.code_key, true);
+        let is_new = self.decommitted_hashes.insert(decommit.code_key, true) != Some(true);
         *gas -= decommit.cost;
-        Some(world.decommit(decommit.code_key))
+
+        let decommit = world.decommit(decommit.code_key);
+        if is_new {
+            tracer.on_extra_prover_cycles(CycleStats::Decommit(
+                (decommit.code_page().len() as u32 + 1) / 2,
+            ));
+        }
+
+        Some(decommit)
     }
 }
 

src/instruction_handlers/binop.rs

@@ -1,4 +1,4 @@
-use super::common::instruction_boilerplate;
+use super::common::boilerplate;
 use crate::{
     addressing_modes::{
         AbsoluteStack, Addressable, AdvanceStackPointer, AnyDestination, AnySource, Arguments,
@@ -28,7 +28,7 @@ fn binop<
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<Op, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate::<Op, _, _>(vm, world, tracer, |vm, args| {
         let a = In1::get(args, &mut vm.state);
         let b = Register2::get(args, &mut vm.state);
         let (a, b) = if SWAP { (b, a) } else { (a, b) };

src/instruction_handlers/common.rs

@@ -3,28 +3,67 @@ use crate::{addressing_modes::Arguments, instruction::ExecutionStatus, VirtualMa
 use eravm_stable_interface::{opcodes, OpcodeType, Tracer};
 
 #[inline(always)]
-pub(crate) fn instruction_boilerplate<Opcode: OpcodeType, T: Tracer, W>(
+pub(crate) fn boilerplate<Opcode: OpcodeType, T: Tracer, W>(
+    vm: &mut VirtualMachine<T, W>,
+    world: &mut W,
+    tracer: &mut T,
+    business_logic: impl FnOnce(&mut VirtualMachine<T, W>, &Arguments),
+) -> ExecutionStatus {
+    full_boilerplate::<Opcode, T, W>(vm, world, tracer, |vm, args, _, _| {
+        business_logic(vm, args);
+        ExecutionStatus::Running
+    })
+}
+
+#[inline(always)]
+pub(crate) fn boilerplate_w<Opcode: OpcodeType, T: Tracer, W>(
     vm: &mut VirtualMachine<T, W>,
     world: &mut W,
     tracer: &mut T,
     business_logic: impl FnOnce(&mut VirtualMachine<T, W>, &Arguments, &mut W),
 ) -> ExecutionStatus {
-    instruction_boilerplate_ext::<Opcode, T, W>(vm, world, tracer, |vm, args, _, world| {
+    full_boilerplate::<Opcode, T, W>(vm, world, tracer, |vm, args, world, _| {
         business_logic(vm, args, world);
         ExecutionStatus::Running
     })
 }
 
 #[inline(always)]
-pub(crate) fn instruction_boilerplate_ext<Opcode: OpcodeType, T: Tracer, W>(
+pub(crate) fn boilerplate_t<Opcode: OpcodeType, T: Tracer, W>(
+    vm: &mut VirtualMachine<T, W>,
+    world: &mut W,
+    tracer: &mut T,
+    business_logic: impl FnOnce(&mut VirtualMachine<T, W>, &Arguments, &mut T),
+) -> ExecutionStatus {
+    full_boilerplate::<Opcode, T, W>(vm, world, tracer, |vm, args, _, tracer| {
+        business_logic(vm, args, tracer);
+        ExecutionStatus::Running
+    })
+}
+
+#[inline(always)]
+pub(crate) fn boilerplate_wt<Opcode: OpcodeType, T: Tracer, W>(
+    vm: &mut VirtualMachine<T, W>,
+    world: &mut W,
+    tracer: &mut T,
+    business_logic: impl FnOnce(&mut VirtualMachine<T, W>, &Arguments, &mut W, &mut T),
+) -> ExecutionStatus {
+    full_boilerplate::<Opcode, T, W>(vm, world, tracer, |vm, args, world, tracer| {
+        business_logic(vm, args, world, tracer);
+        ExecutionStatus::Running
+    })
+}
+
+#[inline(always)]
+pub(crate) fn full_boilerplate<Opcode: OpcodeType, T: Tracer, W>(
     vm: &mut VirtualMachine<T, W>,
     world: &mut W,
     tracer: &mut T,
     business_logic: impl FnOnce(
         &mut VirtualMachine<T, W>,
         &Arguments,
-        &mut T,
         &mut W,
+        &mut T,
     ) -> ExecutionStatus,
 ) -> ExecutionStatus {
     let args = unsafe { &(*vm.state.current_frame.pc).arguments };
@@ -41,7 +80,7 @@ pub(crate) fn instruction_boilerplate_ext<Opcode: OpcodeType, T: Tracer, W>(
     if args.predicate().satisfied(&vm.state.flags) {
         tracer.before_instruction::<Opcode, _>(vm);
         vm.state.current_frame.pc = unsafe { vm.state.current_frame.pc.add(1) };
-        let result = business_logic(vm, args, tracer, world);
+        let result = business_logic(vm, args, world, tracer);
         tracer.after_instruction::<Opcode, _>(vm);
         result
     } else {

src/instruction_handlers/context.rs

@@ -1,4 +1,4 @@
-use super::common::instruction_boilerplate;
+use super::common::boilerplate;
 use crate::{
     addressing_modes::{Arguments, Destination, Register1, Source},
     decommit::address_into_u256,
@@ -18,7 +18,7 @@ fn context<T: Tracer, W, Op: ContextOp>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<Op, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate::<Op, _, _>(vm, world, tracer, |vm, args| {
         let result = Op::get(&vm.state);
         Register1::set(args, &mut vm.state, result)
     })
@@ -69,7 +69,7 @@ fn context_meta<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::ContextMeta, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate::<opcodes::ContextMeta, _, _>(vm, world, tracer, |vm, args| {
         let result = VmMetaParameters {
             heap_size: vm.state.current_frame.heap_size,
             aux_heap_size: vm.state.current_frame.aux_heap_size,
@@ -94,7 +94,7 @@ fn set_context_u128<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::SetContextU128, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate::<opcodes::SetContextU128, _, _>(vm, world, tracer, |vm, args| {
         let value = Register1::get(args, &mut vm.state).low_u128();
         vm.state.set_context_u128(value);
     })
@@ -105,7 +105,7 @@ fn increment_tx_number<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::IncrementTxNumber, _, _>(vm, world, tracer, |vm, _, _| {
+    boilerplate::<opcodes::IncrementTxNumber, _, _>(vm, world, tracer, |vm, _| {
         vm.start_new_tx();
     })
 }
@@ -115,7 +115,7 @@ fn aux_mutating<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::AuxMutating0, _, _>(vm, world, tracer, |_, _, _| {
+    boilerplate::<opcodes::AuxMutating0, _, _>(vm, world, tracer, |_, _| {
         // This instruction just crashes or nops
     })
 }

src/instruction_handlers/decommit.rs

@@ -1,4 +1,4 @@
-use super::common::instruction_boilerplate;
+use super::common::boilerplate_wt;
 use crate::{
     addressing_modes::{Arguments, Destination, Register1, Register2, Source},
     fat_pointer::FatPointer,
@@ -14,7 +14,7 @@ fn decommit<T: Tracer, W: World<T>>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::Decommit, _, _>(vm, world, tracer, |vm, args, world| {
+    boilerplate_wt::<opcodes::Decommit, _, _>(vm, world, tracer, |vm, args, world, tracer| {
         let code_hash = Register1::get(args, &mut vm.state);
         let extra_cost = Register2::get(args, &mut vm.state).low_u32();
 
@@ -32,7 +32,7 @@ fn decommit<T: Tracer, W: World<T>>(
             return;
         }
 
-        let (program, is_fresh) = vm.world_diff.decommit_opcode(world, code_hash);
+        let (program, is_fresh) = vm.world_diff.decommit_opcode(world, tracer, code_hash);
         if !is_fresh {
             vm.state.current_frame.gas += extra_cost;
         }

src/instruction_handlers/event.rs

@@ -1,4 +1,4 @@
-use super::common::instruction_boilerplate;
+use super::common::boilerplate_w;
 use crate::{
     addressing_modes::{Arguments, Immediate1, Register1, Register2, Source},
     instruction::ExecutionStatus,
@@ -14,7 +14,7 @@ fn event<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::Event, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate_w::<opcodes::Event, _, _>(vm, world, tracer, |vm, args, _| {
         if vm.state.current_frame.address == H160::from_low_u64_be(ADDRESS_EVENT_WRITER as u64) {
             let key = Register1::get(args, &mut vm.state);
             let value = Register2::get(args, &mut vm.state);
@@ -36,7 +36,7 @@ fn l2_to_l1<T: Tracer, W>(
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate::<opcodes::L2ToL1Message, _, _>(vm, world, tracer, |vm, args, _| {
+    boilerplate_w::<opcodes::L2ToL1Message, _, _>(vm, world, tracer, |vm, args, _| {
         let key = Register1::get(args, &mut vm.state);
         let value = Register2::get(args, &mut vm.state);
         let is_service = Immediate1::get(args, &mut vm.state).low_u32() == 1;

src/instruction_handlers/far_call.rs

@@ -1,5 +1,5 @@
 use super::{
-    common::instruction_boilerplate_ext,
+    common::boilerplate_wt,
     heap_access::grow_heap,
     ret::{panic_from_failed_far_call, RETURN_COST},
     AuxHeap, Heap,
@@ -43,7 +43,7 @@ fn far_call<
     world: &mut W,
     tracer: &mut T,
 ) -> ExecutionStatus {
-    instruction_boilerplate_ext::<FarCall<M>, _, _>(vm, world, tracer, |vm, args, tracer, world| {
+    boilerplate_wt::<FarCall<M>, _, _>(vm, world, tracer, |vm, args, world, tracer| {
         let (raw_abi, raw_abi_is_pointer) = Register1::get_with_pointer_flag(args, &mut vm.state);
 
         let address_mask: U256 = U256::MAX >> (256 - 160);
@@ -65,6 +65,7 @@ fn far_call<
         let failing_part = (|| {
             let decommit_result = vm.world_diff.decommit(
                 world,
+                tracer,
                 destination_address,
                 vm.settings.default_aa_code_hash,
                 vm.settings.evm_interpreter_code_hash,
@@ -92,6 +93,7 @@ fn far_call<
             let (unpaid_decommit, is_evm) = decommit_result?;
             let program = vm.world_diff.pay_for_decommit(
                 world,
+                tracer,
                 unpaid_decommit,
                 &mut vm.state.current_frame.gas,
             )?;
@@ -107,7 +109,7 @@ fn far_call<
         let Some((calldata, program, is_evm_interpreter)) = failing_part else {
             vm.state.current_frame.gas += new_frame_gas.saturating_sub(RETURN_COST);
             panic_from_failed_far_call(vm, tracer, exception_handler);
-            return ExecutionStatus::Running;
+            return;
         };
 
         let stipend = if is_evm_interpreter {
@@ -152,8 +154,6 @@ fn far_call<
             | u8::from(abi.is_constructor_call);
 
         vm.state.registers[2] = call_type.into();
-
-        ExecutionStatus::Running
     })
 }