Add scalar function performance baselines

Adds stable CodSpeed benchmark names for `byte_length`, tensor scalar functions, and the geo binary predicates. The benchmarks use public construction and execution APIs, which lets later implementation changes compare directly against this baseline.

CodSpeed runs tensor and geo in a dedicated shard. Each benchmark binary uses vendored `mimalloc` because scalar function execution allocates its output inside the timed trace.

`Normalized` keeps its checked inherent constructor because `ScalarFnFactoryExt` cannot represent its normalized-row invariant.

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

.github/workflows/codspeed.yml

@@ -57,6 +57,7 @@ jobs:
           - { shard: 6, name: "Encodings 3", packages: "vortex-pco vortex-runend vortex-sequence" }
           - { shard: 7, name: "Encodings 4", packages: "vortex-sparse vortex-zigzag vortex-zstd" }
           - { shard: 8, name: "Storage formats & row encoding", packages: "vortex-flatbuffers vortex-proto vortex-btrblocks vortex-row" }
+          - { shard: 9, name: "Tensor & geo", packages: "vortex-tensor vortex-geo" }
     name: "Benchmark with Codspeed (Shard #${{ matrix.shard }})"
     timeout-minutes: 30
     runs-on: >-

Cargo.lock

@@ -137,6 +137,10 @@ harness = false
 name = "like"
 harness = false
 
+[[bench]]
+name = "byte_length"
+harness = false
+
 [[bench]]
 name = "interleave"
 harness = false

vortex-array/Cargo.toml

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Baseline throughput for `byte_length` over UTF-8 view arrays.
+//!
+//! The arms cover inline and out-of-line views, plus nullable out-of-line views. Their names are
+//! intended to remain stable across scalar-function implementation changes so CodSpeed can compare
+//! them against `develop`.
+
+#![expect(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use divan::counter::ItemsCount;
+use mimalloc::MiMalloc;
+use vortex_array::ArrayRef;
+use vortex_array::Canonical;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::array_session;
+use vortex_array::arrays::MaskedArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::scalar_fn::EmptyOptions;
+use vortex_array::scalar_fn::fns::byte_length::ByteLength;
+use vortex_array::validity::Validity;
+use vortex_session::VortexSession;
+
+// Scalar function execution allocates its output inside the timed region, so use the vendored
+// allocator instead of measuring glibc differences between CodSpeed runner images.
+#[global_allocator]
+static GLOBAL: MiMalloc = MiMalloc;
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(array_session);
+
+fn main() {
+    LazyLock::force(&SESSION);
+    divan::main();
+}
+
+const SIZES: &[usize] = &[4_096, 65_536];
+
+fn long_strings(len: usize) -> ArrayRef {
+    VarBinViewArray::from_iter_str((0..len).map(|i| format!("a string well past inline: {i}")))
+        .into_array()
+}
+
+fn short_strings(len: usize) -> ArrayRef {
+    VarBinViewArray::from_iter_str((0..len).map(|i| format!("{}", i % 1_000))).into_array()
+}
+
+fn bench_byte_length(bencher: Bencher, input: ArrayRef) {
+    let len = input.len();
+    bencher
+        .counter(ItemsCount::new(len))
+        .with_inputs(|| {
+            (
+                ByteLength
+                    .try_new_array(len, EmptyOptions, [input.clone()])
+                    .unwrap(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_values(|(array, mut ctx)| array.execute::<Canonical>(&mut ctx).unwrap());
+}
+
+#[divan::bench(args = SIZES)]
+fn inline(bencher: Bencher, len: usize) {
+    bench_byte_length(bencher, short_strings(len));
+}
+
+#[divan::bench(args = SIZES)]
+fn out_of_line(bencher: Bencher, len: usize) {
+    bench_byte_length(bencher, long_strings(len));
+}
+
+#[divan::bench(args = SIZES)]
+fn nullable_out_of_line(bencher: Bencher, len: usize) {
+    let validity = Validity::from_iter((0..len).map(|i| i % 8 != 0));
+    let input = MaskedArray::try_new(long_strings(len), validity)
+        .unwrap()
+        .into_array();
+    bench_byte_length(bencher, input);
+}

vortex-array/benches/byte_length.rs

@@ -36,6 +36,7 @@ _test-harness = []
 
 [dev-dependencies]
 divan = { workspace = true }
+mimalloc = { workspace = true }
 rstest = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
 vortex-geo = { path = ".", features = ["_test-harness"] }
@@ -45,5 +46,9 @@ vortex-layout = { workspace = true }
 name = "envelope"
 harness = false
 
+[[bench]]
+name = "binary_predicates"
+harness = false
+
 [lints]
 workspace = true