merge op_bench and bitop_bench

Author: carlsverre

Cargo.toml

@@ -57,7 +57,3 @@ harness = false
 [[bench]]
 name = "count_bench"
 harness = false
-
-[[bench]]
-name = "bitop_bench"
-harness = false

benches/bitop_bench.rs

@@ -2,12 +2,17 @@ use bytes::Bytes;
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use rand::seq::index::{self, IndexVec};
 use roaring::RoaringBitmap;
-use std::hint::black_box;
+use std::{
+    hint::black_box,
+    ops::{BitAnd, BitOr, BitXor, Sub},
+};
 
 use splinter_rs::{
-    Optimizable, PartitionRead, PartitionWrite, Splinter, SplinterRef, testutil::SetGen,
+    Cut, Optimizable, PartitionRead, PartitionWrite, Splinter, SplinterRef, testutil::SetGen,
 };
 
+const SEED: u64 = 0xDEAD_BEEF;
+
 fn mksplinter(values: impl IntoIterator<Item = u32>) -> Splinter {
     Splinter::from_iter(values)
 }
@@ -16,6 +21,10 @@ fn mksplinter_ref(values: impl IntoIterator<Item = u32>) -> SplinterRef<Bytes> {
     mksplinter(values).encode_to_splinter_ref()
 }
 
+fn mkroaring(values: impl IntoIterator<Item = u32>) -> RoaringBitmap {
+    values.into_iter().collect()
+}
+
 fn benchmark_contains(c: &mut Criterion) {
     let cardinalities = [4u32, 16, 64, 256, 1024, 4096, 16384];
 
@@ -462,6 +471,145 @@ fn benchmark_select(c: &mut Criterion) {
     group.finish();
 }
 
+macro_rules! bench_bitop {
+    ($name:ident, $group:literal, $op:path) => {
+        fn $name(c: &mut Criterion) {
+            let cardinalities_left = [64, 4096, 16384];
+            let cardinalities_right = [64, 4096, 16384];
+
+            let mut group = c.benchmark_group($group);
+            let mut set_gen = SetGen::new(SEED);
+
+            for &cardinality_left in &cardinalities_left {
+                for &cardinality_right in &cardinalities_right {
+                    let set_a = set_gen.random(cardinality_left as usize);
+                    let set_b = set_gen.random(cardinality_right as usize);
+
+                    group.bench_function(
+                        BenchmarkId::new(
+                            "splinter",
+                            format!("{cardinality_left}/{cardinality_right}"),
+                        ),
+                        |b| {
+                            b.iter_batched(
+                                || (mksplinter(set_a.clone()), mksplinter(set_b.clone())),
+                                |(a, b)| black_box($op(a, b)),
+                                criterion::BatchSize::SmallInput,
+                            );
+                        },
+                    );
+
+                    group.bench_function(
+                        BenchmarkId::new(
+                            "splinter_ref",
+                            format!("{cardinality_left}/{cardinality_right}"),
+                        ),
+                        |b| {
+                            let b_ref = mksplinter_ref(set_b.clone());
+                            b.iter_batched(
+                                || mksplinter(set_a.clone()),
+                                |a| black_box($op(a, &b_ref)),
+                                criterion::BatchSize::SmallInput,
+                            );
+                        },
+                    );
+
+                    group.bench_function(
+                        BenchmarkId::new(
+                            "roaring",
+                            format!("{cardinality_left}/{cardinality_right}"),
+                        ),
+                        |b| {
+                            b.iter_batched(
+                                || (mkroaring(set_a.clone()), mkroaring(set_b.clone())),
+                                |(a, b)| black_box($op(a, b)),
+                                criterion::BatchSize::SmallInput,
+                            );
+                        },
+                    );
+                }
+            }
+
+            group.finish();
+        }
+    };
+}
+
+bench_bitop!(benchmark_bitor, "bitor", BitOr::bitor);
+bench_bitop!(benchmark_bitand, "bitand", BitAnd::bitand);
+bench_bitop!(benchmark_bitxor, "bitxor", BitXor::bitxor);
+bench_bitop!(benchmark_sub, "sub", Sub::sub);
+
+fn benchmark_cut(c: &mut Criterion) {
+    let cardinalities_left = [64, 4096, 16384];
+    let cardinalities_right = [64, 4096, 16384];
+
+    let mut group = c.benchmark_group("cut");
+    let mut set_gen = SetGen::new(SEED);
+
+    for &cardinality_left in &cardinalities_left {
+        for &cardinality_right in &cardinalities_right {
+            let set_a = set_gen.random(cardinality_left as usize);
+            let set_b = set_gen.random(cardinality_right as usize);
+
+            group.bench_function(
+                BenchmarkId::new(
+                    "splinter",
+                    format!("{cardinality_left}/{cardinality_right}"),
+                ),
+                |b| {
+                    let other = mksplinter(set_b.clone());
+                    b.iter_batched(
+                        || mksplinter(set_a.clone()),
+                        |mut a| {
+                            let intersection = a.cut(&other);
+                            black_box((a, intersection))
+                        },
+                        criterion::BatchSize::SmallInput,
+                    );
+                },
+            );
+
+            group.bench_function(
+                BenchmarkId::new(
+                    "splinter_ref",
+                    format!("{cardinality_left}/{cardinality_right}"),
+                ),
+                |b| {
+                    let other_ref = mksplinter_ref(set_b.clone());
+                    b.iter_batched(
+                        || mksplinter(set_a.clone()),
+                        |mut a| {
+                            let intersection = a.cut(&other_ref);
+                            black_box((a, intersection))
+                        },
+                        criterion::BatchSize::SmallInput,
+                    );
+                },
+            );
+
+            // Equivalent roaring operation: intersection + difference
+            group.bench_function(
+                BenchmarkId::new("roaring", format!("{cardinality_left}/{cardinality_right}")),
+                |b| {
+                    let other = mkroaring(set_b.clone());
+                    b.iter_batched(
+                        || mkroaring(set_a.clone()),
+                        |mut a| {
+                            let intersection = &a & &other;
+                            a -= &other;
+                            black_box((a, intersection))
+                        },
+                        criterion::BatchSize::SmallInput,
+                    );
+                },
+            );
+        }
+    }
+
+    group.finish();
+}
+
 criterion_group!(
     benches,
     benchmark_contains,
@@ -470,6 +618,11 @@ criterion_group!(
     benchmark_contains_vs_position,
     benchmark_cardinality,
     benchmark_rank,
-    benchmark_select
+    benchmark_select,
+    benchmark_bitor,
+    benchmark_bitand,
+    benchmark_bitxor,
+    benchmark_sub,
+    benchmark_cut
 );
 criterion_main!(benches);