bench: cover representative run-end sums

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

Author: connortsui20

encodings/runend/Cargo.toml

@@ -58,3 +58,7 @@ harness = false
 [[bench]]
 name = "run_end_filter"
 harness = false
+
+[[bench]]
+name = "run_end_sum"
+harness = false

encodings/runend/benches/run_end_sum.rs

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![expect(clippy::unwrap_used)]
+
+use std::sync::LazyLock;
+
+use divan::Bencher;
+use vortex_array::ArrayRef;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::aggregate_fn::DynGroupedAccumulator;
+use vortex_array::aggregate_fn::GroupedAccumulator;
+use vortex_array::aggregate_fn::NumericalAggregateOpts;
+use vortex_array::aggregate_fn::fns::sum_v2::SumV2;
+use vortex_array::aggregate_fn::fns::sum_v2::sum_v2;
+use vortex_array::arrays::FixedSizeListArray;
+use vortex_array::arrays::PrimitiveArray;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_runend::RunEnd;
+use vortex_session::VortexSession;
+
+const LEN: usize = 2_048;
+const RUN_LENGTH: usize = 64;
+
+static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
+    let session = vortex_array::array_session();
+    vortex_runend::initialize(&session);
+    session
+});
+
+fn main() {
+    LazyLock::force(&SESSION);
+    divan::main();
+}
+
+fn runend_with_null_runs() -> ArrayRef {
+    let ends =
+        PrimitiveArray::from_iter((RUN_LENGTH..=LEN).step_by(RUN_LENGTH).map(|end| end as u64));
+    let values = PrimitiveArray::from_option_iter(
+        (0..ends.len())
+            .map(|index| (index % 5 != 0).then_some(i32::try_from(index % 100).unwrap())),
+    );
+    RunEnd::try_new(
+        ends.into_array(),
+        values.into_array(),
+        &mut SESSION.create_execution_ctx(),
+    )
+    .unwrap()
+    .into_array()
+}
+
+fn bench_fixed_size_group_sum(bencher: Bencher, elements: ArrayRef, group_size: u32) {
+    let dtype = elements.dtype().clone();
+    let groups = FixedSizeListArray::try_new(
+        elements,
+        group_size,
+        Validity::NonNullable,
+        LEN / group_size as usize,
+    )
+    .unwrap()
+    .into_array();
+    bencher
+        .with_inputs(|| {
+            (
+                GroupedAccumulator::try_new(
+                    SumV2,
+                    NumericalAggregateOpts::default(),
+                    dtype.clone(),
+                )
+                .unwrap(),
+                SESSION.create_execution_ctx(),
+            )
+        })
+        .bench_refs(|(acc, ctx)| {
+            acc.accumulate_list(&groups, ctx).unwrap();
+            acc.finish()
+                .unwrap()
+                .execute::<PrimitiveArray>(ctx)
+                .unwrap()
+        });
+}
+
+#[divan::bench]
+fn whole_array_sum_partially_valid(bencher: Bencher) {
+    let array = runend_with_null_runs();
+    bencher
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_refs(|ctx| sum_v2(&array, ctx).unwrap());
+}
+
+#[divan::bench(args = [Validity::AllValid, Validity::AllInvalid])]
+fn whole_array_sum_uniform_validity(bencher: Bencher, validity: &Validity) {
+    let array = runend_with_validity(validity);
+
+    bencher
+        .with_inputs(|| SESSION.create_execution_ctx())
+        .bench_refs(|ctx| sum_v2(&array, ctx).unwrap());
+}
+
+#[divan::bench(consts = [2, 128])]
+fn fixed_size_group_sum_partially_valid<const GROUP_SIZE: u32>(bencher: Bencher) {
+    bench_fixed_size_group_sum(bencher, runend_with_null_runs(), GROUP_SIZE);
+}
+
+fn runend_with_validity(validity: &Validity) -> ArrayRef {
+    let ends =
+        PrimitiveArray::from_iter((RUN_LENGTH..=LEN).step_by(RUN_LENGTH).map(|end| end as u64));
+    let values = PrimitiveArray::new(
+        (0..ends.len())
+            .map(|index| i32::try_from(index).unwrap())
+            .collect::<Buffer<_>>(),
+        validity.clone(),
+    );
+    RunEnd::try_new(
+        ends.into_array(),
+        values.into_array(),
+        &mut SESSION.create_execution_ctx(),
+    )
+    .unwrap()
+    .into_array()
+}
+
+#[divan::bench(consts = [2, 128])]
+fn fixed_size_group_sum_all_valid<const GROUP_SIZE: u32>(bencher: Bencher) {
+    bench_fixed_size_group_sum(
+        bencher,
+        runend_with_validity(&Validity::AllValid),
+        GROUP_SIZE,
+    );
+}