starknet_committer_cli: use Box<dyn Storage> for storage init

Author: dorimedini-starkware

crates/starknet_committer_cli/src/commands.rs

@@ -13,13 +13,13 @@ pub type InputImpl = Input<ConfigImpl>;
 /// Runs the committer on n_iterations random generated blocks.
 /// Prints the time measurement to the console and saves statistics to a CSV file in the given
 /// output directory.
-pub async fn run_storage_benchmark<S: Storage>(
+pub async fn run_storage_benchmark<S: Storage + ?Sized>(
     seed: u64,
     n_iterations: usize,
     n_storage_updates_per_iteration: usize,
     output_dir: &str,
     checkpoint_dir: Option<&str>,
-    mut storage: S,
+    storage: &mut S,
     checkpoint_interval: usize,
 ) {
     let mut time_measurement = TimeMeasurement::new(checkpoint_interval);
@@ -45,11 +45,11 @@ pub async fn run_storage_benchmark<S: Storage>(
         };
 
         time_measurement.start_measurement(Action::EndToEnd);
-        let filled_forest = commit_block(input, &mut storage, Some(&mut time_measurement))
+        let filled_forest = commit_block(input, storage, Some(&mut time_measurement))
             .await
             .expect("Failed to commit the given block.");
         time_measurement.start_measurement(Action::Write);
-        let n_new_facts = filled_forest.write_to_storage(&mut storage);
+        let n_new_facts = filled_forest.write_to_storage(storage);
         info!("Written {n_new_facts} new facts to storage");
         time_measurement.stop_measurement(None, Action::Write);
 

crates/starknet_committer_cli/src/main.rs

@@ -7,6 +7,7 @@ use clap::{Args, Parser, Subcommand};
 use starknet_committer_cli::commands::run_storage_benchmark;
 use starknet_patricia_storage::map_storage::{CachedStorage, MapStorage};
 use starknet_patricia_storage::mdbx_storage::MdbxStorage;
+use starknet_patricia_storage::storage_trait::Storage;
 use tracing::info;
 use tracing::level_filters::LevelFilter;
 use tracing_subscriber::reload::Handle;
@@ -99,56 +100,42 @@ pub async fn run_committer_cli(
                 format!("{data_path}/{storage_type:?}/checkpoints/{n_iterations}")
             });
 
-            match storage_type {
-                StorageType::MapStorage => {
-                    let storage = MapStorage::default();
-                    run_storage_benchmark(
-                        seed,
-                        n_iterations,
-                        n_diffs,
-                        &output_dir,
-                        None,
-                        storage,
-                        checkpoint_interval,
-                    )
-                    .await;
-                }
+            let (mut storage, checkpoint_dir): (Box<dyn Storage>, Option<&str>) = match storage_type
+            {
+                StorageType::MapStorage => (Box::new(MapStorage::default()), None),
                 StorageType::Mdbx => {
                     let storage_path = storage_path
                         .unwrap_or_else(|| format!("{data_path}/storage/{storage_type:?}"));
                     fs::create_dir_all(&storage_path).expect("Failed to create storage directory.");
-                    let storage = MdbxStorage::open(Path::new(&storage_path)).unwrap();
-                    run_storage_benchmark(
-                        seed,
-                        n_iterations,
-                        n_diffs,
-                        &output_dir,
+                    (
+                        Box::new(MdbxStorage::open(Path::new(&storage_path)).unwrap()),
                         Some(&checkpoint_dir),
-                        storage,
-                        checkpoint_interval,
                     )
-                    .await;
                 }
                 StorageType::CachedMdbx => {
                     let storage_path = storage_path
                         .unwrap_or_else(|| format!("{data_path}/storage/{storage_type:?}"));
                     fs::create_dir_all(&storage_path).expect("Failed to create storage directory.");
-                    let storage = CachedStorage::new(
-                        MdbxStorage::open(Path::new(&storage_path)).unwrap(),
-                        NonZeroUsize::new(cache_size).unwrap(),
-                    );
-                    run_storage_benchmark(
-                        seed,
-                        n_iterations,
-                        n_diffs,
-                        &output_dir,
+                    (
+                        Box::new(CachedStorage::new(
+                            MdbxStorage::open(Path::new(&storage_path)).unwrap(),
+                            NonZeroUsize::new(cache_size).unwrap(),
+                        )),
                         Some(&checkpoint_dir),
-                        storage,
-                        checkpoint_interval,
                     )
-                    .await;
                 }
-            }
+            };
+
+            run_storage_benchmark(
+                seed,
+                n_iterations,
+                n_diffs,
+                &output_dir,
+                checkpoint_dir,
+                &mut *storage,
+                checkpoint_interval,
+            )
+            .await;
         }
     }
 }