Apache DataFusion SQL Query Engine
perf: Optimize round scalar performance (#19831)
Kumar Ujjawald90d0746d64b
diff --git a/datafusion/functions/Cargo.toml b/datafusion/functions/Cargo.tomlindex 939fcfd11f..610ab1617a 100644--- a/datafusion/functions/Cargo.toml+++ b/datafusion/functions/Cargo.toml@@ -320,3 +320,8 @@ required-features = ["math_expressions"]harness = falsename = "floor_ceil"required-features = ["math_expressions"]++[[bench]]+harness = false+name = "round"+required-features = ["math_expressions"]diff --git a/datafusion/functions/benches/round.rs b/datafusion/functions/benches/round.rsnew file mode 100644index 0000000000..ea59584919--- /dev/null+++ b/datafusion/functions/benches/round.rs@@ -0,0 +1,154 @@+// Licensed to the Apache Software Foundation (ASF) under one+// or more contributor license agreements. See the NOTICE file+// distributed with this work for additional information+// regarding copyright ownership. The ASF licenses this file+// to you under the Apache License, Version 2.0 (the+// "License"); you may not use this file except in compliance+// with the License. You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing,+// software distributed under the License is distributed on an+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY+// KIND, either express or implied. See the License for the+// specific language governing permissions and limitations+// under the License.++extern crate criterion;++use arrow::datatypes::{DataType, Field, Float32Type, Float64Type};+use arrow::util::bench_util::create_primitive_array;+use criterion::{Criterion, SamplingMode, criterion_group, criterion_main};+use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;+use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};+use datafusion_functions::math::round;+use std::hint::black_box;+use std::sync::Arc;+use std::time::Duration;++fn criterion_benchmark(c: &mut Criterion) {+ let round_fn = round();+ let config_options = Arc::new(ConfigOptions::default());++ for size in [1024, 4096, 8192] {+ let mut group = c.benchmark_group(format!("round size={size}"));+ group.sampling_mode(SamplingMode::Flat);+ group.sample_size(10);+ group.measurement_time(Duration::from_secs(10));++ // Float64 array benchmark+ let f64_array = Arc::new(create_primitive_array::<Float64Type>(size, 0.1));+ let batch_len = f64_array.len();+ let f64_args = vec![+ ColumnarValue::Array(f64_array),+ ColumnarValue::Scalar(ScalarValue::Int32(Some(2))),+ ];++ group.bench_function("round_f64_array", |b| {+ b.iter(|| {+ let args_cloned = f64_args.clone();+ black_box(+ round_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: args_cloned,+ arg_fields: vec![+ Field::new("a", DataType::Float64, true).into(),+ Field::new("b", DataType::Int32, false).into(),+ ],+ number_rows: batch_len,+ return_field: Field::new("f", DataType::Float64, true).into(),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });++ // Float32 array benchmark+ let f32_array = Arc::new(create_primitive_array::<Float32Type>(size, 0.1));+ let f32_args = vec![+ ColumnarValue::Array(f32_array),+ ColumnarValue::Scalar(ScalarValue::Int32(Some(2))),+ ];++ group.bench_function("round_f32_array", |b| {+ b.iter(|| {+ let args_cloned = f32_args.clone();+ black_box(+ round_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: args_cloned,+ arg_fields: vec![+ Field::new("a", DataType::Float32, true).into(),+ Field::new("b", DataType::Int32, false).into(),+ ],+ number_rows: batch_len,+ return_field: Field::new("f", DataType::Float32, true).into(),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });++ // Scalar benchmark (the optimization we added)+ let scalar_f64_args = vec![+ ColumnarValue::Scalar(ScalarValue::Float64(Some(std::f64::consts::PI))),+ ColumnarValue::Scalar(ScalarValue::Int32(Some(2))),+ ];++ group.bench_function("round_f64_scalar", |b| {+ b.iter(|| {+ let args_cloned = scalar_f64_args.clone();+ black_box(+ round_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: args_cloned,+ arg_fields: vec![+ Field::new("a", DataType::Float64, false).into(),+ Field::new("b", DataType::Int32, false).into(),+ ],+ number_rows: 1,+ return_field: Field::new("f", DataType::Float64, false)+ .into(),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });++ let scalar_f32_args = vec![+ ColumnarValue::Scalar(ScalarValue::Float32(Some(std::f32::consts::PI))),+ ColumnarValue::Scalar(ScalarValue::Int32(Some(2))),+ ];++ group.bench_function("round_f32_scalar", |b| {+ b.iter(|| {+ let args_cloned = scalar_f32_args.clone();+ black_box(+ round_fn+ .invoke_with_args(ScalarFunctionArgs {+ args: args_cloned,+ arg_fields: vec![+ Field::new("a", DataType::Float32, false).into(),+ Field::new("b", DataType::Int32, false).into(),+ ],+ number_rows: 1,+ return_field: Field::new("f", DataType::Float32, false)+ .into(),+ config_options: Arc::clone(&config_options),+ })+ .unwrap(),+ )+ })+ });++ group.finish();+ }+}++criterion_group!(benches, criterion_benchmark);+criterion_main!(benches);diff --git a/datafusion/functions/src/math/round.rs b/datafusion/functions/src/math/round.rsindex de70788128..8c25c57740 100644--- a/datafusion/functions/src/math/round.rs+++ b/datafusion/functions/src/math/round.rs@@ -31,7 +31,7 @@ use arrow::error::ArrowError;use datafusion_common::types::{NativeType, logical_float32, logical_float64, logical_int32,};-use datafusion_common::{Result, ScalarValue, exec_err};+use datafusion_common::{Result, ScalarValue, exec_err, internal_err};use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,@@ -141,7 +141,67 @@ impl ScalarUDFImpl for RoundFunc {&default_decimal_places};- round_columnar(&args.args[0], decimal_places, args.number_rows)+ // Scalar fast path for float and decimal types - avoid array conversion overhead+ if let (ColumnarValue::Scalar(value_scalar), ColumnarValue::Scalar(dp_scalar)) =+ (&args.args[0], decimal_places)+ {+ if value_scalar.is_null() || dp_scalar.is_null() {+ return ColumnarValue::Scalar(ScalarValue::Null)+ .cast_to(args.return_type(), None);+ }++ let dp = if let ScalarValue::Int32(Some(dp)) = dp_scalar {+ *dp+ } else {+ return internal_err!(+ "Unexpected datatype for decimal_places: {}",+ dp_scalar.data_type()+ );+ };++ match value_scalar {+ ScalarValue::Float32(Some(v)) => {+ let rounded = round_float(*v, dp)?;+ Ok(ColumnarValue::Scalar(ScalarValue::from(rounded)))+ }+ ScalarValue::Float64(Some(v)) => {+ let rounded = round_float(*v, dp)?;+ Ok(ColumnarValue::Scalar(ScalarValue::from(rounded)))+ }+ ScalarValue::Decimal128(Some(v), precision, scale) => {+ let rounded = round_decimal(*v, *scale, dp)?;+ let scalar =+ ScalarValue::Decimal128(Some(rounded), *precision, *scale);+ Ok(ColumnarValue::Scalar(scalar))+ }+ ScalarValue::Decimal256(Some(v), precision, scale) => {+ let rounded = round_decimal(*v, *scale, dp)?;+ let scalar =+ ScalarValue::Decimal256(Some(rounded), *precision, *scale);+ Ok(ColumnarValue::Scalar(scalar))+ }+ ScalarValue::Decimal64(Some(v), precision, scale) => {+ let rounded = round_decimal(*v, *scale, dp)?;+ let scalar =+ ScalarValue::Decimal64(Some(rounded), *precision, *scale);+ Ok(ColumnarValue::Scalar(scalar))+ }+ ScalarValue::Decimal32(Some(v), precision, scale) => {+ let rounded = round_decimal(*v, *scale, dp)?;+ let scalar =+ ScalarValue::Decimal32(Some(rounded), *precision, *scale);+ Ok(ColumnarValue::Scalar(scalar))+ }+ _ => {+ internal_err!(+ "Unexpected datatype for value: {}",+ value_scalar.data_type()+ )+ }+ }+ } else {+ round_columnar(&args.args[0], decimal_places, args.number_rows)+ }}fn output_ordering(&self, input: &[ExprProperties]) -> Result<SortProperties> {