Remove/update benchmarks

Cargo.toml

@@ -55,12 +55,6 @@ unexpected_cfgs = { level = "warn", check-cfg = [
 [package.metadata.cargo-all-features]
 denylist = []
 
-[[bench]]
-name = "tli"
-harness = false
-path = "benches/tli.rs"
-required-features = []
-
 [[bench]]
 name = "merge"
 harness = false
@@ -79,32 +73,15 @@ harness = false
 path = "benches/bloom.rs"
 required-features = []
 
-[[bench]]
-name = "block"
-harness = false
-path = "benches/block.rs"
-required-features = ["lz4"]
-
 [[bench]]
 name = "tree"
 harness = false
 path = "benches/tree.rs"
 required-features = ["lz4"]
 
-[[bench]]
-name = "level_manifest"
-harness = false
-path = "benches/level_manifest.rs"
-required-features = []
-
 [[bench]]
 name = "fd_table"
 harness = false
 path = "benches/fd_table.rs"
 required-features = []
 
-[[bench]]
-name = "partition_point"
-harness = false
-path = "benches/partition_point.rs"
-required-features = []

benches/bloom.rs

@@ -54,34 +54,6 @@ fn standard_filter_construction(c: &mut Criterion) {
     });
 }
 
-fn blocked_filter_construction(c: &mut Criterion) {
-    use lsm_tree::table::filter::blocked_bloom::Builder;
-
-    let mut rng = rand::rng();
-
-    c.bench_function("blocked bloom filter add key, 1M", |b| {
-        let mut filter = Builder::with_fp_rate(1_000_000, 0.01);
-
-        b.iter(|| {
-            let mut key = [0; 16];
-            rng.fill_bytes(&mut key);
-
-            filter.set_with_hash(Builder::get_hash(&key));
-        });
-    });
-
-    c.bench_function("blocked bloom filter add key, 10M", |b| {
-        let mut filter = Builder::with_fp_rate(10_000_000, 0.01);
-
-        b.iter(|| {
-            let mut key = [0; 16];
-            rng.fill_bytes(&mut key);
-
-            filter.set_with_hash(Builder::get_hash(&key));
-        });
-    });
-}
-
 fn standard_filter_contains(c: &mut Criterion) {
     use lsm_tree::table::filter::standard_bloom::Builder;
 
@@ -126,56 +98,10 @@ fn standard_filter_contains(c: &mut Criterion) {
     }
 }
 
-fn blocked_filter_contains(c: &mut Criterion) {
-    use lsm_tree::table::filter::blocked_bloom::Builder;
-
-    let keys = (0..100_000u128)
-        .map(|x| x.to_be_bytes().to_vec())
-        .collect::<Vec<_>>();
-
-    for fpr in [0.1, 0.01, 0.001, 0.0001, 0.00001] {
-        // NOTE: Purposefully bloat bloom filter size to run into more CPU cache misses
-        let n = 100_000_000;
-
-        let mut filter = Builder::with_fp_rate(n, fpr);
-
-        for key in &keys {
-            filter.set_with_hash(Builder::get_hash(key));
-        }
-
-        let mut rng = rand::rng();
-
-        let filter_bytes = filter.build();
-
-        c.bench_function(
-            &format!(
-                "blocked bloom filter contains key, true positive ({}%)",
-                fpr * 100.0,
-            ),
-            |b| {
-                b.iter(|| {
-                    use lsm_tree::table::filter::blocked_bloom::BlockedBloomFilterReader as Reader;
-                    use rand::seq::IndexedRandom;
-
-                    // NOTE: To make the costs more realistic, we
-                    // pretend we are reading the filter straight from the block
-                    let filter = Reader::new(&filter_bytes).unwrap();
-
-                    let sample = keys.choose(&mut rng).unwrap();
-                    let hash = Builder::get_hash(sample);
-                    assert!(filter.contains_hash(hash));
-                });
-            },
-        );
-    }
-}
-
 criterion_group!(
     benches,
     fast_block_index,
     standard_filter_construction,
-    blocked_filter_construction,
     standard_filter_contains,
-    blocked_filter_contains,
 );
 criterion_main!(benches);