starknet_committer,apollo_committer: add timers for fetch patricia paths

Author: ArielElp

crates/apollo_committer/src/committer.rs

@@ -21,7 +21,7 @@ use async_trait::async_trait;
 use starknet_api::block::BlockNumber;
 use starknet_api::block_hash::state_diff_hash::calculate_state_diff_hash;
 use starknet_api::core::{GlobalRoot, StateDiffCommitment};
-use starknet_api::hash::PoseidonHash;
+use starknet_api::hash::{HashOutput, PoseidonHash};
 use starknet_api::state::ThinStateDiff;
 use starknet_committer::block_committer::commit::commit_block;
 use starknet_committer::block_committer::input::Input;
@@ -540,6 +540,9 @@ where
                     .read_roots(ForestDB::InitialReadContext::create_empty())
                     .await
                     .map_err(|e| self.map_internal_error(e))?;
+                let mut block_measurements = SingleBlockMeasurements::default();
+                let pre_global_root = HashOutput(pre_roots.global_root().0);
+                block_measurements.start_measurement(Action::FetchPatriciaPaths(pre_global_root));
                 let mut patricia_proofs = self
                     .forest_storage
                     .fetch_patricia_witnesses(
@@ -555,8 +558,13 @@ where
                         height,
                         message: format!("pre-commit witness paths: {e:?}"),
                     })?;
+                block_measurements
+                    .attempt_to_stop_measurement(
+                        Action::FetchPatriciaPaths(pre_global_root),
+                        patricia_proofs.len(),
+                    )
+                    .ok();
 
-                let mut block_measurements = SingleBlockMeasurements::default();
                 block_measurements.start_measurement(Action::EndToEnd);
                 let CommitStateDiffOutput { filled_forest, global_root, deleted_nodes } =
                     self.commit_state_diff(state_diff, &mut block_measurements).await?;
@@ -565,6 +573,8 @@ where
                 let forest_updates = ForestDB::serialize_forest(&filled_forest)
                     .map_err(|e| self.map_internal_error(e))?;
 
+                let post_global_root = HashOutput(post_roots.global_root().0);
+                block_measurements.start_measurement(Action::FetchPatriciaPaths(post_global_root));
                 let proof_after = self
                     .forest_storage
                     .fetch_patricia_witnesses(
@@ -580,23 +590,24 @@ where
                         height,
                         message: format!("post-commit witness paths: {e:?}"),
                     })?;
+                block_measurements
+                    .attempt_to_stop_measurement(
+                        Action::FetchPatriciaPaths(post_global_root),
+                        proof_after.len(),
+                    )
+                    .ok();
 
                 patricia_proofs.extend(proof_after);
 
                 let (metadata, next_offset) =
                     commit_tip_metadata_bundle(height, global_root, state_diff_commitment);
-                let witness_node_count = patricia_proofs.classes_trie_proof.len()
-                    + patricia_proofs.contracts_trie_proof.nodes.len()
-                    + patricia_proofs.contracts_trie_proof.leaves.len()
-                    + patricia_proofs
-                        .contracts_trie_storage_proofs
-                        .values()
-                        .map(|proof| proof.len())
-                        .sum::<usize>();
+
                 info!(
-                    "For block number {height}, writing filled forest and {witness_node_count} \
-                     witness nodes to storage with metadata: {metadata:?}, delete {} nodes",
-                    deleted_nodes.len()
+                    "For block number {height}, writing filled forest and {witness_count} \
+                     witnesses to storage with metadata: {metadata:?}, delete \
+                     {deleted_nodes_count} nodes",
+                    witness_count = patricia_proofs.len(),
+                    deleted_nodes_count = deleted_nodes.len(),
                 );
                 block_measurements.start_measurement(Action::Write);
                 let n_write_entries = self
@@ -657,7 +668,7 @@ impl ComponentStarter for ApolloCommitter {
 #[allow(clippy::as_conversions)]
 fn update_metrics(
     height: BlockNumber,
-    BlockMeasurement { n_reads, n_writes, durations, modifications_counts }: &BlockMeasurement,
+    BlockMeasurement { n_reads, n_writes, durations, modifications_counts, .. }: &BlockMeasurement,
 ) {
     BLOCKS_COMMITTED.increment(1);
     TOTAL_BLOCK_DURATION.increment((durations.block * 1000.0) as u64);

crates/starknet_committer/src/block_committer/measurements_util.rs

@@ -1,5 +1,7 @@
+use std::collections::HashMap;
 use std::time::Instant;
 
+use starknet_api::hash::HashOutput;
 use tracing::error;
 
 #[derive(Debug)]
@@ -11,6 +13,7 @@ pub enum Action {
     Read,
     Compute,
     Write,
+    FetchPatriciaPaths(HashOutput),
 }
 
 #[derive(Default)]
@@ -19,6 +22,7 @@ pub struct BlockTimers {
     pub read_timer: Option<Instant>,
     pub compute_timer: Option<Instant>,
     pub writer_timer: Option<Instant>,
+    pub fetch_patricia_paths_timers: HashMap<HashOutput, Option<Instant>>,
 }
 
 impl BlockTimers {
@@ -28,6 +32,9 @@ impl BlockTimers {
             Action::Read => &mut self.read_timer,
             Action::Compute => &mut self.compute_timer,
             Action::Write => &mut self.writer_timer,
+            Action::FetchPatriciaPaths(root) => {
+                self.fetch_patricia_paths_timers.entry(*root).or_default()
+            }
         }
     }
 
@@ -107,12 +114,20 @@ impl BlockModificationsCounts {
     }
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct FetchPatriciaPathsMeasurement {
+    pub root: HashOutput,
+    pub duration: f64,
+    pub n_entries: usize,
+}
+
 #[derive(Default, Clone)]
 pub struct BlockMeasurement {
     pub n_writes: usize,
     pub n_reads: usize,
     pub durations: BlockDurations,
     pub modifications_counts: BlockModificationsCounts,
+    pub fetch_patricia_paths_measurements: Vec<FetchPatriciaPathsMeasurement>,
 }
 
 impl BlockMeasurement {
@@ -137,6 +152,13 @@ impl BlockMeasurement {
             Action::EndToEnd => {
                 self.durations.block = duration_in_seconds;
             }
+            Action::FetchPatriciaPaths(root) => {
+                self.fetch_patricia_paths_measurements.push(FetchPatriciaPathsMeasurement {
+                    root: *root,
+                    duration: duration_in_seconds,
+                    n_entries: entries_count,
+                });
+            }
         }
     }
 }

crates/starknet_committer/src/patricia_merkle_tree/types.rs

@@ -58,6 +58,15 @@ impl StarknetForestProofs {
             self.contracts_trie_storage_proofs.entry(address).or_default().extend(proof);
         }
     }
+
+    pub fn len(&self) -> usize {
+        self.classes_trie_proof.len()
+            + self.contracts_trie_proof.nodes.len()
+            + self
+                .contracts_trie_storage_proofs
+                .values()
+                .fold(0, |count, proofs| count + proofs.len())
+    }
 }
 
 pub struct RootHashes {