Add scalar function performance baselines

Adds stable CodSpeed baselines for public construction and execution paths across byte length, binary arithmetic, LIKE, tensor scalar functions, and geo operations. The benches avoid RowFn test-harness internals so later implementation changes compare against the production path.

Geo distance covers point and polygon columns, including constants and nullable points. Geo predicate coverage adds sparse and mixed validity cases, while its all-overlapping polygon arm uses 1,024 rows because CodSpeed simulates the compiled amd64/AVX2 machine code.

Each benchmark binary that allocates inside the timed region uses vendored `mimalloc`. `Normalized` keeps its checked inherent constructor because its normalized-row invariant requires construction-time validation.

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

@@ -54,6 +54,30 @@ fn add_i64_nullable(bencher: Bencher) {
     bench_primitive(bencher, lhs, rhs, Operator::Add);
 }
 
+#[divan::bench]
+fn add_i64_constant(bencher: Bencher) {
+    let lhs = primitive_nonnull(0).into_array();
+    let rhs = ConstantArray::new(1_000_000i64, LEN).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Add);
+}
+
+#[divan::bench]
+fn add_i32_nonnull(bencher: Bencher) {
+    let lhs = primitive_i32_small_nonnull(1).into_array();
+    let rhs = primitive_i32_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Add);
+}
+
+#[divan::bench]
+fn add_u32_nonnull(bencher: Bencher) {
+    let lhs = primitive_u32_small_nonnull(1).into_array();
+    let rhs = primitive_u32_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Add);
+}
+
 #[divan::bench]
 fn mul_i64_nonnull(bencher: Bencher) {
     let lhs = primitive_small_nonnull(1).into_array();

vortex-array/benches/binary_ops.rs

@@ -0,0 +1,98 @@
+// 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::ScalarFnArray;
+use vortex_array::arrays::VarBinViewArray;
+use vortex_array::scalar_fn::EmptyOptions;
+use vortex_array::scalar_fn::TypedScalarFnInstance;
+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(|| {
+            (
+                ScalarFnArray::try_new(
+                    TypedScalarFnInstance::new(ByteLength, EmptyOptions).erased(),
+                    vec![input.clone()],
+                )
+                .unwrap()
+                .into_array(),
+                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);
+}
+
+#[divan::bench(args = SIZES)]
+fn nullable_out_of_line_90pct(bencher: Bencher, len: usize) {
+    let validity = Validity::from_iter((0..len).map(|i| i.is_multiple_of(10)));
+    let input = MaskedArray::try_new(long_strings(len), validity)
+        .unwrap()
+        .into_array();
+    bench_byte_length(bencher, input);
+}

vortex-array/benches/byte_length.rs

@@ -13,8 +13,9 @@ use vortex_array::IntoArray;
 use vortex_array::VortexSessionExecute;
 use vortex_array::arrays::BoolArray;
 use vortex_array::arrays::ConstantArray;
+use vortex_array::arrays::ScalarFnArray;
 use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::scalar_fn::ScalarFnFactoryExt;
+use vortex_array::scalar_fn::TypedScalarFnInstance;
 use vortex_array::scalar_fn::fns::like::Like;
 use vortex_array::scalar_fn::fns::like::LikeOptions;
 
@@ -47,15 +48,15 @@ fn bench_like(bencher: Bencher, pattern: &str, options: LikeOptions) {
     bencher
         .with_inputs(|| {
             (
-                Like.try_new_array(
-                    ARRAY_SIZE,
-                    options,
-                    [
+                ScalarFnArray::try_new(
+                    TypedScalarFnInstance::new(Like, options).erased(),
+                    vec![
                         array.clone(),
                         ConstantArray::new(pattern, ARRAY_SIZE).into_array(),
                     ],
                 )
-                .unwrap(),
+                .unwrap()
+                .into_array(),
                 session.create_execution_ctx(),
             )
         })
@@ -87,28 +88,50 @@ fn like_regex(bencher: Bencher) {
     bench_like(bencher, "h_llo%w%d", LikeOptions::default());
 }
 
-#[divan::bench]
-fn like_per_row_patterns(bencher: Bencher) {
+fn bench_per_row_patterns(bencher: Bencher, patterns: ArrayRef) {
     let session = vortex_array::array_session();
     let array = strings();
-    // A non-constant pattern child takes the per-row path; repeated patterns hit the
-    // compile cache.
-    let patterns = VarBinViewArray::from_iter_str((0..ARRAY_SIZE).map(|_| "hello%")).into_array();
     bencher
         .with_inputs(|| {
             (
-                Like.try_new_array(
-                    ARRAY_SIZE,
-                    LikeOptions::default(),
-                    [array.clone(), patterns.clone()],
+                ScalarFnArray::try_new(
+                    TypedScalarFnInstance::new(Like, LikeOptions::default()).erased(),
+                    vec![array.clone(), patterns.clone()],
                 )
-                .unwrap(),
+                .unwrap()
+                .into_array(),
                 session.create_execution_ctx(),
             )
         })
         .bench_values(|(array, mut ctx)| array.execute::<BoolArray>(&mut ctx).unwrap());
 }
 
+#[divan::bench]
+fn like_per_row_patterns(bencher: Bencher) {
+    // A non-constant pattern child takes the per-row path; repeated patterns hit the compile
+    // cache. Its five-byte `%aaa%` shape matches the distinct-pattern fixture below.
+    let patterns = VarBinViewArray::from_iter_str((0..ARRAY_SIZE).map(|_| "%aaa%")).into_array();
+    bench_per_row_patterns(bencher, patterns);
+}
+
+/// The per-row path with the compile cache defeated: every row carries a distinct pattern of the
+/// same shape, so each row pays one pattern compilation.
+#[divan::bench]
+fn like_per_row_distinct_patterns(bencher: Bencher) {
+    let patterns = VarBinViewArray::from_iter_str(
+        (0..ARRAY_SIZE).map(|i| format!("%{}%", distinct_trigram(i))),
+    )
+    .into_array();
+    bench_per_row_patterns(bencher, patterns);
+}
+
+/// A distinct three-letter lowercase infix per row, so every pattern has the same shape while
+/// no two rows share a compiled pattern.
+fn distinct_trigram(i: usize) -> String {
+    let letter = |shift: usize| char::from(b'a' + u8::try_from((i >> shift) % 26).unwrap());
+    [letter(0), letter(5), letter(10)].iter().collect()
+}
+
 #[divan::bench]
 fn ilike_contains(bencher: Bencher) {
     bench_like(

vortex-array/benches/like.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,13 @@ vortex-layout = { workspace = true }
 name = "envelope"
 harness = false
 
+[[bench]]
+name = "binary_predicates"
+harness = false
+
+[[bench]]
+name = "distance"
+harness = false
+
 [lints]
 workspace = true