starknet_committer: add number of modifications to BlockMeasurement and impl set function

Author: rotem-starkware

crates/apollo_committer/src/committer.rs

@@ -449,7 +449,7 @@ impl ComponentStarter for ApolloCommitter {
     }
 }
 
-fn update_metrics(BlockMeasurement { n_reads, n_writes, durations }: &BlockMeasurement) {
+fn update_metrics(BlockMeasurement { n_reads, n_writes, durations, .. }: &BlockMeasurement) {
     READ_DURATION_PER_BLOCK.set_lossy(durations.read);
     READ_DURATION_PER_BLOCK_HIST.record_lossy(durations.read);
     READ_DB_ENTRIES_PER_BLOCK.set_lossy(*n_reads);

crates/starknet_committer/src/block_committer/commit.rs

@@ -7,7 +7,11 @@ use tracing::{info, warn};
 
 use crate::block_committer::errors::BlockCommitmentError;
 use crate::block_committer::input::{contract_address_into_node_index, Input, StateDiff};
-use crate::block_committer::measurements_util::{Action, MeasurementsTrait};
+use crate::block_committer::measurements_util::{
+    Action,
+    BlockModificationsCounts,
+    MeasurementsTrait,
+};
 use crate::db::forest_trait::ForestReader;
 use crate::forest::filled_forest::FilledForest;
 use crate::forest::forest_errors::ForestError;
@@ -29,6 +33,7 @@ pub trait CommitBlockTrait: Send {
     ) -> BlockCommitmentResult<FilledForest> {
         let (mut storage_tries_indices, mut contracts_trie_indices, mut classes_trie_indices) =
             get_all_modified_indices(&input.state_diff);
+        let n_contracts_trie_modifications = contracts_trie_indices.len();
         let forest_sorted_indices = ForestSortedIndices {
             storage_tries_sorted_indices: storage_tries_indices
                 .iter_mut()
@@ -39,6 +44,14 @@ pub trait CommitBlockTrait: Send {
         };
         let actual_storage_updates = input.state_diff.actual_storage_updates();
         let actual_classes_updates = input.state_diff.actual_classes_updates();
+        // Record the number of modifications.
+        let n_storage_tries_modifications =
+            actual_storage_updates.values().map(|value| value.len()).sum();
+        measurements.set_number_of_modifications(BlockModificationsCounts {
+            storage_tries: n_storage_tries_modifications,
+            contracts_trie: n_contracts_trie_modifications,
+            classes_trie: actual_classes_updates.len(),
+        });
         // Reads - fetch_nodes.
 
         measurements.start_measurement(Action::Read);

crates/starknet_committer/src/block_committer/measurements_util.rs

@@ -61,6 +61,8 @@ pub trait MeasurementsTrait {
         action: Action,
         entries_count: usize,
     ) -> Result<u128, MeasurementNotStartedError>;
+
+    fn set_number_of_modifications(&mut self, block_modifications_counts: BlockModificationsCounts);
 }
 
 pub struct NoMeasurements;
@@ -75,6 +77,12 @@ impl MeasurementsTrait for NoMeasurements {
     ) -> Result<u128, MeasurementNotStartedError> {
         Err(MeasurementNotStartedError)
     }
+
+    fn set_number_of_modifications(
+        &mut self,
+        _block_modifications_counts: BlockModificationsCounts,
+    ) {
+    }
 }
 
 #[derive(Default, Clone)]
@@ -85,11 +93,19 @@ pub struct BlockDurations {
     pub write: u128,   // Duration of a write phase (milliseconds).
 }
 
+#[derive(Default, Clone, Debug, PartialEq, Eq)]
+pub struct BlockModificationsCounts {
+    pub storage_tries: usize,
+    pub contracts_trie: usize,
+    pub classes_trie: usize,
+}
+
 #[derive(Default, Clone)]
 pub struct BlockMeasurement {
     pub n_writes: usize,
     pub n_reads: usize,
     pub durations: BlockDurations,
+    pub modifications_counts: BlockModificationsCounts,
 }
 
 impl BlockMeasurement {
@@ -138,4 +154,11 @@ impl MeasurementsTrait for SingleBlockMeasurements {
         self.block_measurement.update_after_action(&action, entries_count, duration_in_millis);
         Ok(duration_in_millis)
     }
+
+    fn set_number_of_modifications(
+        &mut self,
+        block_modifications_counts: BlockModificationsCounts,
+    ) {
+        self.block_measurement.modifications_counts = block_modifications_counts;
+    }
 }

crates/starknet_committer_cli/src/utils.rs

@@ -8,6 +8,7 @@ use starknet_api::hash::HashOutput;
 use starknet_committer::block_committer::measurements_util::{
     Action,
     BlockMeasurement,
+    BlockModificationsCounts,
     MeasurementNotStartedError,
     MeasurementsTrait,
     SingleBlockMeasurements,
@@ -75,6 +76,13 @@ impl MeasurementsTrait for BenchmarkMeasurements {
         }
         Ok(duration_in_millis)
     }
+
+    fn set_number_of_modifications(
+        &mut self,
+        block_modifications_counts: BlockModificationsCounts,
+    ) {
+        self.current_measurement.set_number_of_modifications(block_modifications_counts);
+    }
 }
 
 impl BenchmarkMeasurements {
@@ -185,6 +193,9 @@ impl BenchmarkMeasurements {
                     "read_duration_millis",
                     "compute_duration_millis",
                     "write_duration_millis",
+                    "n_storage_tries_modifications",
+                    "n_contracts_trie_modifications",
+                    "n_classes_trie_modifications",
                 ],
                 self.storage_stat_columns.clone(),
             ]
@@ -206,6 +217,9 @@ impl BenchmarkMeasurements {
                 measurement.durations.read.to_string(),
                 measurement.durations.compute.to_string(),
                 measurement.durations.write.to_string(),
+                measurement.modifications_counts.storage_tries.to_string(),
+                measurement.modifications_counts.contracts_trie.to_string(),
+                measurement.modifications_counts.classes_trie.to_string(),
             ];
             if i == n_results - 1 {
                 record

crates/starknet_committer_cli/src/utils_test.rs

@@ -1,6 +1,10 @@
 use std::time::Duration;
 
-use starknet_committer::block_committer::measurements_util::{Action, MeasurementsTrait};
+use starknet_committer::block_committer::measurements_util::{
+    Action,
+    BlockModificationsCounts,
+    MeasurementsTrait,
+};
 use tokio::time::sleep;
 
 use crate::utils::BenchmarkMeasurements;
@@ -10,8 +14,14 @@ const COMPUTE_DURATION: u64 = 100;
 const WRITE_DURATION: u64 = 100;
 const N_READ_ENTRIES: usize = 100;
 const N_WRITE_ENTRIES: usize = 100;
+const N_MODIFICATIONS: usize = 100;
 
 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,
+    });
     measurements.start_measurement(Action::EndToEnd);
     measurements.start_measurement(Action::Read);
     sleep(Duration::from_millis(READ_DURATION)).await;
@@ -54,6 +64,14 @@ fn assert_block_measurement(measurements: &BenchmarkMeasurements, number_of_bloc
         assert_eq!(measurement.n_writes, N_WRITE_ENTRIES);
         assert_eq!(measurement.n_reads, N_READ_ENTRIES);
         assert_eq!(*db_entry_count, N_WRITE_ENTRIES * i);
+        assert_eq!(
+            measurement.modifications_counts,
+            BlockModificationsCounts {
+                storage_tries: N_MODIFICATIONS,
+                contracts_trie: N_MODIFICATIONS,
+                classes_trie: N_MODIFICATIONS
+            }
+        );
     }
 }