Merge branch 'develop' into adamg/minimize-benchmarks

Author: AdamGS

.github/workflows/run-fuzzer.yml

@@ -116,6 +116,7 @@ jobs:
       - name: Run fuzzing target
         id: fuzz
         run: |
+          CORPUS_DIR="fuzz/corpus/${FUZZ_NAME}"
           FEATURES_FLAG=""
           if [ -n "${{ inputs.extra_features }}" ]; then
             FEATURES_FLAG="--features ${{ inputs.extra_features }}"
@@ -127,7 +128,7 @@ jobs:
           ${{ inputs.extra_env }} RUST_BACKTRACE=1 \
             cargo +$NIGHTLY_TOOLCHAIN fuzz run --release --debug-assertions \
             $FEATURES_FLAG \
-            ${{ inputs.fuzz_target }} -- \
+            ${{ inputs.fuzz_target }} "$CORPUS_DIR" -- \
             $FORK_FLAG -max_total_time=${{ inputs.max_time }} -rss_limit_mb=0 \
             2>&1 | tee fuzz_output.log
         continue-on-error: true

Cargo.lock

@@ -4,20 +4,21 @@
 #![no_main]
 #![expect(clippy::unwrap_used)]
 
+use std::sync::LazyLock;
+
 use libfuzzer_sys::Corpus;
 use libfuzzer_sys::fuzz_target;
+use tokio::runtime::Builder;
+use tokio::runtime::Runtime;
 use vortex_error::vortex_panic;
 use vortex_fuzz::FuzzCompressGpu;
 use vortex_fuzz::run_compress_gpu;
 
-fuzz_target!(|fuzz: FuzzCompressGpu| -> Corpus {
-    // Use tokio runtime to run async GPU fuzzer
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap();
+static RUNTIME: LazyLock<Runtime> =
+    LazyLock::new(|| Builder::new_current_thread().enable_all().build().unwrap());
 
-    match rt.block_on(run_compress_gpu(fuzz)) {
+fuzz_target!(|fuzz: FuzzCompressGpu| -> Corpus {
+    match RUNTIME.block_on(run_compress_gpu(fuzz)) {
         Ok(true) => Corpus::Keep,
         Ok(false) => Corpus::Reject,
         Err(e) => {

fuzz/fuzz_targets/compress_gpu.rs

@@ -130,6 +130,10 @@ harness = false
 name = "binary_ops"
 harness = false
 
+[[bench]]
+name = "kleene_bool"
+harness = false
+
 [[bench]]
 name = "interleave"
 harness = false

vortex-array/Cargo.toml

@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use divan::counter::ItemsCount;
+use vortex_array::ArrayRef;
+use vortex_array::Columnar;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::BoolArray;
+use vortex_array::arrays::ConstantArray;
+use vortex_array::arrow::ArrowSession;
+use vortex_array::builtins::ArrayBuiltins;
+use vortex_array::dtype::DType;
+use vortex_array::dtype::Nullability;
+use vortex_array::scalar::Scalar;
+use vortex_array::scalar_fn::fns::operators::Operator;
+use vortex_array::session::ArraySession;
+use vortex_session::VortexSession;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    VortexSession::empty()
+        .with::<ArraySession>()
+        .with::<ArrowSession>()
+});
+
+const LEN: usize = 65_536;
+const SHIFTED_OFFSET: usize = 1;
+
+#[divan::bench]
+fn and_bool_nonnull_arrays(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nonnull(2).into_array(),
+        bool_nonnull(3).into_array(),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_bool_nonnull_arrays(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nonnull(2).into_array(),
+        bool_nonnull(3).into_array(),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_bool_nullable_arrays(bencher: Bencher) {
+    and_bool_nullable_arrays_aligned(bencher);
+}
+
+#[divan::bench]
+fn and_bool_nullable_arrays_aligned(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        bool_nullable(3, 5, 0),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_bool_nullable_arrays(bencher: Bencher) {
+    or_bool_nullable_arrays_aligned(bencher);
+}
+
+#[divan::bench]
+fn or_bool_nullable_arrays_aligned(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        bool_nullable(3, 5, 0),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_bool_nullable_arrays_shifted(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, SHIFTED_OFFSET),
+        bool_nullable(3, 5, SHIFTED_OFFSET),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_bool_nullable_arrays_shifted(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, SHIFTED_OFFSET),
+        bool_nullable(3, 5, SHIFTED_OFFSET),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_true_constant(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        ConstantArray::new(true, LEN).into_array(),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_false_constant(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        ConstantArray::new(false, LEN).into_array(),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_false_constant(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        ConstantArray::new(false, LEN).into_array(),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_true_constant(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        ConstantArray::new(true, LEN).into_array(),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_null_constant(bencher: Bencher) {
+    and_null_constant_aligned(bencher);
+}
+
+#[divan::bench]
+fn and_null_constant_aligned(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        null_bool_constant(),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_null_constant(bencher: Bencher) {
+    or_null_constant_aligned(bencher);
+}
+
+#[divan::bench]
+fn or_null_constant_aligned(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, 0),
+        null_bool_constant(),
+        Operator::Or,
+    );
+}
+
+#[divan::bench]
+fn and_null_constant_shifted(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, SHIFTED_OFFSET),
+        null_bool_constant(),
+        Operator::And,
+    );
+}
+
+#[divan::bench]
+fn or_null_constant_shifted(bencher: Bencher) {
+    bench_kleene(
+        bencher,
+        bool_nullable(2, 7, SHIFTED_OFFSET),
+        null_bool_constant(),
+        Operator::Or,
+    );
+}
+
+fn bench_kleene(bencher: Bencher, lhs: ArrayRef, rhs: ArrayRef, operator: Operator) {
+    let mut ctx = SESSION.create_execution_ctx();
+
+    bencher.counter(ItemsCount::new(LEN)).bench_local(|| {
+        lhs.clone()
+            .binary(rhs.clone(), operator)
+            .unwrap()
+            .execute::<Columnar>(&mut ctx)
+            .unwrap()
+    });
+}
+
+fn bool_nonnull(true_every: usize) -> BoolArray {
+    BoolArray::from_iter((0..LEN).map(|i| i.is_multiple_of(true_every)))
+}
+
+fn bool_nullable(true_every: usize, null_every: usize, offset: usize) -> ArrayRef {
+    let len = LEN + offset;
+    let array = BoolArray::from_iter(
+        (0..len).map(|i| (!i.is_multiple_of(null_every)).then_some(i.is_multiple_of(true_every))),
+    )
+    .into_array();
+
+    if offset == 0 {
+        array
+    } else {
+        array.slice(offset..offset + LEN).unwrap()
+    }
+}
+
+fn null_bool_constant() -> ArrayRef {
+    ConstantArray::new(Scalar::null(DType::Bool(Nullability::Nullable)), LEN).into_array()
+}

vortex-array/benches/kleene_bool.rs

@@ -43,7 +43,7 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
     &integer::IntRLEScheme,
     // Prefer all other schemes above delta, for now (since its slower to decompress).
     #[cfg(feature = "unstable_encodings")]
-    &integer::DeltaScheme,
+    &integer::DeltaScheme::new(1.25),
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Float schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -186,7 +186,7 @@ impl BtrBlocksCompressorBuilder {
         // Delta has no GPU decode kernel and its prefix-sum decode is inherently sequential, so it
         // is incompatible with pure-GPU decompression paths.
         #[cfg(feature = "unstable_encodings")]
-        excluded.push(integer::DeltaScheme.id());
+        excluded.push(integer::DeltaScheme::default().id());
         let builder = self.exclude_schemes(excluded);
 
         #[cfg(all(feature = "zstd", feature = "unstable_encodings"))]

vortex-btrblocks/src/builder.rs

@@ -34,8 +34,29 @@ use crate::SchemeExt;
 /// Delta replaces each value with its difference from an earlier value (at the FastLanes lane
 /// stride), so a later cascade layer (FoR / BitPacking) packs the smaller residuals. It only
 /// pays off when those residuals span meaningfully fewer bits than the values themselves.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct DeltaScheme;
+///
+/// The minimum penalized compression ratio required for Delta to be selected is configurable via
+/// [`DeltaScheme::new`]; [`DeltaScheme::default`] uses a ratio of `1.25`.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct DeltaScheme {
+    min_ratio: f64,
+}
+
+impl DeltaScheme {
+    /// Creates a Delta scheme requiring `min_ratio` (after the [`DELTA_PENALTY`]) before it wins.
+    ///
+    /// Pass a higher ratio to make Delta more conservative, or a lower one to select it more
+    /// eagerly. [`DeltaScheme::default`] uses a ratio of `1.25`.
+    pub const fn new(min_ratio: f64) -> Self {
+        Self { min_ratio }
+    }
+}
+
+impl Default for DeltaScheme {
+    fn default() -> Self {
+        Self::new(1.25)
+    }
+}
 
 /// Multiplicative penalty applied to Delta's estimated compression ratio.
 ///
@@ -65,7 +86,7 @@ impl Scheme for DeltaScheme {
     /// bases and the deltas children so we never delta-encode data that was already delta-encoded.
     fn descendant_exclusions(&self) -> Vec<DescendantExclusion> {
         vec![DescendantExclusion {
-            excluded: DeltaScheme.id(),
+            excluded: self.id(),
             children: ChildSelection::All,
         }]
     }
@@ -110,8 +131,9 @@ impl Scheme for DeltaScheme {
 
         // Estimating Delta needs the real transposed-delta span, so defer to a callback that
         // delta-encodes the array and measures the residual range.
+        let min_ratio = self.min_ratio;
         CompressionEstimate::Deferred(DeferredEstimate::Callback(Box::new(
-            |_compressor, data, best_so_far, _ctx, exec_ctx| {
+            move |_compressor, data, best_so_far, _ctx, exec_ctx| {
                 let primitive = data.array().clone().execute::<PrimitiveArray>(exec_ctx)?;
                 let full_width = primitive.ptype().bit_width() as f64;
 
@@ -138,7 +160,7 @@ impl Scheme for DeltaScheme {
                 };
 
                 let ratio = full_width / delta_bits * DELTA_PENALTY;
-                if ratio <= 1.0 {
+                if ratio <= min_ratio {
                     return Ok(EstimateVerdict::Skip);
                 }
                 Ok(EstimateVerdict::Ratio(ratio))