Skip to content

Apache DataFusion SQL Query Engine

Add per-aggregate metrics to non-grouped AggregateStream (#24706)

kosiewc56a7ab824bc
diff --git a/datafusion/physical-plan/src/aggregates/aggregate_stream.rs b/datafusion/physical-plan/src/aggregates/aggregate_stream.rs
index ac7727b459..7666fc6da7 100644
--- a/datafusion/physical-plan/src/aggregates/aggregate_stream.rs
+++ b/datafusion/physical-plan/src/aggregates/aggregate_stream.rs
@@ -17,14 +17,18 @@
//! Aggregate without grouping columns
+use crate::aggregates::group_values::{
+ AccumulatorPhase, AggregateAccumulatorMetrics, AggregateArgumentMetrics,
+};
use crate::aggregates::{
AccumulatorItem, AggrDynFilter, AggregateInputMode, AggregateMode,
- DynamicFilterAggregateType, aggregate_expressions, create_accumulators,
- finalize_aggregation,
+ AggregateOutputMode, DynamicFilterAggregateType, aggregate_expressions,
+ aggregate_metric_label, create_accumulators,
};
use crate::metrics::{BaselineMetrics, RecordOutput};
use crate::stream::EmptyRecordBatchStream;
use crate::{RecordBatchStream, SendableRecordBatchStream};
+use arrow::array::ArrayRef;
use arrow::datatypes::SchemaRef;
use arrow::record_batch::RecordBatch;
use datafusion_common::{Result, ScalarValue, internal_datafusion_err, internal_err};
@@ -33,6 +37,7 @@ use datafusion_expr::Operator;
use datafusion_physical_expr::PhysicalExpr;
use datafusion_physical_expr::expressions::{BinaryExpr, lit};
use futures::stream::BoxStream;
+use itertools::Itertools;
use std::borrow::Cow;
use std::cmp::Ordering;
use std::sync::Arc;
@@ -64,6 +69,8 @@ struct AggregateStreamInner {
input: SendableRecordBatchStream,
aggregate_expressions: Vec<Vec<Arc<dyn PhysicalExpr>>>,
filter_expressions: Arc<[Option<Arc<dyn PhysicalExpr>>]>,
+ aggregate_argument_metrics: AggregateArgumentMetrics,
+ aggregate_accumulator_metrics: AggregateAccumulatorMetrics,
// ==== Runtime States/Buffers ====
accumulators: Vec<AccumulatorItem>,
@@ -298,6 +305,22 @@ impl AggregateStream {
AggregateInputMode::Partial => vec![None; agg.aggr_expr.len()].into(),
};
let accumulators = create_accumulators(&agg.aggr_expr)?;
+ let aggregate_labels = agg
+ .aggr_expr
+ .iter()
+ .map(|agg_expr| aggregate_metric_label(agg_expr))
+ .collect::<Vec<_>>();
+ let aggregate_argument_metrics = AggregateArgumentMetrics::new(
+ &agg.metrics,
+ partition,
+ aggregate_labels.clone(),
+ );
+ let aggregate_accumulator_metrics = AggregateAccumulatorMetrics::new(
+ &agg.metrics,
+ partition,
+ aggregate_labels,
+ accumulator_phases(&agg.mode),
+ );
let reservation = MemoryConsumer::new(format!("AggregateStream[{partition}]"))
.register(context.memory_pool());
@@ -327,6 +350,8 @@ impl AggregateStream {
baseline_metrics,
aggregate_expressions,
filter_expressions,
+ aggregate_argument_metrics,
+ aggregate_accumulator_metrics,
accumulators,
reservation,
finished: false,
@@ -350,6 +375,8 @@ impl AggregateStream {
&mut this.accumulators,
&this.aggregate_expressions,
&this.filter_expressions,
+ &this.aggregate_argument_metrics,
+ &this.aggregate_accumulator_metrics,
)
};
@@ -375,19 +402,17 @@ impl AggregateStream {
let input_schema = this.input.schema();
this.input = Box::pin(EmptyRecordBatchStream::new(input_schema));
let timer = this.baseline_metrics.elapsed_compute().timer();
- let result =
- finalize_aggregation(&mut this.accumulators, &this.mode)
- .and_then(|columns| {
- prepend_grouping_id_column(columns, None)
- })
- .and_then(|columns| {
- RecordBatch::try_new(
- Arc::clone(&this.schema),
- columns,
- )
- .map_err(Into::into)
- })
- .record_output(&this.baseline_metrics);
+ let result = finalize_aggregation_with_metrics(
+ &mut this.accumulators,
+ &this.mode,
+ &this.aggregate_accumulator_metrics,
+ )
+ .and_then(|columns| prepend_grouping_id_column(columns, None))
+ .and_then(|columns| {
+ RecordBatch::try_new(Arc::clone(&this.schema), columns)
+ .map_err(Into::into)
+ })
+ .record_output(&this.baseline_metrics);
timer.done();
@@ -440,6 +465,8 @@ fn aggregate_batch(
accumulators: &mut [AccumulatorItem],
expressions: &[Vec<Arc<dyn PhysicalExpr>>],
filters: &[Option<Arc<dyn PhysicalExpr>>],
+ aggregate_argument_metrics: &AggregateArgumentMetrics,
+ aggregate_accumulator_metrics: &AggregateAccumulatorMetrics,
) -> Result<usize> {
let mut allocated = 0usize;
@@ -453,21 +480,30 @@ fn aggregate_batch(
.iter_mut()
.zip(expressions)
.zip(filters)
- .try_for_each(|((accum, expr), filter)| {
- // 1.2
- let batch = match filter {
- Some(filter) => Cow::Owned(batch_filter(batch, filter)?),
- None => Cow::Borrowed(batch),
- };
-
- // 1.3
- let values = evaluate_expressions_to_arrays(expr, batch.as_ref())?;
+ .enumerate()
+ .try_for_each(|(index, ((accum, expr), filter))| {
+ // 1.2 and 1.3
+ let values = aggregate_argument_metrics.time(index, || {
+ let batch = match filter {
+ Some(filter) => Cow::Owned(batch_filter(batch, filter)?),
+ None => Cow::Borrowed(batch),
+ };
+ evaluate_expressions_to_arrays(expr, batch.as_ref())
+ })?;
// 1.4
let size_pre = accum.size();
let res = match mode.input_mode() {
- AggregateInputMode::Raw => accum.update_batch(&values),
- AggregateInputMode::Partial => accum.merge_batch(&values),
+ AggregateInputMode::Raw => aggregate_accumulator_metrics.time(
+ index,
+ AccumulatorPhase::Update,
+ || accum.update_batch(&values),
+ ),
+ AggregateInputMode::Partial => aggregate_accumulator_metrics.time(
+ index,
+ AccumulatorPhase::Merge,
+ || accum.merge_batch(&values),
+ ),
};
let size_post = accum.size();
allocated += size_post.saturating_sub(size_pre);
@@ -476,3 +512,250 @@ fn aggregate_batch(
Ok(allocated)
}
+
+fn accumulator_phases(mode: &AggregateMode) -> &'static [AccumulatorPhase] {
+ match mode {
+ AggregateMode::Partial => &[AccumulatorPhase::Update, AccumulatorPhase::State],
+ AggregateMode::PartialReduce => {
+ &[AccumulatorPhase::Merge, AccumulatorPhase::State]
+ }
+ AggregateMode::Final | AggregateMode::FinalPartitioned => {
+ &[AccumulatorPhase::Merge, AccumulatorPhase::Evaluate]
+ }
+ AggregateMode::Single | AggregateMode::SinglePartitioned => {
+ &[AccumulatorPhase::Update, AccumulatorPhase::Evaluate]
+ }
+ }
+}
+
+fn finalize_aggregation_with_metrics(
+ accumulators: &mut [AccumulatorItem],
+ mode: &AggregateMode,
+ metrics: &AggregateAccumulatorMetrics,
+) -> Result<Vec<ArrayRef>> {
+ match mode.output_mode() {
+ AggregateOutputMode::Final => accumulators
+ .iter_mut()
+ .enumerate()
+ .map(|(index, accumulator)| {
+ metrics
+ .time(index, AccumulatorPhase::Evaluate, || accumulator.evaluate())
+ .and_then(|value| value.to_array())
+ })
+ .collect(),
+ AggregateOutputMode::Partial => accumulators
+ .iter_mut()
+ .enumerate()
+ .map(|(index, accumulator)| {
+ metrics
+ .time(index, AccumulatorPhase::State, || accumulator.state())
+ .and_then(|values| {
+ values
+ .iter()
+ .map(|value| value.to_array())
+ .collect::<Result<Vec<_>>>()
+ })
+ })
+ .flatten_ok()
+ .collect(),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::aggregates::PhysicalGroupBy;
+ use crate::metrics::{MetricValue, MetricsSet};
+ use crate::test::TestMemoryExec;
+ use crate::{ExecutionPlan, collect};
+ use arrow::array::Float64Array;
+ use arrow::datatypes::{DataType, Field, Schema};
+ use datafusion_functions_aggregate::sum::sum_udaf;
+ use datafusion_physical_expr::aggregate::{
+ AggregateExprBuilder, AggregateFunctionExpr,
+ };
+ use datafusion_physical_expr::expressions::col;
+
+ fn sum_aggregate(
+ schema: &SchemaRef,
+ column: &str,
+ alias: &str,
+ ) -> Result<Arc<AggregateFunctionExpr>> {
+ Ok(Arc::new(
+ AggregateExprBuilder::new(sum_udaf(), vec![col(column, schema)?])
+ .schema(Arc::clone(schema))
+ .alias(alias)
+ .build()?,
+ ))
+ }
+
+ fn aggregate_metrics(metrics: &MetricsSet, phase: &str) -> Vec<(String, String)> {
+ let mut result = metrics
+ .iter()
+ .filter_map(|metric| match metric.value() {
+ MetricValue::Time { name, .. }
+ if name
+ .strip_prefix("agg_expr_")
+ .and_then(|name| name.split_once('_'))
+ .is_some_and(|(_, suffix)| suffix == format!("{phase}_time")) =>
+ {
+ Some((
+ name.to_string(),
+ metric
+ .labels()
+ .iter()
+ .find(|label| label.name() == "aggregate")?
+ .value()
+ .to_string(),
+ ))
+ }
+ _ => None,
+ })
+ .collect::<Vec<_>>();
+ result.sort();
+ result
+ }
+
+ #[test]
+ fn accumulator_phases_match_aggregate_mode() {
+ let cases: [(AggregateMode, &[AccumulatorPhase]); 6] = [
+ (
+ AggregateMode::Partial,
+ &[AccumulatorPhase::Update, AccumulatorPhase::State],
+ ),
+ (
+ AggregateMode::PartialReduce,
+ &[AccumulatorPhase::Merge, AccumulatorPhase::State],
+ ),
+ (
+ AggregateMode::Final,
+ &[AccumulatorPhase::Merge, AccumulatorPhase::Evaluate],
+ ),
+ (
+ AggregateMode::FinalPartitioned,
+ &[AccumulatorPhase::Merge, AccumulatorPhase::Evaluate],
+ ),
+ (
+ AggregateMode::Single,
+ &[AccumulatorPhase::Update, AccumulatorPhase::Evaluate],
+ ),
+ (
+ AggregateMode::SinglePartitioned,
+ &[AccumulatorPhase::Update, AccumulatorPhase::Evaluate],
+ ),
+ ];
+
+ for (mode, expected) in cases {
+ assert!(accumulator_phases(&mode) == expected, "{mode:?}");
+ }
+ }
+
+ #[tokio::test]
+ async fn aggregate_stream_reports_per_aggregate_metrics() -> Result<()> {
+ let schema = Arc::new(Schema::new(vec![
+ Field::new("a", DataType::Float64, false),
+ Field::new("b", DataType::Float64, false),
+ ]));
+ let batch = RecordBatch::try_new(
+ Arc::clone(&schema),
+ vec![
+ Arc::new(Float64Array::from(vec![1.0, 2.0, 3.0])),
+ Arc::new(Float64Array::from(vec![4.0, 5.0, 6.0])),
+ ],
+ )?;
+ let input =
+ TestMemoryExec::try_new_exec(&[vec![batch]], Arc::clone(&schema), None)?;
+ let aggregates = vec![
+ sum_aggregate(&schema, "a", "SUM(a)")?,
+ sum_aggregate(&schema, "b", "SUM(b)")?,
+ ];
+ let aggregate = Arc::new(AggregateExec::try_new(
+ AggregateMode::Single,
+ PhysicalGroupBy::default(),
+ aggregates,
+ vec![None, None],
+ input,
+ schema,
+ )?);
+
+ let _ = collect(
+ Arc::clone(&aggregate) as Arc<dyn ExecutionPlan>,
+ Arc::new(TaskContext::default()),
+ )
+ .await?;
+
+ let metrics = aggregate.metrics().unwrap();
+ for phase in ["arguments", "update", "evaluate"] {
+ assert_eq!(
+ aggregate_metrics(&metrics, phase),
+ vec![
+ (format!("agg_expr_0_{phase}_time"), "SUM(a)".to_string()),
+ (format!("agg_expr_1_{phase}_time"), "SUM(b)".to_string()),
+ ]
+ );
+ }
+ assert!(aggregate_metrics(&metrics, "merge").is_empty());
+ assert!(aggregate_metrics(&metrics, "state").is_empty());
+
+ Ok(())
+ }
+
+ #[tokio::test]
+ async fn aggregate_stream_reports_partial_and_final_phases() -> Result<()> {
+ let schema = Arc::new(Schema::new(vec![
+ Field::new("a", DataType::Float64, false),
+ Field::new("b", DataType::Float64, false),
+ ]));
+ let batch = RecordBatch::try_new(
+ Arc::clone(&schema),
+ vec![
+ Arc::new(Float64Array::from(vec![1.0, 2.0, 3.0])),
+ Arc::new(Float64Array::from(vec![4.0, 5.0, 6.0])),
+ ],
+ )?;
+ let input =
+ TestMemoryExec::try_new_exec(&[vec![batch]], Arc::clone(&schema), None)?;
+ let aggregates = vec![
+ sum_aggregate(&schema, "a", "SUM(a)")?,
+ sum_aggregate(&schema, "b", "SUM(b)")?,
+ ];
+ let group_by = PhysicalGroupBy::default();
+ let partial = Arc::new(AggregateExec::try_new(
+ AggregateMode::Partial,
+ group_by.clone(),
+ aggregates.clone(),
+ vec![None, None],
+ input,
+ Arc::clone(&schema),
+ )?);
+ let final_aggregate = Arc::new(AggregateExec::try_new(
+ AggregateMode::Final,
+ group_by.as_final(),
+ aggregates,
+ vec![None, None],
+ Arc::clone(&partial) as Arc<dyn ExecutionPlan>,
+ partial.schema(),
+ )?);
+ let _ = collect(
+ Arc::clone(&final_aggregate) as Arc<dyn ExecutionPlan>,
+ Arc::new(TaskContext::default()),
+ )
+ .await?;
+
+ let partial_metrics = partial.metrics().unwrap();
+ assert_eq!(aggregate_metrics(&partial_metrics, "update").len(), 2);
+ assert_eq!(aggregate_metrics(&partial_metrics, "state").len(), 2);
+ assert_eq!(aggregate_metrics(&partial_metrics, "arguments").len(), 2);
+ assert!(aggregate_metrics(&partial_metrics, "merge").is_empty());
+ assert!(aggregate_metrics(&partial_metrics, "evaluate").is_empty());
+
+ let final_metrics = final_aggregate.metrics().unwrap();
+ assert_eq!(aggregate_metrics(&final_metrics, "merge").len(), 2);
+ assert_eq!(aggregate_metrics(&final_metrics, "evaluate").len(), 2);
+ assert_eq!(aggregate_metrics(&final_metrics, "arguments").len(), 2);
+ assert!(aggregate_metrics(&final_metrics, "update").is_empty());
+ assert!(aggregate_metrics(&final_metrics, "state").is_empty());
+
+ Ok(())
+ }
+}