Skip to content

Apache DataFusion SQL Query Engine

bench: Fix panic in `power` benchmark (#26028)

Neil Conway5c7d33aac4e7
diff --git a/datafusion/functions/benches/math_expressions/power.rs b/datafusion/functions/benches/math_expressions/power.rs
index eed0e55aa3..2ead8e3d91 100644
--- a/datafusion/functions/benches/math_expressions/power.rs
+++ b/datafusion/functions/benches/math_expressions/power.rs
@@ -15,34 +15,38 @@
// specific language governing permissions and limitations
// under the License.
-//! Microbenchmark for `power(decimal_array, int_*)`.
+//! Microbenchmark for `power`.
//!
-//! Covers both array- and scalar-shaped integer exponents on a Decimal
-//! base. Both shapes are dispatched to the native per-row decimal kernel;
-//! the bench guards against any future change that routes either shape
-//! through a Float64 round-trip, which is measurably slower than the
-//! decimal kernel for the cases the kernel can handle.
+//! `power` coerces both arguments to Float64, so the inputs are Float64.
+//! Covers a different exponent for each row, as in `power(x, y)`, and a
+//! constant exponent, as in `power(x, 2)`.
-use arrow::array::{Decimal128Array, Int64Array};
+use std::hint::black_box;
+use std::ops::Range;
+use std::sync::Arc;
+
+use arrow::array::Float64Array;
use arrow::datatypes::{DataType, Field, FieldRef};
use criterion::{Criterion, criterion_group};
use datafusion_common::ScalarValue;
use datafusion_common::config::ConfigOptions;
use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDF};
use datafusion_functions::math::power;
-use std::hint::black_box;
-use std::sync::Arc;
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
-fn make_decimal_array(size: usize, precision: u8, scale: i8) -> Decimal128Array {
- // Use a fixed unscaled value (250) so the bench is independent of `scale`.
- // The four-arm dispatch in `power` only cares about the Decimal variant
- // and the exponent's shape, not the numeric value.
- let arr = Decimal128Array::from(vec![250i128; size]);
- arr.with_precision_and_scale(precision, scale).unwrap()
-}
+const NULL_DENSITY: f64 = 0.1;
-fn make_int_array(size: usize, value: i64) -> Int64Array {
- Int64Array::from(vec![value; size])
+fn make_f64_array(rng: &mut StdRng, size: usize, range: Range<f64>) -> Float64Array {
+ (0..size)
+ .map(|_| {
+ if rng.random_bool(NULL_DENSITY) {
+ None
+ } else {
+ Some(rng.random_range(range.clone()))
+ }
+ })
+ .collect()
}
fn run_power(
@@ -69,54 +73,41 @@ fn run_power(
fn criterion_benchmark(c: &mut Criterion) {
let power_fn = power();
let config_options = Arc::new(ConfigOptions::default());
- let precision: u8 = 20;
- let scale: i8 = 2;
- let decimal_ty = DataType::Decimal128(precision, scale);
-
- // Exponents are bounded by what the native decimal kernel can handle
- // without overflowing the i128 intermediate; see
- // <https://github.com/apache/datafusion/issues/22480>
- let exponents = [2i64, 4, 8];
+ let base_field: FieldRef = Field::new("base", DataType::Float64, true).into();
+ let exp_field: FieldRef = Field::new("exp", DataType::Float64, true).into();
+ let return_field: FieldRef = Field::new("r", DataType::Float64, true).into();
+ let arg_fields = vec![base_field, exp_field];
for size in [1024usize, 8192] {
- let base_arr = Arc::new(make_decimal_array(size, precision, scale));
- let base_field: FieldRef = Field::new("base", decimal_ty.clone(), true).into();
- let exp_field: FieldRef = Field::new("exp", DataType::Int64, true).into();
- let return_field: FieldRef = Field::new("r", decimal_ty.clone(), true).into();
- let arg_fields = vec![base_field, exp_field];
+ let mut rng = StdRng::seed_from_u64(42);
+ // Bases are positive: a zero base with a negative exponent is an error.
+ let base_arr = Arc::new(make_f64_array(&mut rng, size, 0.1..100.0));
+ let exp_arr = Arc::new(make_f64_array(&mut rng, size, -4.0..4.0));
- for &exp in &exponents {
- let exp_arr = Arc::new(make_int_array(size, exp));
- let array_args = vec![
- ColumnarValue::Array(base_arr.clone()),
- ColumnarValue::Array(exp_arr),
- ];
- c.bench_function(
- &format!(
- "power decimal({precision},{scale}) array x int array, exp={exp}, n={size}"
- ),
- |b| {
- b.iter(|| {
- run_power(
- &power_fn,
- &array_args,
- &arg_fields,
- &return_field,
- &config_options,
- size,
- )
- })
- },
- );
+ let array_args = vec![
+ ColumnarValue::Array(Arc::clone(&base_arr) as _),
+ ColumnarValue::Array(exp_arr),
+ ];
+ c.bench_function(&format!("power f64 array x f64 array, n={size}"), |b| {
+ b.iter(|| {
+ run_power(
+ &power_fn,
+ &array_args,
+ &arg_fields,
+ &return_field,
+ &config_options,
+ size,
+ )
+ })
+ });
+ for exp in [2.0, 0.5] {
let scalar_args = vec![
- ColumnarValue::Array(base_arr.clone()),
- ColumnarValue::Scalar(ScalarValue::Int64(Some(exp))),
+ ColumnarValue::Array(Arc::clone(&base_arr) as _),
+ ColumnarValue::Scalar(ScalarValue::Float64(Some(exp))),
];
c.bench_function(
- &format!(
- "power decimal({precision},{scale}) array x int scalar, exp={exp}, n={size}"
- ),
+ &format!("power f64 array x f64 scalar, exp={exp}, n={size}"),
|b| {
b.iter(|| {
run_power(