diff --git a/docs/source/user-guide/latest/tuning/operators.md b/docs/source/user-guide/latest/tuning/operators.md index 721723cd647..b884d9cba61 100644 --- a/docs/source/user-guide/latest/tuning/operators.md +++ b/docs/source/user-guide/latest/tuning/operators.md @@ -44,7 +44,8 @@ limit, or to a non-positive value to convert every eligible join regardless of s A left-semi join returns each left row if any right row matches. For an unfiltered batch join on a single integer equality key (`=`), set `spark.comet.exec.sortMergeJoin.rightKeyReduction.enabled=true` to keep one copy of each repeated key per batch before the native sort. The option is off by -default. The right sort must read the key column directly from a Comet shuffle. With the +default. The right sort must read from a Comet shuffle. Its key can be a single shuffled integer column +or a `coalesce` of same-type integer columns and literals, such as `coalesce(r.primary_id, r.backup_id)`. With the `fair_unified` memory pool, the native planner checks at first execution for memory held by another Spark consumer in the task and skips reduction if it finds any, logging the reason at debug level. This best-effort check does not cover consumers that allocate memory later. diff --git a/native/core/src/execution/planner/join.rs b/native/core/src/execution/planner/join.rs index b4ed291eaf2..393851da771 100644 --- a/native/core/src/execution/planner/join.rs +++ b/native/core/src/execution/planner/join.rs @@ -32,7 +32,7 @@ use datafusion::{ config::ConfigOptions, physical_expr::{ expressions::{CastExpr, Column}, - LexOrdering, PhysicalExpr, + LexOrdering, PhysicalExpr, PhysicalSortExpr, }, physical_plan::{ filter::FilterExec, @@ -218,16 +218,19 @@ fn reduce_before_sort( let Some(sort) = params.right.native_plan.downcast_ref::() else { return Ok(None); }; + // Removing duplicates before a fetch can bring new keys into the first N rows. + if sort.fetch().is_some() { + return Ok(None); + } let input = sort.input(); - let ([(_, key)], [options]) = (params.join_on.as_slice(), sort_options) else { + let ([(_, key)], [options]) = (params.join_on.as_mut_slice(), sort_options) else { return Ok(None); }; let schema = input.schema(); let order = sort.expr().first(); if !(input.is::() || input.is::()) - || schema.fields().len() != 1 - || !schema.field(0).data_type().is_signed_integer() - || !key.is::() + || !key.data_type(&schema).is_ok_and(|t| t.is_signed_integer()) + || (key.is::() && schema.fields().len() != 1) || sort.expr().len() != 1 || order.options != *options || !order.expr.eq(key) @@ -260,12 +263,23 @@ fn reduce_before_sort( return Ok(None); } } - let reducer: Arc = - Arc::new(MembershipKeyReductionExec::new(Arc::clone(input))); - let sort = Arc::clone(¶ms.right.native_plan).replace_children( - vec![Arc::clone(&reducer)], - ReplaceChildrenOptions::new(ChildrenPropertiesMode::Recompute), - )?; + let (input, ordering) = if key.is::() { + (Arc::clone(input), sort.expr().clone()) + } else { + // Spark admitted an integer coalesce. Evaluate it once and use that column for + // reduction, sorting, and the join. A left-semi join needs no other right columns. + let name = "membership_key"; + let projected = + ProjectionExec::try_new([(Arc::clone(key), name.to_owned())], Arc::clone(input))?; + *key = Arc::new(Column::new(name, 0)); + let ordering = LexOrdering::from([PhysicalSortExpr::new(Arc::clone(key), *options)]); + (Arc::new(projected) as Arc, ordering) + }; + let reducer: Arc = Arc::new(MembershipKeyReductionExec::new(input)); + let sort = Arc::new( + SortExec::new(ordering, Arc::clone(&reducer)) + .with_preserve_partitioning(sort.preserve_partitioning()), + ); Arc::make_mut(&mut params.right).native_plan = sort; // The Spark sort collects from its replacement. The join owns the reducer's named metrics. Ok(Some(reducer)) @@ -307,8 +321,7 @@ impl OperatorBuilder for SortMergeJoinBuilder { .collect(); let reducer = if join.right_key_reduction_enabled - && matches!(&children[1].op_struct, Some(OpStruct::Sort(sort)) - if sort.fetch.is_none() && sort.skip.is_none()) + && matches!(&children[1].op_struct, Some(OpStruct::Sort(sort)) if sort.skip.is_none()) { reduce_before_sort(planner, &mut join_params, &sort_options)? } else { diff --git a/native/core/src/execution/planner/tests/semi_join_reduction.rs b/native/core/src/execution/planner/tests/semi_join_reduction.rs index 05317019367..39f797a8b14 100644 --- a/native/core/src/execution/planner/tests/semi_join_reduction.rs +++ b/native/core/src/execution/planner/tests/semi_join_reduction.rs @@ -15,19 +15,27 @@ // specific language governing permissions and limitations // under the License. +use std::sync::Arc; + use super::{ create_bound_reference, create_proto_datatype, create_scan, create_sort_order, PhysicalPlanner, }; +use datafusion::{ + physical_expr::expressions::Column, + physical_plan::{ + joins::SortMergeJoinExec, projection::ProjectionExec, sorts::sort::SortExec, ExecutionPlan, + }, +}; use datafusion_comet_operators::MembershipKeyReductionExec; +use datafusion_comet_proto::spark_expression::{self as expr, expr::ExprStruct, Expr}; use datafusion_comet_proto::spark_operator::{self as op, operator::OpStruct, JoinType, Operator}; -fn reduced(input: Operator, sort: op::Sort) -> bool { +fn plan_join(input: Operator, sort: op::Sort, key: Expr) -> Arc { let sorted = Operator { children: vec![input], op_struct: Some(OpStruct::Sort(sort)), ..Default::default() }; - let key = create_bound_reference(0); let join = Operator { children: vec![sorted.clone(), sorted], op_struct: Some(OpStruct::SortMergeJoin(op::SortMergeJoin { @@ -48,11 +56,15 @@ fn reduced(input: Operator, sort: op::Sort) -> bool { let (_, _, plan) = PhysicalPlanner::default() .create_plan(&join, &mut vec![], 1) .unwrap(); - plan.children[1].native_plan.children()[0].is::() + Arc::clone(&plan.native_plan) } #[test] fn reduces_only_a_matching_unlimited_sort_directly_over_the_shuffle() { + let reduced = |input, sort| { + plan_join(input, sort, create_bound_reference(0)).children()[1].children()[0] + .is::() + }; let field = create_proto_datatype(); let scan = create_scan(); let sort = op::Sort { @@ -94,3 +106,59 @@ fn reduces_only_a_matching_unlimited_sort_directly_over_the_shuffle() { }; assert!(!reduced(project, sort)); } + +#[test] +fn projects_an_integer_coalesce_before_reducing_its_key() { + let wrap = |kind| Expr { + expr_struct: Some(kind), + ..Default::default() + }; + let plan_key = |key: Expr| { + let sort = op::Sort { + sort_orders: vec![wrap(ExprStruct::SortOrder(Box::new(expr::SortOrder { + child: Some(Box::new(key.clone())), + ..Default::default() + })))], + ..Default::default() + }; + plan_join(create_scan(), sort, key) + }; + let column = create_bound_reference(0); + let has_value = wrap(ExprStruct::IsNotNull(Box::new(expr::UnaryExpr { + child: Some(Box::new(column.clone())), + }))); + // Spark lowers coalesce(k, 0) to CASE WHEN k IS NOT NULL THEN k ELSE 0 END. + let key = wrap(ExprStruct::CaseWhen(Box::new(expr::CaseWhen { + when: vec![has_value.clone()], + then: vec![column], + else_expr: Some(Box::new(wrap(ExprStruct::Literal(expr::Literal { + datatype: Some(create_proto_datatype()), + value: Some(expr::literal::Value::IntVal(0)), + ..Default::default() + })))), + ..Default::default() + }))); + let plan = plan_key(key); + let join = plan.downcast_ref::().unwrap(); + let sort = join.right().downcast_ref::().unwrap(); + let reducer = sort + .input() + .downcast_ref::() + .unwrap(); + let projection = reducer.children()[0] + .downcast_ref::() + .unwrap(); + let key = &join.on()[0].1; + assert_eq!( + key.downcast_ref::().unwrap(), + &Column::new("membership_key", 0) + ); + assert!(sort.expr().first().expr.eq(key)); + assert_eq!(projection.expr()[0].alias, "membership_key"); + + // A computed Boolean key still uses the original sort input. + let boolean_plan = plan_key(has_value); + let join = boolean_plan.downcast_ref::().unwrap(); + let sort = join.right().downcast_ref::().unwrap(); + assert!(sort.input().is::()); +} diff --git a/spark/src/main/scala/org/apache/comet/CometConf.scala b/spark/src/main/scala/org/apache/comet/CometConf.scala index 06f7e8b5f3f..4e68cfe12d4 100644 --- a/spark/src/main/scala/org/apache/comet/CometConf.scala +++ b/spark/src/main/scala/org/apache/comet/CometConf.scala @@ -375,9 +375,8 @@ object CometConf extends ShimCometConf { val COMET_EXEC_SORT_MERGE_JOIN_RIGHT_KEY_REDUCTION_ENABLED: ConfigEntry[Boolean] = conf(s"$COMET_EXEC_CONFIG_PREFIX.sortMergeJoin.rightKeyReduction.enabled") .category(CATEGORY_EXEC) - .doc( - "Reduce duplicate keys when an unfiltered left-semi sort-merge join reads its single " + - s"integer equality key directly from a Comet shuffle. $TUNING_GUIDE.") + .doc("Reduce repeated integer keys before the right sort of an unfiltered left-semi join " + + s"over a Comet shuffle. Supports a single column or coalesce expression. $TUNING_GUIDE.") .booleanConf .createWithDefault(false) val COMET_EXEC_EXISTENCE_JOIN_ENABLED: ConfigEntry[Boolean] = diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala index 07a6a769eb9..a4a4a38ddde 100644 --- a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala +++ b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala @@ -31,7 +31,7 @@ import org.apache.spark.broadcast.Broadcast import org.apache.spark.internal.Logging import org.apache.spark.rdd.RDD import org.apache.spark.sql.catalyst.InternalRow -import org.apache.spark.sql.catalyst.expressions.{Ascending, Attribute, AttributeSeq, AttributeSet, CodegenObjectFactoryMode, Expression, ExpressionSet, Generator, LeafExpression, Literal, NamedExpression, SortOrder, XXH64} +import org.apache.spark.sql.catalyst.expressions.{Ascending, Attribute, AttributeSeq, AttributeSet, Coalesce, CodegenObjectFactoryMode, Expression, ExpressionSet, Generator, LeafExpression, Literal, NamedExpression, SortOrder, XXH64} import org.apache.spark.sql.catalyst.expressions.aggregate.{AggregateExpression, AggregateMode, Average, CollectList, CollectSet, Final, ImperativeAggregate, Mode, Partial, PartialMerge, Percentile, Sum} import org.apache.spark.sql.catalyst.expressions.codegen.CodegenFallback import org.apache.spark.sql.catalyst.optimizer.{BuildLeft, BuildRight, BuildSide} @@ -3595,9 +3595,18 @@ object CometSortMergeJoinExec extends CometOperatorSerde[SortMergeJoinExec] { // A sort on one integer column uses DataFusion's primitive merge cursor. private def canReduceRightKey(join: SortMergeJoinExec): Boolean = (join.right, join.rightKeys) match { - case (sort: CometSortExec, Seq(key: Attribute)) => - key.dataType.isInstanceOf[IntegralType] && sort.output.size == 1 && - key.semanticEquals(sort.output.head) && readsCometShuffle(sort.child) + case (sort: CometSortExec, Seq(key)) + if key.dataType.isInstanceOf[IntegralType] && readsCometShuffle(sort.child) => + key match { + case a: Attribute => sort.output.size == 1 && a.semanticEquals(sort.output.head) + // These operands have the key's type and are safe to evaluate before reduction. + case Coalesce(values) => + values.forall { + case _: Attribute | _: Literal => true + case _ => false + } + case _ => false + } case _ => false } diff --git a/spark/src/test/scala/org/apache/comet/exec/CometJoinSuite.scala b/spark/src/test/scala/org/apache/comet/exec/CometJoinSuite.scala index b76f52330ac..5b60cd04bec 100644 --- a/spark/src/test/scala/org/apache/comet/exec/CometJoinSuite.scala +++ b/spark/src/test/scala/org/apache/comet/exec/CometJoinSuite.scala @@ -32,7 +32,7 @@ import org.apache.spark.memory.{MemoryConsumer, MemoryMode} import org.apache.spark.sql.{Column, CometTestBase, DataFrame, QueryTest, Row} import org.apache.spark.sql.catalyst.TableIdentifier import org.apache.spark.sql.catalyst.analysis.UnresolvedRelation -import org.apache.spark.sql.catalyst.expressions.{And, Ascending, AttributeReference, BoundReference, Cast, Descending, DynamicPruningExpression, Expression, IsNotNull, Literal, SortOrder} +import org.apache.spark.sql.catalyst.expressions.{And, Ascending, AttributeReference, BoundReference, Cast, Coalesce, Descending, DynamicPruningExpression, Expression, IsNotNull, Literal, SortOrder} import org.apache.spark.sql.catalyst.optimizer.{BuildLeft, BuildRight, BuildSide} import org.apache.spark.sql.catalyst.plans.{Inner, JoinType, LeftOuter, LeftSemi} import org.apache.spark.sql.catalyst.plans.logical.Join @@ -1710,7 +1710,9 @@ class CometJoinSuite extends CometTestBase { assert(!eligible(CoalesceExec(1, shuffle), keys)) assert(!eligible(shuffle, keys, Inner)) assert(!eligible(shuffle, keys, condition = Some(Literal.TrueLiteral))) - assert(!eligible(shuffle, Seq(Cast(keys.head, IntegerType)))) + val cast = Cast(keys.head, IntegerType) + assert(!eligible(shuffle, Seq(cast))) + assert(!eligible(shuffle, Seq(Coalesce(Seq(cast, Literal(0)))))) } } @@ -1791,6 +1793,13 @@ class CometJoinSuite extends CometTestBase { config.key -> "true", CometConf.COMET_SHUFFLE_MODE.key -> "native", SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false") { + val computed = run(s"l._2 = coalesce(r._1, ${wideKey - 1}L)", expected :+ 8) + val reduced = collectFirst(computed.queryExecution.executedPlan) { + case j: CometSortMergeJoinExec => j + }.get + val input = reduced.longMetric("right_key_reduction_input_rows").value + val output = reduced.longMetric("right_key_reduction_output_rows").value + assert(output > 0 && output < input, computed.queryExecution.executedPlan.treeString) for ((condition, ids) <- Seq( ("l._2 <=> r._1", Seq(1, 1, 2, 3, 3, 4, 5, 6, 7)), (s"$equality AND l._3 = r._2", Seq(3, 3, 5, 6, 7)))) { @@ -1806,6 +1815,41 @@ class CometJoinSuite extends CometTestBase { } } + test("right key reduction coalesces nullable integer columns with and without a literal") { + val left = Seq[java.lang.Integer](null, -1, 0, 5, 7, 9).map(Tuple1(_)) + val keys = Seq[(java.lang.Integer, java.lang.Integer)]((5, 9), (null, 7), (null, null)) + val right = Seq.fill(8192)(keys).flatten + withSQLConf( + SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false", + SQLConf.SHUFFLE_PARTITIONS.key -> "1", + CometConf.COMET_BATCH_SIZE.key -> "4096", + CometConf.COMET_SHUFFLE_MODE.key -> "native", + CometConf.COMET_EXEC_SORT_MERGE_JOIN_RIGHT_KEY_REDUCTION_ENABLED.key -> "true") { + withParquetTable(left, "reduction_left") { + withParquetTable(right, "reduction_right") { + for ((keyType, key, expected) <- Seq( + ("INT", "coalesce(r.a, r.b)", Seq(5, 7)), + ("TINYINT", "coalesce(r.a, r.b, -1Y)", Seq(-1, 5, 7)), + ("SMALLINT", "coalesce(r.a, r.b, -1S)", Seq(-1, 5, 7)))) { + val df = sql(s"""SELECT /*+ MERGE(r) */ l._1 FROM reduction_left l + |LEFT SEMI JOIN ( + | SELECT CAST(_1 AS $keyType) AS a, CAST(_2 AS $keyType) AS b + | FROM reduction_right + |) r ON CAST(l._1 AS $keyType) = $key""".stripMargin) + assert(df.collect().map(_.getInt(0)).sorted.toSeq == expected, keyType) + val plan = df.queryExecution.executedPlan + val join = collectFirst(plan) { case j: CometSortMergeJoinExec => j } + .getOrElse(fail(plan.treeString)) + assert(join.rightKeys.head.dataType.sql == keyType) + val input = join.longMetric("right_key_reduction_input_rows").value + val output = join.longMetric("right_key_reduction_output_rows").value + assert(input == right.size && output > 0 && output < input, plan.treeString) + } + } + } + } + } + for (pool <- Seq("fair_unified", "greedy_unified")) { test(s"right key reduction admission with resident JVM execution memory ($pool)") { val rightRows = 32768 diff --git a/spark/src/test/scala/org/apache/spark/sql/benchmark/CometSortMergeJoinBenchmark.scala b/spark/src/test/scala/org/apache/spark/sql/benchmark/CometSortMergeJoinBenchmark.scala index 3049cea1591..6cd6a055bea 100644 --- a/spark/src/test/scala/org/apache/spark/sql/benchmark/CometSortMergeJoinBenchmark.scala +++ b/spark/src/test/scala/org/apache/spark/sql/benchmark/CometSortMergeJoinBenchmark.scala @@ -21,9 +21,9 @@ package org.apache.spark.sql.benchmark import org.apache.spark.SparkConf import org.apache.spark.benchmark.Benchmark -import org.apache.spark.sql.SparkSession -import org.apache.spark.sql.comet.{CometSortExec, CometSortMergeJoinExec} -import org.apache.spark.sql.comet.execution.shuffle.CometShuffleExchangeExec +import org.apache.spark.sql.{Row, SparkSession} +import org.apache.spark.sql.comet.{CometProjectExec, CometSortExec, CometSortMergeJoinExec} +import org.apache.spark.sql.comet.execution.shuffle.{CometNativeShuffle, CometShuffleExchangeExec} import org.apache.spark.sql.internal.SQLConf import org.apache.comet.{CometConf, CometSparkSessionExtensions} @@ -34,14 +34,24 @@ import org.apache.comet.{CometConf, CometSparkSessionExtensions} * {{{ * SPARK_GENERATE_BENCHMARK_FILES=1 make benchmark-org.apache.spark.sql.benchmark.CometSortMergeJoinBenchmark * }}} - * Pass `--many-map-only` to run only the small shuffle-block control. + * Pass `--many-map-only` to run only the small shuffle-block control. Use the following command + * for the coalesced right key cases. + * {{{ + * COMET_BENCHMARK_MASTER='local[4]' BENCH_HEAP=4g \ + * JAVA_TOOL_OPTIONS='-Dspark.memory.offHeap.enabled=true -Dspark.memory.offHeap.size=1g' \ + * make benchmark-org.apache.spark.sql.benchmark.CometSortMergeJoinBenchmark -- --coalesced-keys-only + * }}} + * Each input warms up twice per mode and measures all six permutations of baseline, projection + * only and reduction. Repeat with `--reverse` to reverse the input and round order in a fresh + * JVM. Action time covers SQL planning through collection. Reduction time sums batch + * deduplication attempts across tasks, excluding projection and packing of small output batches. */ object CometSortMergeJoinBenchmark extends CometBenchmarkBase { override def getSparkSession: SparkSession = { val conf = new SparkConf() .setAppName("CometSortMergeJoinBenchmark") - .set("spark.master", "local[5]") + .set("spark.master", sys.env.getOrElse("COMET_BENCHMARK_MASTER", "local[5]")) .setIfMissing("spark.driver.memory", "3g") .setIfMissing("spark.executor.memory", "3g") .set( @@ -69,7 +79,19 @@ object CometSortMergeJoinBenchmark extends CometBenchmarkBase { SQLConf.AUTO_BROADCASTJOIN_THRESHOLD.key -> "-1", SQLConf.ADAPTIVE_AUTO_BROADCASTJOIN_THRESHOLD.key -> "-1") + private val reductionConfigs = cometConfigs ++ Map( + SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false", + CometConf.COMET_ENABLED.key -> "true", + CometConf.COMET_EXEC_ENABLED.key -> "true", + CometConf.COMET_SHUFFLE_ENABLED.key -> "true", + CometConf.COMET_SHUFFLE_MODE.key -> "native") + override def runCometBenchmark(mainArgs: Array[String]): Unit = { + val reverse = mainArgs.contains("--reverse") + if (mainArgs.contains("--coalesced-keys-only")) { + runCoalescedKeyBenchmark(reverse) + return + } runManyMapBenchmark() if (mainArgs.contains("--many-map-only")) { return @@ -139,13 +161,7 @@ object CometSortMergeJoinBenchmark extends CometBenchmarkBase { } runBenchmark("SortMergeJoin - right key reduction") { - val settings = cometConfigs ++ Map( - SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false", - SQLConf.SHUFFLE_PARTITIONS.key -> "1", - CometConf.COMET_ENABLED.key -> "true", - CometConf.COMET_EXEC_ENABLED.key -> "true", - CometConf.COMET_SHUFFLE_ENABLED.key -> "true", - CometConf.COMET_SHUFFLE_MODE.key -> "native") + val settings = reductionConfigs + (SQLConf.SHUFFLE_PARTITIONS.key -> "1") withSQLConf(settings.toSeq: _*) { val flag = CometConf.COMET_EXEC_SORT_MERGE_JOIN_RIGHT_KEY_REDUCTION_ENABLED.key for ((table, distinctKeys, batchSize) <- Seq( @@ -173,6 +189,8 @@ object CometSortMergeJoinBenchmark extends CometBenchmarkBase { } } + runCoalescedKeyBenchmark(reverse) + runBenchmark("SortMergeJoin - right outer") { runExpressionBenchmark( "right outer", @@ -184,6 +202,122 @@ object CometSortMergeJoinBenchmark extends CometBenchmarkBase { } } + private def runCoalescedKeyBenchmark(reverse: Boolean): Unit = { + val settings = reductionConfigs ++ Map( + CometConf.COMET_EXEC_SORT_MERGE_JOIN_RIGHT_KEY_REDUCTION_ENABLED.key -> "false", + // Avoid an inferred isnotnull(coalesce(a, b)) filter before the projection-only shuffle. + SQLConf.CONSTRAINT_PROPAGATION_ENABLED.key -> "false", + SQLConf.EXCHANGE_REUSE_ENABLED.key -> "false", + SQLConf.SHUFFLE_PARTITIONS.key -> "4", + CometConf.COMET_SHUFFLE_DIRECT_READ_ENABLED.key -> "true", + CometConf.COMET_BATCH_SIZE.key -> "8192") + withTempPath { dir => + withTempTable("coalesce_probe", "coalesce_build") { + val probe = s"${dir.getAbsolutePath}/probe" + // Every eighth event misses all four build tables. + spark + .range(0, 131072, 1, 4) + .selectExpr( + "id AS event_id", + "CAST(IF(id % 8 = 7, 8388608 + id, (id * 48271) % 128) AS INT) AS k") + .write + .parquet(probe) + spark.read.parquet(probe).createOrReplaceTempView("coalesce_probe") + val inputs = + for (rows <- Seq(1048576, 8388608); keys <- Seq(128, rows)) yield (rows, keys) + for ((rows, keys) <- (if (reverse) inputs.reverse else inputs)) { + val build = s"${dir.getAbsolutePath}/build-$rows-$keys" + spark + .range(0, rows.toLong, 1, 4) + .selectExpr(s"CAST((id * 48271) % $keys AS INT) AS k", "id % 3 = 0 AS fallback") + .selectExpr("IF(fallback, NULL, k) AS a", "IF(fallback, k, NULL) AS b") + .write + .parquet(build) + spark.read.parquet(build).createOrReplaceTempView("coalesce_build") + withSQLConf(settings.toSeq: _*) { + compareCoalescedKeys(rows, keys, reverse) + } + } + } + } + } + + private def compareCoalescedKeys(rows: Int, keys: Int, reverse: Boolean): Unit = { + val name = s"left semi, $keys distinct coalesced right keys in $rows rows" + val modes = Seq("baseline", "projection", "reduction") + val flag = CometConf.COMET_EXEC_SORT_MERGE_JOIN_RIGHT_KEY_REDUCTION_ENABLED.key + val shuffled = "(SELECT a, b FROM coalesce_build DISTRIBUTE BY coalesce(a, b))" + case class Sample( + mode: String, + actionNs: Long, + reductionNs: Long, + sortRows: Long, + spills: Long) + + def run(mode: String): Sample = { + val enabled = mode == "reduction" + val (table, key) = mode match { + case "projection" => (s"(SELECT coalesce(a, b) AS k FROM $shuffled)", "r.k") + case _ => (shuffled, "coalesce(r.a, r.b)") + } + val query = s"""SELECT /*+ MERGE(r) */ count(*), sum(p.event_id) + |FROM coalesce_probe p LEFT SEMI JOIN $table r ON p.k = $key + |WHERE p.k IS NOT NULL""".stripMargin + spark.conf.set(flag, enabled) + val start = System.nanoTime() + val df = spark.sql(query) + val result = df.collect() + val elapsed = System.nanoTime() - start + require(result.toSeq == Seq(Row(114688L, 7516078080L))) + val plan = df.queryExecution.executedPlan + val join = plan.collectFirst { case j: CometSortMergeJoinExec => j }.get + val sort = join.right.asInstanceOf[CometSortExec] + val input = if (mode == "projection") { + val project = sort.child.asInstanceOf[CometProjectExec] + require(project.output.size == 1) + project.child + } else { + sort.child + } + val shuffle = input.asInstanceOf[CometShuffleExchangeExec] + require(shuffle.shuffleType == CometNativeShuffle && shuffle.output.size == 2) + require(join.nativeOp.getSortMergeJoin.getRightKeyReductionEnabled == enabled) + val sortRows = sort.longMetric("output_rows").value + require(if (enabled && keys < rows) sortRows < rows else sortRows == rows) + if (enabled) { + require(join.longMetric("right_key_reduction_input_rows").value == rows) + require(join.longMetric("right_key_reduction_output_rows").value == sortRows) + if (keys == rows) + require(join.longMetric("right_key_reduction_bypass_rows").value == rows) + } + val reductionNs = if (enabled) join.longMetric("right_key_reduction_time").value else 0L + Sample(mode, elapsed, reductionNs, sortRows, sort.longMetric("spill_count").value) + } + + def medianMs(times: Seq[Long]): Double = { + val sorted = times.sorted + (sorted((sorted.size - 1) / 2) + sorted(sorted.size / 2)) / 2e6 + } + + runBenchmark(name) { + val out = new Benchmark(name, rows.toLong, output = output).out + val rounds = modes.permutations.toList + val order = if (reverse) rounds.reverse else rounds + (order.head ++ order.head.reverse).foreach(run) + val measured = order.flatten.map(run) + for (mode <- modes) { + val samples = measured.filter(_.mode == mode) + val sortRows = samples.map(_.sortRows).distinct.mkString(",") + val spills = samples.map(_.spills).sum + val actions = samples.map(_.actionNs) + val reduction = samples.map(_.reductionNs) + out.println(s"rows=$rows keys=$keys mode=$mode sortRows=$sortRows totalSpills=$spills " + + f"medianActionMs=${medianMs(actions)}%.2f medianReductionMs=${medianMs(reduction)}%.2f " + + s"actionNs=${actions.mkString(",")}") + } + } + } + private def runManyMapBenchmark(): Unit = { val rightRows = 4L * 1024 * 1024 val keys = 8192