From a5853f86b72a703b60e35f1e7b8239ddb8f649bd Mon Sep 17 00:00:00 2001 From: Omar Abdulla Date: Wed, 22 Oct 2025 14:48:16 +0300 Subject: [PATCH] Add step information to the benchmark report --- .../src/differential_benchmarks/watcher.rs | 35 ++++++++++++++++--- crates/report/src/aggregator.rs | 19 ++++++++-- crates/report/src/runner_event.rs | 16 ++++++++- 3 files changed, 62 insertions(+), 8 deletions(-) diff --git a/crates/core/src/differential_benchmarks/watcher.rs b/crates/core/src/differential_benchmarks/watcher.rs index 44762ad..603ebca 100644 --- a/crates/core/src/differential_benchmarks/watcher.rs +++ b/crates/core/src/differential_benchmarks/watcher.rs @@ -1,4 +1,9 @@ -use std::{collections::HashMap, pin::Pin, sync::Arc}; +use std::{ + collections::HashMap, + pin::Pin, + sync::Arc, + time::{SystemTime, UNIX_EPOCH}, +}; use alloy::primitives::{BlockNumber, TxHash}; use anyhow::Result; @@ -6,7 +11,7 @@ use futures::{Stream, StreamExt}; use revive_dt_common::types::PlatformIdentifier; use revive_dt_format::steps::StepPath; use revive_dt_node_interaction::MinedBlockInformation; -use revive_dt_report::ExecutionSpecificReporter; +use revive_dt_report::{ExecutionSpecificReporter, TransactionInformation}; use tokio::sync::{ RwLock, mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel}, @@ -69,7 +74,7 @@ impl Watcher { // watch for them in the blocks. The watcher will keep watching for blocks until it sees // that all of the transactions that it was watching for has been seen in the mined blocks. let watch_for_transaction_hashes = - Arc::new(RwLock::new(HashMap::::new())); + Arc::new(RwLock::new(HashMap::::new())); // A boolean that keeps track of whether all of the transactions were submitted or if more // txs are expected to come through the receive side of the channel. We do not want to rely @@ -96,7 +101,7 @@ impl Watcher { watch_for_transaction_hashes .write() .await - .insert(transaction_hash, step_path); + .insert(transaction_hash, (step_path, SystemTime::now())); } WatcherEvent::AllTransactionsSubmitted => { *all_transactions_submitted.write().await = true; @@ -108,6 +113,7 @@ impl Watcher { } } }; + let reporter = self.reporter.clone(); let block_information_watching_task = { let watch_for_transaction_hashes = watch_for_transaction_hashes.clone(); let all_transactions_submitted = all_transactions_submitted.clone(); @@ -146,7 +152,26 @@ impl Watcher { let mut watch_for_transaction_hashes = watch_for_transaction_hashes.write().await; for tx_hash in block.ethereum_block_information.transaction_hashes.iter() { - watch_for_transaction_hashes.remove(tx_hash); + let Some((step_path, submission_time)) = + watch_for_transaction_hashes.remove(tx_hash) + else { + continue; + }; + let transaction_information = TransactionInformation { + transaction_hash: *tx_hash, + submission_timestamp: submission_time + .duration_since(UNIX_EPOCH) + .expect("Can't fail") + .as_secs() as _, + block_timestamp: block.ethereum_block_information.block_timestamp, + block_number: block.ethereum_block_information.block_number, + }; + reporter + .report_step_transaction_information_event( + step_path, + transaction_information, + ) + .expect("Can't fail") } // region:TEMPORARY diff --git a/crates/report/src/aggregator.rs b/crates/report/src/aggregator.rs index dcad23a..dee8ba5 100644 --- a/crates/report/src/aggregator.rs +++ b/crates/report/src/aggregator.rs @@ -107,6 +107,10 @@ impl ReportAggregator { self.handle_completion(*event); break; } + /* Benchmarks Events */ + RunnerEvent::StepTransactionInformation(event) => { + self.handle_step_transaction_information(*event) + } } } debug!("Report aggregation completed"); @@ -385,6 +389,17 @@ impl ReportAggregator { self.runner_rx.close(); } + fn handle_step_transaction_information(&mut self, event: StepTransactionInformationEvent) { + self.test_case_report(&event.execution_specifier.test_specifier) + .steps + .entry(event.step_path) + .or_default() + .transactions + .entry(event.execution_specifier.platform_identifier) + .or_default() + .push(event.transaction_information); + } + fn test_case_report(&mut self, specifier: &TestSpecifier) -> &mut ExecutionReport { self.report .execution_information @@ -466,6 +481,7 @@ pub struct ExecutionReport { pub metrics: Option, /// Information related to the execution on one of the platforms. pub platform_execution: PlatformKeyedInformation>, + /// Information tracked for each step that was executed. pub steps: BTreeMap, } @@ -566,7 +582,7 @@ pub enum CompilationStatus { } /// Information on each step in the execution. -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Default, Serialize, Deserialize)] pub struct StepReport { /// Information on the transactions submitted as part of this step. transactions: PlatformKeyedInformation>, @@ -579,7 +595,6 @@ pub struct TransactionInformation { pub submission_timestamp: u64, pub block_timestamp: u64, pub block_number: BlockNumber, - pub gas_used: u64, } /// The metrics we collect for our benchmarks. diff --git a/crates/report/src/runner_event.rs b/crates/report/src/runner_event.rs index c91334a..bcce3f1 100644 --- a/crates/report/src/runner_event.rs +++ b/crates/report/src/runner_event.rs @@ -10,9 +10,11 @@ use revive_dt_common::types::PlatformIdentifier; use revive_dt_compiler::{CompilerInput, CompilerOutput}; use revive_dt_format::metadata::ContractInstance; use revive_dt_format::metadata::Metadata; +use revive_dt_format::steps::StepPath; use semver::Version; use tokio::sync::{broadcast, oneshot}; +use crate::TransactionInformation; use crate::{ExecutionSpecifier, ReporterEvent, TestSpecifier, common::MetadataFilePath}; macro_rules! __report_gen_emit_test_specific { @@ -609,7 +611,19 @@ define_event! { address: Address }, /// Reports the completion of the run. - Completion {} + Completion {}, + + /* Benchmarks Events */ + /// An event emitted with information on a transaction that was submitted for a certain step + /// of the execution. + StepTransactionInformation { + /// A specifier for the execution that's taking place. + execution_specifier: Arc, + /// The path of the step that this transaction belongs to. + step_path: StepPath, + /// Information about the transaction + transaction_information: TransactionInformation + } } }