Split Distributed step in two:

1. ArrowFlightReadExec assignation
2. Stage creation

Author: gabotechs

src/flight_service/do_get.rs

@@ -79,7 +79,3 @@ impl ArrowFlightEndpoint {
         ))))
     }
 }
-
-fn invalid_argument<T>(msg: impl Into<String>) -> Result<T, Status> {
-    Err(Status::invalid_argument(msg))
-}

src/physical_optimizer.rs

@@ -1,9 +1,12 @@
 use std::sync::Arc;
 
+use crate::{plan::PartitionIsolatorExec, ArrowFlightReadExec};
+use datafusion::common::tree_node::TreeNodeRecursion;
+use datafusion::error::DataFusionError;
 use datafusion::{
     common::{
         internal_datafusion_err,
-        tree_node::{Transformed, TreeNode, TreeNodeRewriter},
+        tree_node::{Transformed, TreeNode},
     },
     config::ConfigOptions,
     error::Result,
@@ -14,8 +17,6 @@ use datafusion::{
 };
 use datafusion_proto::physical_plan::PhysicalExtensionCodec;
 
-use crate::{plan::PartitionIsolatorExec, ArrowFlightReadExec};
-
 use super::stage::ExecutionStage;
 
 #[derive(Debug, Default)]
@@ -75,11 +76,9 @@ impl PhysicalOptimizerRule for DistributedPhysicalOptimizerRule {
             displayable(plan.as_ref()).indent(false)
         );
 
-        let mut planner = StagePlanner::new(self.codec.clone(), self.partitions_per_task);
-        plan.rewrite(&mut planner)?;
-        planner
-            .finish()
-            .map(|stage| stage as Arc<dyn ExecutionPlan>)
+        let plan = self.apply_network_boundaries(plan)?;
+        let plan = self.distribute_plan(plan)?;
+        Ok(Arc::new(plan))
     }
 
     fn name(&self) -> &str {
@@ -91,172 +90,93 @@ impl PhysicalOptimizerRule for DistributedPhysicalOptimizerRule {
     }
 }
 
-/// StagePlanner is a TreeNodeRewriter that walks the plan tree and creates
-/// a tree of ExecutionStage nodes that represent discrete stages of execution
-/// can are separated by a data shuffle.
-///
-/// See https://howqueryengineswork.com/13-distributed-query.html for more information
-/// about distributed execution.
-struct StagePlanner {
-    /// used to keep track of the current plan head
-    plan_head: Option<Arc<dyn ExecutionPlan>>,
-    /// Current depth in the plan tree, as we walk the tree
-    depth: usize,
-    /// Input stages collected so far. Each entry is a tuple of (plan tree depth, stage).
-    /// This allows us to keep track of the depth in the plan tree
-    /// where we created the stage.   That way when we create a new
-    /// stage, we can tell if it is a peer to the current input stages or
-    /// should be a parent (if its depth is a smaller number)
-    input_stages: Vec<(usize, ExecutionStage)>,
-    /// current stage number
-    stage_counter: usize,
-    /// Optional codec to assist in serializing and deserializing any custom
-    codec: Option<Arc<dyn PhysicalExtensionCodec>>,
-    /// partitions_per_task is used to determine how many tasks to create for each stage
-    partitions_per_task: Option<usize>,
-}
-
-impl StagePlanner {
-    fn new(
-        codec: Option<Arc<dyn PhysicalExtensionCodec>>,
-        partitions_per_task: Option<usize>,
-    ) -> Self {
-        StagePlanner {
-            plan_head: None,
-            depth: 0,
-            input_stages: vec![],
-            stage_counter: 1,
-            codec,
-            partitions_per_task,
-        }
-    }
-
-    fn finish(mut self) -> Result<Arc<ExecutionStage>> {
-        let stage = if self.input_stages.is_empty() {
-            ExecutionStage::new(
-                self.stage_counter,
-                self.plan_head
-                    .take()
-                    .ok_or_else(|| internal_datafusion_err!("No plan head set"))?,
-                vec![],
-            )
-        } else if self.depth < self.input_stages[0].0 {
-            // There is more plan above the last stage we created, so we need to
-            // create a new stage that includes the last plan head
-            ExecutionStage::new(
-                self.stage_counter,
-                self.plan_head
-                    .take()
-                    .ok_or_else(|| internal_datafusion_err!("No plan head set"))?,
-                self.input_stages
-                    .into_iter()
-                    .map(|(_, stage)| Arc::new(stage))
-                    .collect(),
-            )
-        } else {
-            // We have a plan head, and we are at the same depth as the last stage we created,
-            // so we can just return the last stage
-            self.input_stages.last().unwrap().1.clone()
-        };
-
-        // assign the proper tree depth to each stage in the tree
-        fn assign_tree_depth(stage: &ExecutionStage, depth: usize) {
-            stage
-                .depth
-                .store(depth as u64, std::sync::atomic::Ordering::Relaxed);
-            for input in stage.child_stages_iter() {
-                assign_tree_depth(input, depth + 1);
+impl DistributedPhysicalOptimizerRule {
+    pub fn apply_network_boundaries(
+        &self,
+        plan: Arc<dyn ExecutionPlan>,
+    ) -> Result<Arc<dyn ExecutionPlan>, DataFusionError> {
+        let result = plan.transform_up(|plan| {
+            if plan.as_any().downcast_ref::<RepartitionExec>().is_some() {
+                let child = Arc::clone(plan.children().first().cloned().ok_or(
+                    internal_datafusion_err!("Expected RepartitionExec to have a child"),
+                )?);
+
+                let maybe_isolated_plan = if let Some(ppt) = self.partitions_per_task {
+                    let isolated = Arc::new(PartitionIsolatorExec::new(child, ppt));
+                    plan.with_new_children(vec![isolated])?
+                } else {
+                    plan
+                };
+
+                return Ok(Transformed::yes(Arc::new(
+                    ArrowFlightReadExec::new_single_node(
+                        Arc::clone(&maybe_isolated_plan),
+                        maybe_isolated_plan.output_partitioning().clone(),
+                    ),
+                )));
             }
-        }
-        assign_tree_depth(&stage, 0);
 
-        Ok(Arc::new(stage))
+            Ok(Transformed::no(plan))
+        })?;
+        Ok(result.data)
     }
-}
 
-impl TreeNodeRewriter for StagePlanner {
-    type Node = Arc<dyn ExecutionPlan>;
-
-    fn f_down(&mut self, plan: Self::Node) -> Result<Transformed<Self::Node>> {
-        self.depth += 1;
-        Ok(Transformed::no(plan))
+    pub fn distribute_plan(
+        &self,
+        plan: Arc<dyn ExecutionPlan>,
+    ) -> Result<ExecutionStage, DataFusionError> {
+        self._distribute_plan(plan, &mut 1, 0)
     }
 
-    fn f_up(&mut self, plan: Self::Node) -> Result<Transformed<Self::Node>> {
-        self.depth -= 1;
-
-        // keep track of where we are
-        self.plan_head = Some(plan.clone());
-
-        // determine if we need to shuffle data, and thus create a new stage
-        // at this shuffle boundary
-        if let Some(repartition_exec) = plan.as_any().downcast_ref::<RepartitionExec>() {
-            // time to create a stage here so include all previous seen stages deeper than us as
-            // our input stages
-            let child_stages = self
-                .input_stages
-                .iter()
-                .rev()
-                .take_while(|(depth, _)| *depth > self.depth)
-                .map(|(_, stage)| stage.clone())
-                .collect::<Vec<_>>();
-
-            self.input_stages.retain(|(depth, _)| *depth <= self.depth);
-
-            let maybe_isolated_plan = if let Some(partitions_per_task) = self.partitions_per_task {
-                let child = repartition_exec
-                    .children()
-                    .first()
-                    .ok_or(internal_datafusion_err!(
-                        "RepartitionExec has no children, cannot create PartitionIsolatorExec"
-                    ))?
-                    .clone()
-                    .clone(); // just clone the Arcs
-                let isolated = Arc::new(PartitionIsolatorExec::new(child, partitions_per_task));
-                plan.clone().with_new_children(vec![isolated])?
-            } else {
-                plan.clone()
+    fn _distribute_plan(
+        &self,
+        plan: Arc<dyn ExecutionPlan>,
+        num: &mut usize,
+        depth: usize,
+    ) -> Result<ExecutionStage, DataFusionError> {
+        let mut inputs = vec![];
+        for reader in find_children::<ArrowFlightReadExec>(&plan) {
+            let child = Arc::clone(reader.children().first().cloned().ok_or(
+                internal_datafusion_err!("Expected ArrowFlightExecRead to have a child"),
+            )?);
+            inputs.push(self._distribute_plan(child, num, depth + 1)?);
+        }
+        let mut input_index = 0;
+        let ready = plan.transform_down(|plan| {
+            let Some(node) = plan.as_any().downcast_ref::<ArrowFlightReadExec>() else {
+                return Ok(Transformed::no(plan));
             };
+            let node = Arc::new(node.to_distributed(inputs[input_index].num)?);
+            input_index += 1;
+            Ok(Transformed::new(node, true, TreeNodeRecursion::Stop))
+        })?;
+        let inputs = inputs.into_iter().map(Arc::new).collect();
+        let mut stage = ExecutionStage::new(*num, ready.data, inputs);
+        *num += 1;
+
+        if let Some(partitions_per_task) = self.partitions_per_task {
+            stage = stage.with_maximum_partitions_per_task(partitions_per_task);
+        }
+        if let Some(codec) = self.codec.as_ref() {
+            stage = stage.with_codec(codec.clone());
+        }
+        stage.depth = depth;
 
-            let mut stage = ExecutionStage::new(
-                self.stage_counter,
-                maybe_isolated_plan,
-                child_stages.into_iter().map(Arc::new).collect(),
-            );
-
-            if let Some(partitions_per_task) = self.partitions_per_task {
-                stage = stage.with_maximum_partitions_per_task(partitions_per_task);
-            }
-            if let Some(codec) = self.codec.as_ref() {
-                stage = stage.with_codec(codec.clone());
-            }
+        Ok(stage)
+    }
+}
 
-            self.input_stages.push((self.depth, stage));
-
-            // As we are walking up the plan tree, we've now put what we've encountered so far
-            // into a stage.   We want to replace this plan now with an ArrowFlightReadExec
-            // which will be able to consume from this stage over the network.
-            //
-            // That way as we walk further up the tree and build the next stage, the leaf
-            // node in that plan will be an ArrowFlightReadExec that can read from
-            //
-            // Note that we use the original plans partitioning and schema for ArrowFlightReadExec.
-            // If we divide it up in to tasks, then that parittion will need to be gathered from
-            // among them
-            let name = format!("Stage {:<3}", self.stage_counter);
-            let read = Arc::new(ArrowFlightReadExec::new(
-                plan.output_partitioning().clone(),
-                plan.schema(),
-                self.stage_counter,
-            ));
-
-            self.stage_counter += 1;
-
-            Ok(Transformed::yes(read as Self::Node))
-        } else {
-            Ok(Transformed::no(plan))
-        }
+fn find_children<T: ExecutionPlan + 'static>(
+    plan: &Arc<dyn ExecutionPlan>,
+) -> Vec<&Arc<dyn ExecutionPlan>> {
+    if plan.as_any().is::<T>() {
+        return vec![plan];
+    }
+    let mut result = vec![];
+    for child in plan.children() {
+        result.extend(find_children::<T>(child));
     }
+    result
 }
 
 #[cfg(test)]