starknet_committer,apollo_committer: add timers for fetch patricia paths

ArielElp · ArielElp · commit 7bd77dd37049 · 2026-05-27T14:52:43.000+03:00
diff --git a/crates/apollo_committer/src/committer.rs b/crates/apollo_committer/src/committer.rs
@@ -535,11 +535,15 @@ where
             // 4. Merge the two sets of patricia paths and write the result to the storage.
             // 5. Update the commitment offset and return the global root and the patricia proofs.
             CommitBlockHeightPlan::CommitTip { state_diff_commitment } => {
+                let mut block_measurements = SingleBlockMeasurements::default();
+                block_measurements.start_measurement(Action::EndToEnd);
+
                 let pre_roots = self
                     .forest_storage
                     .read_roots(ForestDB::InitialReadContext::create_empty())
                     .await
                     .map_err(|e| self.map_internal_error(e))?;
+                block_measurements.start_measurement(Action::FetchWitnessesFirstPass);
                 let mut patricia_proofs = self
                     .forest_storage
                     .fetch_patricia_witnesses(
@@ -555,16 +559,21 @@ where
                         height,
                         message: format!("pre-commit witness paths: {e:?}"),
                     })?;
+                block_measurements
+                    .attempt_to_stop_measurement(
+                        Action::FetchWitnessesFirstPass,
+                        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?;
                 let post_roots = filled_forest.state_roots();
 
                 let forest_updates = ForestDB::serialize_forest(&filled_forest)
                     .map_err(|e| self.map_internal_error(e))?;
 
+                block_measurements.start_measurement(Action::FetchWitnessesSecondPass);
                 let proof_after = self
                     .forest_storage
                     .fetch_patricia_witnesses(
@@ -580,23 +589,24 @@ where
                         height,
                         message: format!("post-commit witness paths: {e:?}"),
                     })?;
+                block_measurements
+                    .attempt_to_stop_measurement(
+                        Action::FetchWitnessesSecondPass,
+                        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
@@ -655,6 +665,7 @@ impl ComponentStarter for ApolloCommitter {
 }
 
 #[allow(clippy::as_conversions)]
+// TODO: Consider adding fetch witnesses measurements.
 fn update_metrics(
     height: BlockNumber,
     BlockMeasurement { n_reads, n_writes, durations, modifications_counts }: &BlockMeasurement,
diff --git a/crates/starknet_committer/src/block_committer/commit.rs b/crates/starknet_committer/src/block_committer/commit.rs
@@ -12,11 +12,7 @@ use crate::block_committer::input::{
     StarknetStorageValue,
     StateDiff,
 };
-use crate::block_committer::measurements_util::{
-    Action,
-    BlockModificationsCounts,
-    MeasurementsTrait,
-};
+use crate::block_committer::measurements_util::{Action, MeasurementsTrait};
 use crate::db::forest_trait::ForestReader;
 use crate::forest::deleted_nodes::{find_deleted_nodes, DeletedNodes};
 use crate::forest::filled_forest::FilledForest;
@@ -186,10 +182,10 @@ fn measure_number_of_modifications(
         .values()
         .map(|storage_entry| storage_entry.values().filter(|value| value.0 == Felt::ZERO).count())
         .sum::<usize>();
-    measurements.set_number_of_modifications(BlockModificationsCounts {
+    measurements.set_number_of_modifications(
         storage_tries,
-        contracts_trie: n_contracts_trie_modifications,
-        classes_trie: n_classes_trie_modifications,
+        n_contracts_trie_modifications,
+        n_classes_trie_modifications,
         emptied_storage_leaves,
-    });
+    );
 }
diff --git a/crates/starknet_committer/src/block_committer/measurements_util.rs b/crates/starknet_committer/src/block_committer/measurements_util.rs
@@ -11,6 +11,10 @@ pub enum Action {
     Read,
     Compute,
     Write,
+    #[cfg(feature = "os_input")]
+    FetchWitnessesFirstPass,
+    #[cfg(feature = "os_input")]
+    FetchWitnessesSecondPass,
 }
 
 #[derive(Default)]
@@ -19,6 +23,10 @@ pub struct BlockTimers {
     pub read_timer: Option<Instant>,
     pub compute_timer: Option<Instant>,
     pub writer_timer: Option<Instant>,
+    #[cfg(feature = "os_input")]
+    pub fetch_witnesses_first_pass_timer: Option<Instant>,
+    #[cfg(feature = "os_input")]
+    pub fetch_witnesses_second_pass_timer: Option<Instant>,
 }
 
 impl BlockTimers {
@@ -28,6 +36,10 @@ impl BlockTimers {
             Action::Read => &mut self.read_timer,
             Action::Compute => &mut self.compute_timer,
             Action::Write => &mut self.writer_timer,
+            #[cfg(feature = "os_input")]
+            Action::FetchWitnessesFirstPass => &mut self.fetch_witnesses_first_pass_timer,
+            #[cfg(feature = "os_input")]
+            Action::FetchWitnessesSecondPass => &mut self.fetch_witnesses_second_pass_timer,
         }
     }
 
@@ -62,7 +74,13 @@ pub trait MeasurementsTrait {
         entries_count: usize,
     ) -> Result<f64, MeasurementNotStartedError>;
 
-    fn set_number_of_modifications(&mut self, block_modifications_counts: BlockModificationsCounts);
+    fn set_number_of_modifications(
+        &mut self,
+        storage_tries: usize,
+        contracts_trie: usize,
+        classes_trie: usize,
+        emptied_storage_leaves: usize,
+    );
 }
 
 pub struct NoMeasurements;
@@ -80,7 +98,10 @@ impl MeasurementsTrait for NoMeasurements {
 
     fn set_number_of_modifications(
         &mut self,
-        _block_modifications_counts: BlockModificationsCounts,
+        _storage_tries: usize,
+        _contracts_trie: usize,
+        _classes_trie: usize,
+        _emptied_storage_leaves: usize,
     ) {
     }
 }
@@ -91,6 +112,12 @@ pub struct BlockDurations {
     pub read: f64,    // Duration of a read phase (seconds).
     pub compute: f64, // Duration of a computation phase (seconds).
     pub write: f64,   // Duration of a write phase (seconds).
+    #[cfg(feature = "os_input")]
+    // Duration of fetching witnesses w.r.t the old root (seconds).
+    pub fetch_witnesses_first_pass: f64,
+    #[cfg(feature = "os_input")]
+    // Duration of fetching witnesses w.r.t the new root (seconds).
+    pub fetch_witnesses_second_pass: f64,
 }
 
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
@@ -99,6 +126,9 @@ pub struct BlockModificationsCounts {
     pub contracts_trie: usize,
     pub classes_trie: usize,
     pub emptied_storage_leaves: usize,
+    #[cfg(feature = "os_input")]
+    // Number of witnesses fetched in the first pass (pre-commit).
+    pub witnesses: usize,
 }
 
 impl BlockModificationsCounts {
@@ -137,6 +167,15 @@ impl BlockMeasurement {
             Action::EndToEnd => {
                 self.durations.block = duration_in_seconds;
             }
+            #[cfg(feature = "os_input")]
+            Action::FetchWitnessesFirstPass => {
+                self.durations.fetch_witnesses_first_pass = duration_in_seconds;
+                self.modifications_counts.witnesses = entries_count;
+            }
+            #[cfg(feature = "os_input")]
+            Action::FetchWitnessesSecondPass => {
+                self.durations.fetch_witnesses_second_pass = duration_in_seconds;
+            }
         }
     }
 }
@@ -164,8 +203,14 @@ impl MeasurementsTrait for SingleBlockMeasurements {
 
     fn set_number_of_modifications(
         &mut self,
-        block_modifications_counts: BlockModificationsCounts,
+        storage_tries: usize,
+        contracts_trie: usize,
+        classes_trie: usize,
+        emptied_storage_leaves: usize,
     ) {
-        self.block_measurement.modifications_counts = block_modifications_counts;
+        self.block_measurement.modifications_counts.storage_tries = storage_tries;
+        self.block_measurement.modifications_counts.contracts_trie = contracts_trie;
+        self.block_measurement.modifications_counts.classes_trie = classes_trie;
+        self.block_measurement.modifications_counts.emptied_storage_leaves = emptied_storage_leaves;
     }
 }
diff --git a/crates/starknet_committer/src/patricia_merkle_tree/types.rs b/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 {
diff --git a/crates/starknet_committer_cli/Cargo.toml b/crates/starknet_committer_cli/Cargo.toml
@@ -31,3 +31,6 @@ starknet_patricia_storage = { workspace = true, features = [
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 tracing.workspace = true
 tracing-subscriber.workspace = true
+
+[features]
+os_input = ["starknet_committer/os_input"]
diff --git a/crates/starknet_committer_cli/src/utils.rs b/crates/starknet_committer_cli/src/utils.rs
@@ -8,7 +8,6 @@ use starknet_api::hash::HashOutput;
 use starknet_committer::block_committer::measurements_util::{
     Action,
     BlockMeasurement,
-    BlockModificationsCounts,
     MeasurementNotStartedError,
     MeasurementsTrait,
     SingleBlockMeasurements,
@@ -79,9 +78,17 @@ impl MeasurementsTrait for BenchmarkMeasurements {
 
     fn set_number_of_modifications(
         &mut self,
-        block_modifications_counts: BlockModificationsCounts,
+        storage_tries: usize,
+        contracts_trie: usize,
+        classes_trie: usize,
+        emptied_storage_leaves: usize,
     ) {
-        self.current_measurement.set_number_of_modifications(block_modifications_counts);
+        self.current_measurement.set_number_of_modifications(
+            storage_tries,
+            contracts_trie,
+            classes_trie,
+            emptied_storage_leaves,
+        );
     }
 }
 
diff --git a/crates/starknet_committer_cli/src/utils_test.rs b/crates/starknet_committer_cli/src/utils_test.rs
@@ -18,12 +18,12 @@ const N_MODIFICATIONS: usize = 100;
 const N_EMPTY_LEAVES: usize = 10;
 
 async fn measure_block(measurements: &mut BenchmarkMeasurements) {
-    measurements.set_number_of_modifications(BlockModificationsCounts {
-        storage_tries: N_MODIFICATIONS,
-        contracts_trie: N_MODIFICATIONS,
-        classes_trie: N_MODIFICATIONS,
-        emptied_storage_leaves: N_EMPTY_LEAVES,
-    });
+    measurements.set_number_of_modifications(
+        N_MODIFICATIONS,
+        N_MODIFICATIONS,
+        N_MODIFICATIONS,
+        N_EMPTY_LEAVES,
+    );
     measurements.start_measurement(Action::EndToEnd);
     measurements.start_measurement(Action::Read);
     sleep(Duration::from_secs_f64(READ_DURATION)).await;
@@ -70,6 +70,8 @@ fn assert_block_measurement(measurements: &BenchmarkMeasurements, number_of_bloc
                 contracts_trie: N_MODIFICATIONS,
                 classes_trie: N_MODIFICATIONS,
                 emptied_storage_leaves: N_EMPTY_LEAVES,
+                #[cfg(feature = "os_input")]
+                witnesses: 0,
             }
         );
     }

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,15 @@ impl StarknetForestProofs {`
`58`	`58`	`self.contracts_trie_storage_proofs.entry(address).or_default().extend(proof);`
`59`	`59`	`}`
`60`	`60`	`}`
	`61`	`+`
	`62`	`+ pub fn len(&self) -> usize {`
	`63`	`+ self.classes_trie_proof.len()`
	`64`	`+ + self.contracts_trie_proof.nodes.len()`
	`65`	`+ + self`
	`66`	`+ .contracts_trie_storage_proofs`
	`67`	`+ .values()`
	`68`	`+ .fold(0, \|count, proofs\| count + proofs.len())`
	`69`	`+ }`
`61`	`70`	`}`
`62`	`71`
`63`	`72`	`pub struct RootHashes {`