starknet_committer: add number of empty leaves to TimeMeasurementTrait

crates/starknet_committer/src/block_committer/commit.rs

@@ -3,10 +3,16 @@ use std::collections::HashMap;
 use async_trait::async_trait;
 use starknet_api::core::{ClassHash, ContractAddress, Nonce};
 use starknet_patricia::patricia_merkle_tree::types::{NodeIndex, SortedLeafIndices};
+use starknet_types_core::felt::Felt;
 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::input::{
+    contract_address_into_node_index,
+    Input,
+    StarknetStorageValue,
+    StateDiff,
+};
 use crate::block_committer::measurements_util::{
     Action,
     BlockModificationsCounts,
@@ -45,15 +51,13 @@ 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(),
-        });
+        measure_number_of_modifications(
+            measurements,
+            &actual_storage_updates,
+            n_contracts_trie_modifications,
+            actual_classes_updates.len(),
+        );
         // Reads - fetch_nodes.
-
         measurements.start_measurement(Action::Read);
         let roots =
             trie_reader.read_roots(input.initial_read_context).await.map_err(ForestError::from)?;
@@ -170,3 +174,22 @@ pub(crate) fn get_all_modified_indices(
         .collect();
     (storage_tries_indices, contracts_trie_indices, classes_trie_indices)
 }
+
+fn measure_number_of_modifications(
+    measurements: &mut impl MeasurementsTrait,
+    storage_modifications: &HashMap<ContractAddress, HashMap<NodeIndex, StarknetStorageValue>>,
+    n_contracts_trie_modifications: usize,
+    n_classes_trie_modifications: usize,
+) {
+    let storage_tries = storage_modifications.values().map(|value| value.len()).sum();
+    let emptied_storage_leaves = storage_modifications
+        .values()
+        .map(|storage_entry| storage_entry.values().filter(|value| value.0 == Felt::ZERO).count())
+        .sum::<usize>();
+    measurements.set_number_of_modifications(BlockModificationsCounts {
+        storage_tries,
+        contracts_trie: n_contracts_trie_modifications,
+        classes_trie: n_classes_trie_modifications,
+        emptied_storage_leaves,
+    });
+}

crates/starknet_committer/src/block_committer/measurements_util.rs

@@ -98,6 +98,7 @@ pub struct BlockModificationsCounts {
     pub storage_tries: usize,
     pub contracts_trie: usize,
     pub classes_trie: usize,
+    pub emptied_storage_leaves: usize,
 }
 
 #[derive(Default, Clone)]

crates/starknet_committer_cli/src/utils.rs

@@ -196,6 +196,7 @@ impl BenchmarkMeasurements {
                     "n_storage_tries_modifications",
                     "n_contracts_trie_modifications",
                     "n_classes_trie_modifications",
+                    "n_emptied_storage_leaves",
                 ],
                 self.storage_stat_columns.clone(),
             ]
@@ -220,6 +221,7 @@ impl BenchmarkMeasurements {
                 measurement.modifications_counts.storage_tries.to_string(),
                 measurement.modifications_counts.contracts_trie.to_string(),
                 measurement.modifications_counts.classes_trie.to_string(),
+                measurement.modifications_counts.emptied_storage_leaves.to_string(),
             ];
             if i == n_results - 1 {
                 record

crates/starknet_committer_cli/src/utils_test.rs

@@ -15,12 +15,14 @@ const WRITE_DURATION: u64 = 100;
 const N_READ_ENTRIES: usize = 100;
 const N_WRITE_ENTRIES: usize = 100;
 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.start_measurement(Action::EndToEnd);
     measurements.start_measurement(Action::Read);
@@ -69,7 +71,8 @@ fn assert_block_measurement(measurements: &BenchmarkMeasurements, number_of_bloc
             BlockModificationsCounts {
                 storage_tries: N_MODIFICATIONS,
                 contracts_trie: N_MODIFICATIONS,
-                classes_trie: N_MODIFICATIONS
+                classes_trie: N_MODIFICATIONS,
+                emptied_storage_leaves: N_EMPTY_LEAVES,
             }
         );
     }

scripts/committer/committer_benchmark_plotting.py

@@ -110,6 +110,7 @@ def __init__(self, csv_file: str, storage_stats_type: StorageStats):
                 "n_storage_tries_modifications",
                 "n_contracts_trie_modifications",
                 "n_classes_trie_modifications",
+                "n_emptied_storage_leaves",
             ]
             for col in modifications_columns:
                 if col in data[0]: