Add BitBuffer to vortex-buffer

vortex-buffer/Cargo.toml

@@ -25,6 +25,7 @@ warn-copy = ["dep:log"]
 
 [dependencies]
 arrow-buffer = { workspace = true, optional = true }
+bitvec = { workspace = true }
 bytes = { workspace = true }
 cudarc = { workspace = true, optional = true }
 itertools = { workspace = true }
@@ -45,3 +46,7 @@ divan = { workspace = true }
 [[bench]]
 name = "vortex_buffer"
 harness = false
+
+[[bench]]
+name = "vortex_bitbuffer"
+harness = false

vortex-buffer/benches/vortex_bitbuffer.rs

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::unwrap_used)]
+
+use std::iter::Iterator;
+
+use arrow_buffer::{BooleanBuffer, BooleanBufferBuilder};
+use divan::Bencher;
+use vortex_buffer::{BitBuffer, BitBufferMut};
+
+fn main() {
+    divan::main();
+}
+
+/// Wraps an arrow buffer so Divan can provide a nice name
+pub struct Arrow<T>(T);
+
+impl FromIterator<bool> for Arrow<BooleanBuffer> {
+    fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self {
+        Self(BooleanBuffer::from_iter(iter))
+    }
+}
+
+const INPUT_SIZE: &[usize] = &[128, 1024, 2048, 16_384, 65_536];
+
+#[divan::bench(
+    types = [Arrow<BooleanBuffer>, BitBuffer],
+    args = INPUT_SIZE,
+)]
+fn from_iter<B: FromIterator<bool>>(n: usize) {
+    B::from_iter((0..n).map(|i| i % 2 == 0));
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn append_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBufferMut::with_capacity(length))
+        .bench_refs(|buffer| {
+            for idx in 0..length {
+                buffer.append(divan::black_box(idx % 2 == 0));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn append_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBufferBuilder::new(length)))
+        .bench_refs(|buffer| {
+            for idx in 0..length {
+                buffer.0.append(divan::black_box(idx % 2 == 0));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn append_n_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBufferMut::with_capacity(length))
+        .bench_refs(|buffer| {
+            for _ in 0..100 {
+                buffer.append_n(divan::black_box(true), divan::black_box(length / 100));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn append_n_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBufferBuilder::new(length)))
+        .bench_refs(|buffer| {
+            for _ in 0..100 {
+                buffer
+                    .0
+                    .append_n(divan::black_box(length / 100), divan::black_box(true));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn value_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_refs(|buffer| {
+            for idx in 0..length {
+                divan::black_box(buffer.value(idx));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn value_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_refs(|buffer| {
+            for idx in 0..length {
+                divan::black_box(buffer.0.value(idx));
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn slice_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_values(|buffer| {
+            let mid = length / 2;
+            divan::black_box(buffer.slice(mid / 2..mid + mid / 2));
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn slice_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_values(|buffer| {
+            let mid = length / 2;
+            divan::black_box(buffer.0.slice(mid / 2, mid / 2));
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn true_count_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_refs(|buffer| {
+            divan::black_box(buffer.true_count());
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn true_count_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_refs(|buffer| {
+            divan::black_box(buffer.0.count_set_bits());
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_and_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| {
+            let a = BitBuffer::from_iter((0..length).map(|i| i % 2 == 0));
+            let b = BitBuffer::from_iter((0..length).map(|i| i % 3 == 0));
+            (a, b)
+        })
+        .bench_values(|(a, b)| {
+            divan::black_box(&a & &b);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_and_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| {
+            let a = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
+            let b = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 3 == 0)));
+            (a, b)
+        })
+        .bench_values(|(a, b)| {
+            divan::black_box(&a.0 & &b.0);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_or_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| {
+            let a = BitBuffer::from_iter((0..length).map(|i| i % 2 == 0));
+            let b = BitBuffer::from_iter((0..length).map(|i| i % 3 == 0));
+            (a, b)
+        })
+        .bench_values(|(a, b)| {
+            divan::black_box(&a | &b);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_or_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| {
+            let a = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0)));
+            let b = Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 3 == 0)));
+            (a, b)
+        })
+        .bench_values(|(a, b)| {
+            divan::black_box(&a.0 | &b.0);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_not_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_values(|buffer| {
+            divan::black_box(!&buffer);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn bitwise_not_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_values(|buffer| {
+            divan::black_box(!&buffer.0);
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn iter_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_refs(|buffer| {
+            for value in buffer.iter() {
+                divan::black_box(value);
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn iter_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_refs(|buffer| {
+            for value in buffer.0.iter() {
+                divan::black_box(value);
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn set_indices_vortex_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| BitBuffer::from_iter((0..length).map(|i| i % 2 == 0)))
+        .bench_refs(|buffer| {
+            for idx in buffer.set_indices() {
+                divan::black_box(idx);
+            }
+        });
+}
+
+#[divan::bench(args = INPUT_SIZE)]
+fn set_indices_arrow_buffer(bencher: Bencher, length: usize) {
+    bencher
+        .with_inputs(|| Arrow(BooleanBuffer::from_iter((0..length).map(|i| i % 2 == 0))))
+        .bench_refs(|buffer| {
+            for idx in buffer.0.set_indices() {
+                divan::black_box(idx);
+            }
+        });
+}