use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::edge::EdgeKey;
use crate::graph::DataflowGraph;
use crate::ids::{MachineId, NodeId};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MachinePlan {
pub machine: MachineId,
pub spawns: Vec<NodeId>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CrossMachineRoute {
pub producer_machine: MachineId,
pub consumer_machine: MachineId,
pub edge: EdgeKey,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct PlacementPlan {
pub machines: Vec<MachinePlan>,
pub cross_machine_routes: Vec<CrossMachineRoute>,
}
impl PlacementPlan {
#[must_use]
pub fn machine(&self, id: &MachineId) -> Option<&MachinePlan> {
self.machines.iter().find(|plan| &plan.machine == id)
}
#[must_use]
pub fn total_spawns(&self) -> usize {
self.machines.iter().map(|plan| plan.spawns.len()).sum()
}
}
#[must_use]
pub fn plan_placement(graph: &DataflowGraph) -> PlacementPlan {
let mut by_machine: BTreeMap<MachineId, Vec<NodeId>> = BTreeMap::new();
for node in graph.nodes.values() {
let spawns = by_machine.entry(node.machine.clone()).or_default();
if node.spawns_process {
spawns.push(node.id.clone());
}
}
let machines = by_machine
.into_iter()
.map(|(machine, spawns)| MachinePlan { machine, spawns })
.collect();
let mut cross_machine_routes = Vec::new();
for (key, edge) in &graph.edges {
let Some(producer_id) = edge.from.producer_node() else {
continue;
};
let Some(producer) = graph.nodes.get(producer_id) else {
continue;
};
let Some(consumer) = graph.nodes.get(&key.consumer) else {
continue;
};
if producer.machine != consumer.machine {
cross_machine_routes.push(CrossMachineRoute {
producer_machine: producer.machine.clone(),
consumer_machine: consumer.machine.clone(),
edge: key.clone(),
});
}
}
PlacementPlan {
machines,
cross_machine_routes,
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use astrs_manifest::{Deploy, Input, Manifest, Node};
use super::*;
use crate::edge::{Edge, EdgeSource, QueueConfig};
use crate::graph::DataflowGraph;
use crate::ids::PortName;
use crate::node::{GraphNode, InputPort};
fn two_machine_manifest() -> Manifest {
let mut camera = Node::with_path("camera", "./camera");
camera.outputs = vec!["frames".to_string()];
let mut detector = Node::with_path("detector", "./detector");
detector.outputs = vec!["detections".to_string()];
detector
.inputs
.insert("frames".to_string(), Input::from_source("camera/frames"));
let mut planner = Node::with_path("planner", "./planner");
planner.deploy = Some(Deploy {
machine: Some("robot-1".to_string()),
..Deploy::default()
});
planner.inputs.insert(
"detections".to_string(),
Input::from_source("detector/detections"),
);
planner
.inputs
.insert("tick".to_string(), Input::from_source("astrs/timer/hz/50"));
Manifest {
nodes: vec![camera, detector, planner],
..Manifest::default()
}
}
#[test]
fn single_machine_graph_has_one_machine_plan_and_no_routes() {
let mut camera = Node::with_path("camera", "./camera");
camera.outputs = vec!["frames".to_string()];
let mut detector = Node::with_path("detector", "./detector");
detector
.inputs
.insert("frames".to_string(), Input::from_source("camera/frames"));
let manifest = Manifest {
nodes: vec![camera, detector],
..Manifest::default()
};
let (graph, _) = DataflowGraph::from_manifest(&manifest).unwrap();
let plan = plan_placement(&graph);
assert_eq!(plan.machines.len(), 1);
assert_eq!(plan.machines[0].machine, MachineId::CoordinatorLocal);
assert_eq!(plan.total_spawns(), 2);
assert!(plan.cross_machine_routes.is_empty());
}
#[test]
fn two_machine_graph_splits_spawns_and_reports_one_route() {
let manifest = two_machine_manifest();
let (graph, diagnostics) = DataflowGraph::from_manifest(&manifest).unwrap();
assert!(diagnostics.is_empty(), "diagnostics: {diagnostics:?}");
let plan = plan_placement(&graph);
assert_eq!(plan.machines.len(), 2);
let coordinator = plan.machine(&MachineId::CoordinatorLocal).unwrap();
assert_eq!(
coordinator.spawns,
vec![NodeId::new("camera"), NodeId::new("detector")]
);
let robot1 = plan
.machine(&MachineId::Named("robot-1".to_string()))
.unwrap();
assert_eq!(robot1.spawns, vec![NodeId::new("planner")]);
assert_eq!(plan.cross_machine_routes.len(), 1);
let route = &plan.cross_machine_routes[0];
assert_eq!(route.producer_machine, MachineId::CoordinatorLocal);
assert_eq!(
route.consumer_machine,
MachineId::Named("robot-1".to_string())
);
assert_eq!(
route.edge,
EdgeKey::new(NodeId::new("planner"), PortName::new("detections"))
);
}
#[test]
fn machine_with_only_dynamic_nodes_still_appears_with_empty_spawns() {
let manifest = Manifest {
nodes: vec![Node::with_path(
"external",
astrs_manifest::DYNAMIC_PATH_SENTINEL,
)],
..Manifest::default()
};
let (graph, _) = DataflowGraph::from_manifest(&manifest).unwrap();
let plan = plan_placement(&graph);
assert_eq!(plan.machines.len(), 1);
assert!(plan.machines[0].spawns.is_empty());
assert_eq!(plan.total_spawns(), 0);
}
#[test]
fn dangling_producer_reference_is_excluded_not_panicked() {
let mut nodes = BTreeMap::new();
nodes.insert(
NodeId::new("consumer"),
GraphNode {
id: NodeId::new("consumer"),
outputs: BTreeMap::new(),
inputs: [(PortName::new("in"), InputPort { type_urn: None })]
.into_iter()
.collect(),
pattern: None,
machine: MachineId::CoordinatorLocal,
spawns_process: true,
},
);
let mut edges = BTreeMap::new();
edges.insert(
EdgeKey::new(NodeId::new("consumer"), PortName::new("in")),
Edge {
from: EdgeSource::NodeOutput {
node: NodeId::new("ghost"),
output: PortName::new("out"),
},
queue: QueueConfig::default(),
},
);
let graph = DataflowGraph {
nodes,
edges,
strict_types: false,
type_rules: Vec::new(),
};
let plan = plan_placement(&graph);
assert!(plan.cross_machine_routes.is_empty());
}
#[test]
fn placement_plan_default_is_empty() {
let plan = PlacementPlan::default();
assert!(plan.machines.is_empty());
assert!(plan.cross_machine_routes.is_empty());
assert_eq!(plan.total_spawns(), 0);
assert!(plan.machine(&MachineId::CoordinatorLocal).is_none());
}
}