created benches with criterion and moved one performance test to it

TEST_SUMMARY.md

@@ -80,7 +80,7 @@ I have successfully implemented comprehensive unit tests for several critical da
    - State management and persistence
    - Concurrent operations and thread safety
    - Edge cases and error scenarios
-   - Performance considerations
+   - dash-spc/src considerations
 
 2. **Test Quality**: All tests follow best practices:
    - Clear test names describing what is being tested

dash-spv/Cargo.toml

@@ -59,12 +59,17 @@ hickory-resolver = "0.25"
 log = "0.4"
 
 [dev-dependencies]
+criterion = { version = "0.8.1", features = ["async_tokio"] }
 tempfile = "3.0"
 tokio-test = "0.4"
 env_logger = "0.10"
 hex = "0.4"
 test-case = "3.3"
 
+[[bench]]
+name = "storage"
+harness = false
+
 [[bin]]
 name = "dash-spv"
 path = "src/main.rs"

dash-spv/benches/storage.rs

@@ -0,0 +1,93 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use dash_spv::{
+    storage::{DiskStorageManager, StorageManager},
+    Hash,
+};
+use dashcore::{block::Version, BlockHash, CompactTarget, Header};
+use tempfile::TempDir;
+use tokio::runtime::Builder;
+
+fn create_test_header(height: u32) -> Header {
+    Header {
+        version: Version::from_consensus(1),
+        prev_blockhash: BlockHash::all_zeros(),
+        merkle_root: dashcore_hashes::sha256d::Hash::all_zeros().into(),
+        time: height,
+        bits: CompactTarget::from_consensus(0x207fffff),
+        nonce: height,
+    }
+}
+
+fn bench_disk_storage(c: &mut Criterion) {
+    const CHUNK_SIZE: u32 = 13_000;
+    const NUM_ELEMENTS: u32 = CHUNK_SIZE * 20;
+
+    let rt = Builder::new_multi_thread().worker_threads(4).enable_all().build().unwrap();
+
+    let headers = (0..NUM_ELEMENTS).map(create_test_header).collect::<Vec<Header>>();
+
+    c.bench_function("storage/disk/store", |b| {
+        b.to_async(&rt).iter_batched(
+            || async {
+                DiskStorageManager::new(TempDir::new().unwrap().path().to_path_buf()).await.unwrap()
+            },
+            |a| async {
+                let mut storage = a.await;
+
+                for chunk in headers.chunks(CHUNK_SIZE as usize) {
+                    storage.store_headers(chunk).await.unwrap();
+                }
+            },
+            BatchSize::SmallInput,
+        )
+    });
+
+    let temp_dir = TempDir::new().unwrap();
+
+    let mut storage = rt.block_on(async {
+        let mut storage = DiskStorageManager::new(temp_dir.path().to_path_buf()).await.unwrap();
+
+        for chunk in headers.chunks(CHUNK_SIZE as usize) {
+            storage.store_headers(chunk).await.unwrap();
+        }
+
+        storage
+    });
+
+    c.bench_function("storage/disk/get", |b| {
+        b.to_async(&rt).iter_batched(
+            || rand::random::<u32>() % NUM_ELEMENTS,
+            async |height| {
+                let _ = storage.get_header(height).await.unwrap();
+            },
+            BatchSize::SmallInput,
+        )
+    });
+
+    c.bench_function("storage/disk/reverse_index", |b| {
+        b.to_async(&rt).iter_batched(
+            || {
+                let height = rand::random::<u32>() % NUM_ELEMENTS;
+                headers[height as usize].block_hash()
+            },
+            async |hash| {
+                let _ = storage.get_header_height_by_hash(&hash).await.unwrap();
+            },
+            BatchSize::SmallInput,
+        )
+    });
+
+    rt.block_on(async {
+        storage.shutdown().await;
+    });
+}
+
+criterion_group!(
+    name = disk_storage;
+    config =  Criterion::default()
+        .sample_size(10)
+        .warm_up_time(Duration::from_secs(1));
+    targets = bench_disk_storage);
+criterion_main!(disk_storage);

dash-spv/tests/segmented_storage_test.rs

@@ -7,7 +7,7 @@ use dashcore::pow::CompactTarget;
 use dashcore::BlockHash;
 use dashcore_hashes::Hash;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use tempfile::TempDir;
 use tokio::time::sleep;
 
@@ -383,45 +383,3 @@ async fn test_filter_header_persistence() {
         assert_eq!(loaded[3], create_test_filter_header(50_001));
     }
 }
-
-#[tokio::test]
-async fn test_performance_improvement() {
-    let temp_dir = TempDir::new().unwrap();
-    let mut storage = DiskStorageManager::new(temp_dir.path().to_path_buf()).await.unwrap();
-
-    // Store a large number of headers
-    let headers: Vec<BlockHeader> = (0..200_000).map(create_test_header).collect();
-
-    let start = Instant::now();
-    for chunk in headers.chunks(10_000) {
-        storage.store_headers(chunk).await.unwrap();
-    }
-    let store_time = start.elapsed();
-
-    println!("Stored 200,000 headers in {:?}", store_time);
-
-    // Test random access performance
-    let start = Instant::now();
-    for _ in 0..1000 {
-        let height = rand::random::<u32>() % 200_000;
-        let _ = storage.get_header(height).await.unwrap();
-    }
-    let access_time = start.elapsed();
-
-    println!("1000 random accesses in {:?}", access_time);
-    assert!(access_time < Duration::from_secs(1), "Random access should be fast");
-
-    // Test reverse index performance
-    let start = Instant::now();
-    for _ in 0..1000 {
-        let height = rand::random::<u32>() % 200_000;
-        let hash = headers[height as usize].block_hash();
-        let _ = storage.get_header_height_by_hash(&hash).await.unwrap();
-    }
-    let lookup_time = start.elapsed();
-
-    println!("1000 hash lookups in {:?}", lookup_time);
-    assert!(lookup_time < Duration::from_secs(1), "Hash lookups should be fast");
-
-    storage.shutdown().await;
-}