chore(benches): clean up criterion callsites

DaniPopes · DaniPopes · commit ddb85504c37c · 2025-08-01T23:56:29.000+02:00
diff --git a/bins/revme/src/cmd/bench/analysis.rs b/bins/revme/src/cmd/bench/analysis.rs
@@ -24,13 +24,8 @@ pub fn run(criterion: &mut Criterion) {
     let mut evm = context.build_mainnet();
     criterion.bench_function("analysis", |b| {
         b.iter_batched(
-            || {
-                // create a transaction input
-                tx.clone()
-            },
-            |input| {
-                let _ = evm.transact_one(input);
-            },
+            || tx.clone(),
+            |input| evm.transact_one(input).unwrap(),
             criterion::BatchSize::SmallInput,
         );
     });
diff --git a/bins/revme/src/cmd/bench/burntpix.rs b/bins/revme/src/cmd/bench/burntpix.rs
@@ -51,13 +51,8 @@ pub fn run(criterion: &mut Criterion) {
 
     criterion.bench_function("burntpix", |b| {
         b.iter_batched(
-            || {
-                // create a transaction input
-                tx.clone()
-            },
-            |input| {
-                evm.transact_one(input).unwrap();
-            },
+            || tx.clone(),
+            |input| evm.transact_one(input).unwrap(),
             criterion::BatchSize::SmallInput,
         );
     });
diff --git a/bins/revme/src/cmd/bench/gas_cost_estimator.rs b/bins/revme/src/cmd/bench/gas_cost_estimator.rs
@@ -35,13 +35,8 @@ pub fn run(criterion: &mut Criterion) {
 
         criterion.bench_function(name, |b| {
             b.iter_batched(
-                || {
-                    // create a transaction input
-                    tx.clone()
-                },
-                |input| {
-                    let _ = evm.transact_one(input).unwrap();
-                },
+                || tx.clone(),
+                |input| evm.transact_one(input).unwrap(),
                 criterion::BatchSize::SmallInput,
             );
         });
diff --git a/bins/revme/src/cmd/bench/snailtracer.rs b/bins/revme/src/cmd/bench/snailtracer.rs
@@ -27,26 +27,16 @@ pub fn run(criterion: &mut Criterion) {
 
     criterion.bench_function("snailtracer", |b| {
         b.iter_batched(
-            || {
-                // create a transaction input
-                tx.clone()
-            },
-            |input| {
-                let _ = evm.transact_one(input).unwrap();
-            },
+            || tx.clone(),
+            |input| evm.transact_one(input).unwrap(),
             criterion::BatchSize::SmallInput,
         );
     });
 
     criterion.bench_function("analysis-inspector", |b| {
         b.iter_batched(
-            || {
-                // create a transaction input
-                tx.clone()
-            },
-            |input| {
-                let _ = evm.inspect_one_tx(input);
-            },
+            || tx.clone(),
+            |input| evm.inspect_one_tx(input),
             criterion::BatchSize::SmallInput,
         );
     });
diff --git a/bins/revme/src/cmd/bench/transfer.rs b/bins/revme/src/cmd/bench/transfer.rs
@@ -28,13 +28,10 @@ pub fn run(criterion: &mut Criterion) {
     let mut i = 0;
     criterion.bench_function("transfer", |b| {
         b.iter_batched(
-            || {
-                // create a transfer input
-                tx.clone()
-            },
+            || tx.clone(),
             |input| {
                 i += 1;
-                evm.transact_one(input).unwrap();
+                evm.transact_one(input).unwrap()
             },
             criterion::BatchSize::SmallInput,
         );
@@ -57,9 +54,5 @@ pub fn run(criterion: &mut Criterion) {
 
     evm.modify_cfg(|cfg| cfg.disable_nonce_check = false);
 
-    criterion.bench_function("transfer_finalize", |b| {
-        b.iter(|| {
-            let _ = evm.replay().unwrap();
-        })
-    });
+    criterion.bench_function("transfer_finalize", |b| b.iter(|| evm.replay().unwrap()));
 }
diff --git a/bins/revme/src/cmd/bench/transfer_multi.rs b/bins/revme/src/cmd/bench/transfer_multi.rs
@@ -51,10 +51,7 @@ pub fn run(criterion: &mut Criterion) {
 
     criterion.bench_function("transact_commit_1000txs", |b| {
         b.iter_batched(
-            || {
-                // create transaction inputs
-                txs.clone()
-            },
+            || txs.clone(),
             |inputs| {
                 for tx in inputs {
                     let _ = evm.transact_commit(tx).unwrap();
@@ -66,10 +63,7 @@ pub fn run(criterion: &mut Criterion) {
 
     criterion.bench_function("transact_1000tx_commit_inner_every_40", |b| {
         b.iter_batched(
-            || {
-                // create transaction inputs
-                txs.clone()
-            },
+            || txs.clone(),
             |inputs| {
                 for (i, tx) in inputs.into_iter().enumerate() {
                     let _ = evm.transact_one(tx).unwrap();
diff --git a/bins/revme/src/cmd/evmrunner.rs b/bins/revme/src/cmd/evmrunner.rs
@@ -109,29 +109,29 @@ impl Cmd {
                 .without_plots();
             let mut criterion_group = criterion.benchmark_group("revme");
             criterion_group.bench_function("evm", |b| {
-                b.iter(|| {
-                    let _ = evm.transact(tx.clone()).unwrap();
-                })
+                b.iter_batched(
+                    || tx.clone(),
+                    |input| evm.transact(input).unwrap(),
+                    criterion::BatchSize::SmallInput,
+                );
             });
             criterion_group.finish();
 
             return Ok(());
         }
 
         let time = Instant::now();
-        let state = if self.trace {
-            evm.inspect_tx(tx.clone())
-                .map_err(|_| Errors::EVMError)?
-                .state
+        let r = if self.trace {
+            evm.inspect_tx(tx)
         } else {
-            let out = evm.transact(tx.clone()).map_err(|_| Errors::EVMError)?;
-            println!("Result: {:#?}", out.result);
-            out.state
-        };
+            evm.transact(tx)
+        }
+        .map_err(|_| Errors::EVMError)?;
         let time = time.elapsed();
 
+        println!("Result: {:#?}", r.result);
         if self.state {
-            println!("State: {state:#?}");
+            println!("State: {:#?}", r.state);
         }
 
         println!("Elapsed: {time:?}");
diff --git a/bins/revme/src/main.rs b/bins/revme/src/main.rs
@@ -1,22 +1,17 @@
 use clap::Parser;
-use revme::cmd::{Error, MainCmd};
+use revme::cmd::MainCmd;
+use std::process::ExitCode;
 
-fn main() -> Result<(), Error> {
-    set_thread_panic_hook();
-    MainCmd::parse().run().inspect_err(|e| println!("{e:?}"))
-}
+fn main() -> ExitCode {
+    if std::env::var_os("RUST_BACKTRACE").is_none() {
+        unsafe { std::env::set_var("RUST_BACKTRACE", "1") };
+    }
 
-/// Sets thread panic hook, useful for having tests that panic.
-fn set_thread_panic_hook() {
-    use std::{
-        backtrace::Backtrace,
-        panic::{set_hook, take_hook},
-        process::exit,
-    };
-    let orig_hook = take_hook();
-    set_hook(Box::new(move |panic_info| {
-        println!("Custom backtrace: {}", Backtrace::capture());
-        orig_hook(panic_info);
-        exit(1);
-    }));
+    match MainCmd::parse().run() {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("error:\n- {e}\n- {e:#?}");
+            ExitCode::FAILURE
+        }
+    }
 }
diff --git a/crates/bytecode/src/iter.rs b/crates/bytecode/src/iter.rs
@@ -6,10 +6,10 @@ use crate::{opcode, Bytecode, OpCode};
 /// without dealing with the immediate values that follow instructions.
 #[derive(Debug, Clone)]
 pub struct BytecodeIterator<'a> {
-    /// Start pointer of the bytecode. Only used to calculate [`position`](Self::position).
-    start: *const u8,
     /// Iterator over the bytecode bytes.
     bytes: core::slice::Iter<'a, u8>,
+    /// Start pointer of the bytecode. Only used to calculate [`position`](Self::position).
+    start: *const u8,
 }
 
 impl<'a> BytecodeIterator<'a> {
@@ -21,8 +21,8 @@ impl<'a> BytecodeIterator<'a> {
             Bytecode::Eip7702(_) => &[],
         };
         Self {
-            start: bytes.as_ptr(),
             bytes: bytes.iter(),
+            start: bytes.as_ptr(),
         }
     }
 
@@ -40,15 +40,13 @@ impl<'a> BytecodeIterator<'a> {
     /// Returns the current position in the bytecode.
     #[inline]
     pub fn position(&self) -> usize {
-        (self.bytes.as_slice().as_ptr() as usize) - (self.start as usize)
-        // TODO: Use the following on 1.87
         // SAFETY: `start` always points to the start of the bytecode.
-        // unsafe {
-        //     self.bytes
-        //         .as_slice()
-        //         .as_ptr()
-        //         .offset_from_unsigned(self.start)
-        // }
+        unsafe {
+            self.bytes
+                .as_slice()
+                .as_ptr()
+                .offset_from_unsigned(self.start)
+        }
     }
 
     #[inline]
diff --git a/crates/handler/src/instructions.rs b/crates/handler/src/instructions.rs
@@ -45,14 +45,16 @@ where
         Self::new(instruction_table::<WIRE, HOST>())
     }
 
-    /// Rerurns new `EthInstructions` with custom instruction table.
+    /// Returns an instance new `EthInstructions` with custom instruction table.
+    #[inline]
     pub fn new(base_table: InstructionTable<WIRE, HOST>) -> Self {
         Self {
             instruction_table: Box::new(base_table),
         }
     }
 
-    /// Inserts a new instruction into the instruction table.s
+    /// Inserts a new instruction into the instruction table.
+    #[inline]
     pub fn insert_instruction(&mut self, opcode: u8, instruction: Instruction<WIRE, HOST>) {
         self.instruction_table[opcode as usize] = instruction;
     }

Original file line number	Diff line number	Diff line change
`@@ -45,14 +45,16 @@ where`
`45`	`45`	`Self::new(instruction_table::<WIRE, HOST>())`
`46`	`46`	`}`
`47`	`47`
`48`		- /// Rerurns new `EthInstructions` with custom instruction table.
	`48`	+ /// Returns an instance new `EthInstructions` with custom instruction table.
	`49`	`+ #[inline]`
`49`	`50`	`pub fn new(base_table: InstructionTable<WIRE, HOST>) -> Self {`
`50`	`51`	`Self {`
`51`	`52`	`instruction_table: Box::new(base_table),`
`52`	`53`	`}`
`53`	`54`	`}`
`54`	`55`
`55`		`- /// Inserts a new instruction into the instruction table.s`
	`56`	`+ /// Inserts a new instruction into the instruction table.`
	`57`	`+ #[inline]`
`56`	`58`	`pub fn insert_instruction(&mut self, opcode: u8, instruction: Instruction<WIRE, HOST>) {`
`57`	`59`	`self.instruction_table[opcode as usize] = instruction;`
`58`	`60`	`}`