Slice blocked BitPacked without decoding

encodings/fastlanes/Cargo.toml

@@ -51,6 +51,10 @@ _test-harness = ["dep:rand"]
 name = "bitpacking_take"
 harness = false
 
+[[bench]]
+name = "bitpack_blocked_decompress"
+harness = false
+
 [[bench]]
 name = "canonicalize_bench"
 harness = false
@@ -69,6 +73,10 @@ harness = false
 name = "bitpack_compare_sweep"
 harness = false
 
+[[bench]]
+name = "bitpack_blocked"
+harness = false
+
 [[bench]]
 name = "cast_bitpacked"
 harness = false

encodings/fastlanes/benches/bitpack_blocked.rs

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Benchmarks `bitpack_encode_blocked`, which packs every 1024-value block at its own bit width.
+
+#![expect(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use divan::counter::ItemsCount;
+use mimalloc::MiMalloc;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_fastlanes::bitpack_compress::bitpack_encode_blocked;
+use vortex_session::VortexSession;
+
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = vortex_array::array_session();
+    vortex_fastlanes::initialize(&session);
+    session
+});
+
+/// 64 blocks of `u32`, 256 KiB in all: shorter iterations are noisy on the walltime legs.
+const NUM_BLOCKS: usize = 64;
+
+#[vortex_bench_support::cpu_features]
+#[divan::bench]
+fn bitpack_blocked_compress(bencher: Bencher) {
+    // Block widths cycle from 1 to 16 bits, so the blocks take different packing kernels.
+    let bit_widths: Vec<u8> = (1..=16).cycle().take(NUM_BLOCKS).collect();
+    let array = PrimitiveArray::from_iter(bit_widths.iter().flat_map(|&bit_width| {
+        (0..1024u32).map(move |i| i.wrapping_mul(7919) & ((1 << bit_width) - 1))
+    }));
+
+    bencher.counter(ItemsCount::new(array.len())).bench(|| {
+        bitpack_encode_blocked(
+            &array,
+            &bit_widths,
+            Some(0),
+            &mut SESSION.create_execution_ctx(),
+        )
+        .unwrap()
+    });
+}

encodings/fastlanes/benches/bitpack_blocked_decompress.rs

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Benchmarks decoding a `BitPacked` array whose 1024-value blocks each have their own bit width.
+
+#![expect(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use divan::counter::ItemsCount;
+use mimalloc::MiMalloc;
+use num_traits::AsPrimitive;
+use vortex_array::VortexSessionExecute;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::dtype::NativePType;
+use vortex_fastlanes::BitPackedArraySlotsExt;
+use vortex_fastlanes::bitpack_compress::bitpack_encode_blocked;
+use vortex_fastlanes::bitpack_decompress::unpack_array_blocked;
+use vortex_session::VortexSession;
+
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+
+fn main() {
+    divan::main();
+}
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = vortex_array::array_session();
+    vortex_fastlanes::initialize(&session);
+    session
+});
+
+/// 64 blocks per array: shorter iterations are noisy on the walltime legs.
+const NUM_BLOCKS: usize = 64;
+
+#[vortex_bench_support::cpu_features]
+#[divan::bench(types = [u32, u64])]
+fn bitpack_blocked_decompress<T>(bencher: Bencher)
+where
+    T: NativePType,
+    u64: AsPrimitive<T>,
+{
+    // Block widths cycle from 1 to 16 bits, so the blocks take different unpacking kernels.
+    let bit_widths: Vec<u8> = (1..=16).cycle().take(NUM_BLOCKS).collect();
+    let values = PrimitiveArray::from_iter(bit_widths.iter().flat_map(|&bit_width| {
+        (0..1024u64).map(move |i| {
+            AsPrimitive::<T>::as_(i.wrapping_mul(7919) & ((1 << bit_width) - 1))
+        })
+    }));
+    let array = bitpack_encode_blocked(
+        &values,
+        &bit_widths,
+        Some(0),
+        &mut SESSION.create_execution_ctx(),
+    )
+    .unwrap();
+    let offsets = array.block_offsets().unwrap().clone();
+
+    bencher.counter(ItemsCount::new(array.len())).bench(|| {
+        unpack_array_blocked(
+            array.as_view(),
+            &offsets,
+            &mut SESSION.create_execution_ctx(),
+        )
+        .unwrap()
+    });
+}

encodings/fastlanes/benches/bitpack_compare.rs

@@ -30,6 +30,7 @@ use vortex_buffer::BufferMut;
 use vortex_fastlanes::BitPacked;
 use vortex_fastlanes::BitPackedArray;
 use vortex_fastlanes::BitPackedData;
+use vortex_fastlanes::BitWidths;
 use vortex_session::VortexSession;
 
 #[global_allocator]
@@ -58,12 +59,15 @@ const BIT_WIDTHS: &[u8] = &[4, 16];
 fn page_aligned(array: BitPackedArray) -> BitPackedArray {
     let ptype = array.dtype().as_ptype();
     let parts = BitPacked::into_parts(array);
+    let BitWidths::Global(bit_width) = parts.bit_widths else {
+        unreachable!("bitpack_encode packs every block at one bit width")
+    };
     BitPacked::try_new(
         parts.packed.ensure_aligned(Alignment::new(4096)).unwrap(),
         ptype,
         parts.validity,
         parts.patches,
-        parts.bit_width,
+        bit_width,
         parts.len,
         parts.offset,
     )

encodings/fastlanes/benches/bitpack_compare_sweep.rs

@@ -34,6 +34,7 @@ use vortex_buffer::BufferMut;
 use vortex_fastlanes::BitPacked;
 use vortex_fastlanes::BitPackedArray;
 use vortex_fastlanes::BitPackedData;
+use vortex_fastlanes::BitWidths;
 use vortex_session::VortexSession;
 
 #[global_allocator]
@@ -84,12 +85,15 @@ impl_bench_int!(u8, u16, u32, u64, i8, i16, i32, i64);
 fn page_aligned(array: BitPackedArray) -> BitPackedArray {
     let ptype = array.dtype().as_ptype();
     let parts = BitPacked::into_parts(array);
+    let BitWidths::Global(bit_width) = parts.bit_widths else {
+        unreachable!("bitpack_encode packs every block at one bit width")
+    };
     BitPacked::try_new(
         parts.packed.ensure_aligned(Alignment::new(4096)).unwrap(),
         ptype,
         parts.validity,
         parts.patches,
-        parts.bit_width,
+        bit_width,
         parts.len,
         parts.offset,
     )