Benchmark decimal byte-part assembly and splitting

Cover i64, i128, and i256 assembly through DecimalArray execution. Add split benchmarks for all-valid, mixed-null, and clustered-null inputs, with shared fixtures and setup outside the timed region.

Signed-off-by: "Matt Katz" <mhkatz97@gmail.com>

Author: mhk197

encodings/decimal-byte-parts/Cargo.toml

@@ -33,5 +33,9 @@ rstest = { workspace = true }
 vortex-array = { path = "../../vortex-array", features = ["_test-harness"] }
 
 [[bench]]
-name = "decimal_assemble"
+name = "dbp_assemble"
+harness = false
+
+[[bench]]
+name = "dbp_split"
 harness = false

encodings/decimal-byte-parts/benches/common/mod.rs

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Shared decimal inputs for splitting and assembly benchmarks.
+
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use vortex_array::arrays::DecimalArray;
+use vortex_array::dtype::DecimalDType;
+use vortex_array::dtype::DecimalType;
+use vortex_array::dtype::i256;
+use vortex_array::validity::Validity;
+use vortex_buffer::Buffer;
+use vortex_error::vortex_panic;
+
+pub(super) const LEN: usize = 65_536;
+
+pub(super) const DECIMAL_TYPES: &[DecimalType] =
+    &[DecimalType::I64, DecimalType::I128, DecimalType::I256];
+
+pub(super) fn decimal_array(values_type: DecimalType, validity: Validity) -> DecimalArray {
+    let mut rng = StdRng::seed_from_u64(42);
+
+    macro_rules! decimal {
+        ($T:ty, $precision:literal) => {{
+            let max = <$T>::pow(10, $precision) - 1;
+            let values: Buffer<$T> = (0..LEN).map(|_| rng.random_range(-max..=max)).collect();
+            DecimalArray::new(values, DecimalDType::new($precision, 2), validity)
+        }};
+    }
+
+    match values_type {
+        DecimalType::I64 => decimal!(i64, 18),
+        DecimalType::I128 => decimal!(i128, 38),
+        DecimalType::I256 => {
+            // Keep the magnitude below 10^76 while exercising all four signed/unsigned words.
+            let values: Buffer<i256> = (0..LEN)
+                .map(|_| i256::from_parts(rng.random(), rng.random::<i128>() >> 4))
+                .collect();
+            DecimalArray::new(values, DecimalDType::new(76, 2), validity)
+        }
+        _ => vortex_panic!("unsupported benchmark storage type: {values_type}"),
+    }
+}

encodings/decimal-byte-parts/benches/dbp_assemble.rs

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Executing decimal byte parts into canonical decimal arrays.
+
+mod common;
+
+use divan::Bencher;
+use divan::black_box;
+use vortex_array::IntoArray;
+use vortex_array::VortexSessionExecute;
+use vortex_array::array_session;
+use vortex_array::arrays::DecimalArray;
+use vortex_array::dtype::DecimalType;
+use vortex_array::validity::Validity;
+use vortex_decimal_byte_parts::DecimalByteParts;
+use vortex_decimal_byte_parts::split_decimal;
+use vortex_error::VortexExpect;
+
+use crate::common::DECIMAL_TYPES;
+use crate::common::decimal_array;
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = DECIMAL_TYPES)]
+fn assemble(bencher: Bencher, values_type: DecimalType) {
+    let decimal = decimal_array(values_type, Validity::NonNullable);
+    let parts = split_decimal(&decimal, &mut array_session().create_execution_ctx())
+        .vortex_expect("split benchmark input");
+    let dbp = DecimalByteParts::try_new_with_lower_parts(
+        parts.msp,
+        parts.lower_parts,
+        decimal.decimal_dtype(),
+    )
+    .vortex_expect("construct decimal byte parts")
+    .into_array();
+
+    let session = array_session();
+    bencher
+        .with_inputs(|| session.create_execution_ctx())
+        .bench_refs(|ctx| {
+            black_box(dbp.clone())
+                .execute::<DecimalArray>(ctx)
+                .vortex_expect("assemble decimal byte parts")
+        });
+}

encodings/decimal-byte-parts/benches/dbp_split.rs

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Splitting decimal arrays across storage widths and validity paths.
+
+mod common;
+
+use divan::Bencher;
+use divan::black_box;
+use rand::RngExt;
+use rand::SeedableRng;
+use rand::rngs::StdRng;
+use vortex_array::VortexSessionExecute;
+use vortex_array::array_session;
+use vortex_array::dtype::DecimalType;
+use vortex_array::validity::Validity;
+use vortex_decimal_byte_parts::split_decimal;
+use vortex_error::VortexExpect;
+
+use crate::common::DECIMAL_TYPES;
+use crate::common::LEN;
+use crate::common::decimal_array;
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = DECIMAL_TYPES)]
+fn all_valid(bencher: Bencher, values_type: DecimalType) {
+    bench_split(bencher, values_type, Validity::AllValid);
+}
+
+#[divan::bench(args = DECIMAL_TYPES)]
+fn mixed_nulls(bencher: Bencher, values_type: DecimalType) {
+    let mut rng = StdRng::seed_from_u64(42);
+    let validity = Validity::from_iter((0..LEN).map(|_| rng.random_bool(0.5)));
+    bench_split(bencher, values_type, validity);
+}
+
+#[divan::bench(args = DECIMAL_TYPES)]
+fn clustered_nulls(bencher: Bencher, values_type: DecimalType) {
+    const CLUSTER_LEN: usize = 1_024;
+    let validity = Validity::from_iter((0..LEN).map(|i| (i / CLUSTER_LEN).is_multiple_of(2)));
+    bench_split(bencher, values_type, validity);
+}
+
+fn bench_split(bencher: Bencher, values_type: DecimalType, validity: Validity) {
+    let decimal = decimal_array(values_type, validity);
+    let session = array_session();
+    bencher
+        .with_inputs(|| session.create_execution_ctx())
+        .bench_refs(|ctx| {
+            split_decimal(black_box(&decimal), ctx).vortex_expect("split decimal array")
+        });
+}