fix coverage (#2448)

.github/workflows/coverage.yml

@@ -15,11 +15,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install Rust
-        run: rustup toolchain install nightly-2024-04-10 --profile minimal --component llvm-tools-preview
+        run: rustup toolchain install nightly-2024-07-01 --profile minimal --component llvm-tools-preview
       - uses: Swatinem/rust-cache@v2
       - uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo +nightly-2024-04-10 llvm-cov --all-features --workspace --doctests --lcov --output-path lcov.info
+        run: cargo +nightly-2024-07-01 llvm-cov --all-features --workspace --doctests --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v3
         continue-on-error: true

columnar/src/column_values/bench.rs

@@ -34,17 +34,21 @@ fn compute_stats(vals: impl Iterator<Item = u64>) -> ColumnStats {
 fn value_iter() -> impl Iterator<Item = u64> {
     0..20_000
 }
+
 fn get_reader_for_bench<Codec: ColumnCodec>(data: &[u64]) -> Codec::ColumnValues {
     let mut bytes = Vec::new();
     let stats = compute_stats(data.iter().cloned());
     let mut codec_serializer = Codec::estimator();
     for val in data {
         codec_serializer.collect(*val);
     }
-    codec_serializer.serialize(&stats, Box::new(data.iter().copied()).as_mut(), &mut bytes);
+    codec_serializer
+        .serialize(&stats, Box::new(data.iter().copied()).as_mut(), &mut bytes)
+        .unwrap();
 
     Codec::load(OwnedBytes::new(bytes)).unwrap()
 }
+
 fn bench_get<Codec: ColumnCodec>(b: &mut Bencher, data: &[u64]) {
     let col = get_reader_for_bench::<Codec>(data);
     b.iter(|| {

common/Cargo.toml

@@ -9,7 +9,6 @@ documentation = "https://docs.rs/tantivy_common/"
 homepage = "https://github.com/quickwit-oss/tantivy"
 repository = "https://github.com/quickwit-oss/tantivy"
 
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
@@ -20,8 +19,7 @@ time = { version = "0.3.10", features = ["serde-well-known"] }
 serde = { version = "1.0.136", features = ["derive"] }
 
 [dev-dependencies]
+binggan = "0.8.1"
 proptest = "1.0.0"
 rand = "0.8.4"
 
-[features]
-unstable = [] # useful for benches.

common/benches/bench.rs

@@ -1,39 +1,64 @@
-#![feature(test)]
-
-extern crate test;
-
-#[cfg(test)]
-mod tests {
-    use rand::seq::IteratorRandom;
-    use rand::thread_rng;
-    use tantivy_common::serialize_vint_u32;
-    use test::Bencher;
-
-    #[bench]
-    fn bench_vint(b: &mut Bencher) {
-        let vals: Vec<u32> = (0..20_000).collect();
-        b.iter(|| {
-            let mut out = 0u64;
-            for val in vals.iter().cloned() {
-                let mut buf = [0u8; 8];
-                serialize_vint_u32(val, &mut buf);
-                out += u64::from(buf[0]);
-            }
-            out
-        });
-    }
-
-    #[bench]
-    fn bench_vint_rand(b: &mut Bencher) {
-        let vals: Vec<u32> = (0..20_000).choose_multiple(&mut thread_rng(), 100_000);
-        b.iter(|| {
-            let mut out = 0u64;
-            for val in vals.iter().cloned() {
-                let mut buf = [0u8; 8];
-                serialize_vint_u32(val, &mut buf);
-                out += u64::from(buf[0]);
-            }
-            out
-        });
-    }
+use binggan::{black_box, BenchRunner};
+use rand::seq::IteratorRandom;
+use rand::thread_rng;
+use tantivy_common::{serialize_vint_u32, BitSet, TinySet};
+
+fn bench_vint() {
+    let mut runner = BenchRunner::new();
+
+    let vals: Vec<u32> = (0..20_000).collect();
+    runner.bench_function("bench_vint", move |_| {
+        let mut out = 0u64;
+        for val in vals.iter().cloned() {
+            let mut buf = [0u8; 8];
+            serialize_vint_u32(val, &mut buf);
+            out += u64::from(buf[0]);
+        }
+        black_box(out);
+    });
+
+    let vals: Vec<u32> = (0..20_000).choose_multiple(&mut thread_rng(), 100_000);
+    runner.bench_function("bench_vint_rand", move |_| {
+        let mut out = 0u64;
+        for val in vals.iter().cloned() {
+            let mut buf = [0u8; 8];
+            serialize_vint_u32(val, &mut buf);
+            out += u64::from(buf[0]);
+        }
+        black_box(out);
+    });
+}
+
+fn bench_bitset() {
+    let mut runner = BenchRunner::new();
+
+    runner.bench_function("bench_tinyset_pop", move |_| {
+        let mut tinyset = TinySet::singleton(black_box(31u32));
+        tinyset.pop_lowest();
+        tinyset.pop_lowest();
+        tinyset.pop_lowest();
+        tinyset.pop_lowest();
+        tinyset.pop_lowest();
+        tinyset.pop_lowest();
+        black_box(tinyset);
+    });
+
+    let tiny_set = TinySet::empty().insert(10u32).insert(14u32).insert(21u32);
+    runner.bench_function("bench_tinyset_sum", move |_| {
+        assert_eq!(black_box(tiny_set).into_iter().sum::<u32>(), 45u32);
+    });
+
+    let v = [10u32, 14u32, 21u32];
+    runner.bench_function("bench_tinyarr_sum", move |_| {
+        black_box(v.iter().cloned().sum::<u32>());
+    });
+
+    runner.bench_function("bench_bitset_initialize", move |_| {
+        black_box(BitSet::with_max_value(1_000_000));
+    });
+}
+
+fn main() {
+    bench_vint();
+    bench_bitset();
 }

common/src/bitset.rs

@@ -696,43 +696,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(all(test, feature = "unstable"))]
-mod bench {
-
-    use test;
-
-    use super::{BitSet, TinySet};
-
-    #[bench]
-    fn bench_tinyset_pop(b: &mut test::Bencher) {
-        b.iter(|| {
-            let mut tinyset = TinySet::singleton(test::black_box(31u32));
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-            tinyset.pop_lowest();
-        });
-    }
-
-    #[bench]
-    fn bench_tinyset_sum(b: &mut test::Bencher) {
-        let tiny_set = TinySet::empty().insert(10u32).insert(14u32).insert(21u32);
-        b.iter(|| {
-            assert_eq!(test::black_box(tiny_set).into_iter().sum::<u32>(), 45u32);
-        });
-    }
-
-    #[bench]
-    fn bench_tinyarr_sum(b: &mut test::Bencher) {
-        let v = [10u32, 14u32, 21u32];
-        b.iter(|| test::black_box(v).iter().cloned().sum::<u32>());
-    }
-
-    #[bench]
-    fn bench_bitset_initialize(b: &mut test::Bencher) {
-        b.iter(|| BitSet::with_max_value(1_000_000));
-    }
-}