shorten PR

benches/vart_bench.rs

@@ -1,12 +1,12 @@
-use std::str::FromStr;
+use std::collections::BTreeMap;
 use std::time::Instant;
 
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use rand::prelude::SliceRandom;
 use rand::SeedableRng;
 use rand::{rngs::StdRng, Rng};
 
-use vart::art::{QueryType, Tree};
+use vart::art::Tree;
 use vart::{FixedSizeKey, VariableSizeKey};
 
 fn seeded_rng(alter: u64) -> impl Rng {
@@ -40,6 +40,16 @@ pub fn seq_insert_mut(c: &mut Criterion) {
         })
     });
 
+    // Benchmark for BTreeMap
+    group.bench_function("btreemap", |b| {
+        let mut btree = BTreeMap::new();
+        let mut key = 0u64;
+        b.iter(|| {
+            btree.insert(key, key);
+            key += 1;
+        })
+    });
+
     group.finish();
 }
 
@@ -76,6 +86,16 @@ pub fn rand_insert_mut(c: &mut Criterion) {
         })
     });
 
+    // Benchmark for BTreeMap
+    group.bench_function("btreemap", |b| {
+        let mut btree = BTreeMap::new();
+        let mut rng = seeded_rng(0xE080D1A42C207DAF);
+        b.iter(|| {
+            let key = &keys[rng.gen_range(0..keys.len())];
+            btree.insert(key.clone(), key.clone());
+        })
+    });
+
     group.finish();
 }
 
@@ -285,7 +305,7 @@ fn variable_size_bulk_insert_mut(c: &mut Criterion) {
     // Test different combinations of key sizes, value sizes, and number of keys
     let key_sizes = vec![16, 32, 64, 128];
 
-    let num_keys_list = vec![100_000];
+    let num_keys_list = vec![100_000, 500_000, 1_000_000];
 
     for &num_keys in &num_keys_list {
         for &key_size in &key_sizes {
@@ -310,92 +330,6 @@ fn variable_size_bulk_insert_mut(c: &mut Criterion) {
     group.finish();
 }
 
-fn setup_benchmark_tree(num_keys: usize, versions_per_key: usize) -> Tree<VariableSizeKey, i32> {
-    let mut tree = Tree::<VariableSizeKey, i32>::new();
-
-    for key_idx in 0..num_keys {
-        let key = VariableSizeKey::from_str(&format!("key_{}", key_idx)).unwrap();
-        for version in 0..versions_per_key {
-            let value = (key_idx * versions_per_key + version) as i32;
-            let ts = version as u64;
-            tree.insert_unchecked(&key, value, version as u64, ts)
-                .unwrap();
-        }
-    }
-
-    tree
-}
-
-fn bench_query_types(c: &mut Criterion) {
-    let num_keys = 100;
-    let versions_per_key = 10_000;
-    let tree = setup_benchmark_tree(num_keys, versions_per_key);
-    let test_key = VariableSizeKey::from_str("key_50").unwrap();
-    let mid_ts = (versions_per_key / 2) as u64;
-
-    let mut group = c.benchmark_group("tree_queries");
-    group.sample_size(10); // Adjust based on your needs
-    group.measurement_time(std::time::Duration::from_secs(5));
-
-    // Benchmark LatestByVersion
-    group.bench_with_input(
-        BenchmarkId::new("LatestByVersion", mid_ts),
-        &mid_ts,
-        |b, &ts| {
-            b.iter(|| black_box(tree.get_value_by_query(&test_key, QueryType::LatestByVersion(ts))))
-        },
-    );
-
-    // Benchmark LatestByTs
-    group.bench_with_input(BenchmarkId::new("LatestByTs", mid_ts), &mid_ts, |b, &ts| {
-        b.iter(|| black_box(tree.get_value_by_query(&test_key, QueryType::LatestByTs(ts))))
-    });
-
-    // Benchmark LastLessThanTs
-    group.bench_with_input(
-        BenchmarkId::new("LastLessThanTs", mid_ts),
-        &mid_ts,
-        |b, &ts| {
-            b.iter(|| black_box(tree.get_value_by_query(&test_key, QueryType::LastLessThanTs(ts))))
-        },
-    );
-
-    // Benchmark LastLessOrEqualTs
-    group.bench_with_input(
-        BenchmarkId::new("LastLessOrEqualTs", mid_ts),
-        &mid_ts,
-        |b, &ts| {
-            b.iter(|| {
-                black_box(tree.get_value_by_query(&test_key, QueryType::LastLessOrEqualTs(ts)))
-            })
-        },
-    );
-
-    // Benchmark FirstGreaterThanTs
-    group.bench_with_input(
-        BenchmarkId::new("FirstGreaterThanTs", mid_ts),
-        &mid_ts,
-        |b, &ts| {
-            b.iter(|| {
-                black_box(tree.get_value_by_query(&test_key, QueryType::FirstGreaterThanTs(ts)))
-            })
-        },
-    );
-
-    // Benchmark FirstGreaterOrEqualTs
-    group.bench_with_input(
-        BenchmarkId::new("FirstGreaterOrEqualTs", mid_ts),
-        &mid_ts,
-        |b, &ts| {
-            b.iter(|| {
-                black_box(tree.get_value_by_query(&test_key, QueryType::FirstGreaterOrEqualTs(ts)))
-            })
-        },
-    );
-
-    group.finish();
-}
-
 criterion_group!(delete_benches, seq_delete, rand_delete);
 criterion_group!(
     insert_benches,
@@ -408,13 +342,10 @@ criterion_group!(
 criterion_group!(read_benches, seq_get, rand_get, rand_get_str);
 criterion_group!(iter_benches, iter_benchmark);
 criterion_group!(range_benches, range_benchmark);
-criterion_group!(ts_benches, bench_query_types);
-
 criterion_main!(
     insert_benches,
     read_benches,
     delete_benches,
     iter_benches,
-    range_benches,
-    ts_benches
-);
+    range_benches
+);