Add from_v1.

Author: elliottslaughter

lib/pcg/include/pcg/file_format/v1/graphs/v1_labelled_kwarg_dataflow_graph.h

@@ -6,7 +6,14 @@
 #include "utils/bidict/algorithms/bidict_from_enumerating.h"
 #include "utils/containers/map_values.h"
 #include "utils/containers/transform.h"
+#include "utils/graph/digraph/algorithms/get_topological_ordering.h"
+#include "utils/graph/digraph/digraph.h"
+#include "utils/graph/digraph/directed_edge.dtg.h"
+#include "utils/graph/instances/adjacency_digraph.h"
+#include "utils/graph/instances/unordered_set_labelled_open_kwarg_dataflow_graph.h"
 #include "utils/graph/kwarg_dataflow_graph/algorithms/get_outgoing_kwarg_dataflow_outputs_for_node.h"
+#include "utils/graph/kwarg_dataflow_graph/kwarg_node_added_result.dtg.h"
+#include "utils/graph/labelled_kwarg_dataflow_graph/labelled_kwarg_dataflow_graph.h"
 #include "utils/graph/labelled_kwarg_dataflow_graph/labelled_kwarg_dataflow_graph_view.h"
 #include "utils/graph/node/algorithms.h"
 
@@ -50,6 +57,56 @@ V1LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> to_v1(
   return to_v1_including_node_numbering(g).first;
 }
 
+template <typename NodeLabel, typename OutputLabel, typename SlotName>
+LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> from_v1(
+    V1LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> const &v1) {
+  // Build incoming-edge map
+  std::unordered_map<nonnegative_int, std::vector<V1GraphEdge<SlotName>>>
+      incoming;
+  for (nonnegative_int const &n : v1.graph.nodes) {
+    incoming[n] = {};
+  }
+  for (V1GraphEdge<SlotName> const &e : v1.graph.edges) {
+    incoming[e.dstNode].push_back(e);
+  }
+
+  // Build a DiGraph with V1 indices as Node raw_uids to get topological order
+  DiGraph dg = DiGraph::create<AdjacencyDiGraph>();
+  for (nonnegative_int const &n : v1.graph.nodes) {
+    dg.add_node_unsafe(Node{static_cast<size_t>(n.unwrap_nonnegative())});
+  }
+  for (V1GraphEdge<SlotName> const &e : v1.graph.edges) {
+    dg.add_edge(DirectedEdge{
+        Node{static_cast<size_t>(e.srcNode.unwrap_nonnegative())},
+        Node{static_cast<size_t>(e.dstNode.unwrap_nonnegative())}});
+  }
+
+  auto g = LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName>::
+      template create<UnorderedSetLabelledOpenKwargDataflowGraph<NodeLabel,
+                                                                 OutputLabel,
+                                                                 int,
+                                                                 SlotName>>();
+
+  std::unordered_map<nonnegative_int, Node> node_map;
+  for (Node const &topo_node : get_topological_ordering(dg)) {
+    nonnegative_int v1_idx{static_cast<size_t>(topo_node.raw_uid)};
+
+    std::unordered_map<SlotName, KwargDataflowOutput<SlotName>> inputs;
+    for (V1GraphEdge<SlotName> const &e : incoming.at(v1_idx)) {
+      inputs.emplace(
+          e.dstSlot,
+          KwargDataflowOutput<SlotName>{node_map.at(e.srcNode), e.srcSlot});
+    }
+
+    KwargNodeAddedResult<SlotName> result = g.add_node(
+        v1.node_labels.at(v1_idx), inputs, v1.output_labels.at(v1_idx));
+
+    node_map.emplace(v1_idx, result.node);
+  }
+
+  return g;
+}
+
 } // namespace FlexFlow
 
 #endif

lib/pcg/include/pcg/file_format/v1/v1_computation_graph.h

@@ -8,6 +8,7 @@
 namespace FlexFlow {
 
 V1ComputationGraph to_v1(ComputationGraph const &);
+ComputationGraph from_v1(V1ComputationGraph const &);
 
 std::pair<V1ComputationGraph, bidict<nonnegative_int, layer_guid_t>>
     to_v1_including_node_numbering(ComputationGraph const &);

lib/pcg/include/pcg/file_format/v1/v1_mapped_operator_task_group.h

@@ -7,6 +7,7 @@
 namespace FlexFlow {
 
 V1MappedOperatorTaskGroup to_v1(MappedOperatorTaskGroup const &);
+MappedOperatorTaskGroup from_v1(V1MappedOperatorTaskGroup const &);
 
 } // namespace FlexFlow
 

lib/pcg/include/pcg/file_format/v1/v1_mapped_parallel_computation_graph.h

@@ -7,6 +7,8 @@
 namespace FlexFlow {
 
 V1MappedParallelComputationGraph to_v1(MappedParallelComputationGraph const &);
+MappedParallelComputationGraph
+    from_v1(V1MappedParallelComputationGraph const &);
 
 } // namespace FlexFlow
 

lib/pcg/include/pcg/file_format/v1/v1_parallel_computation_graph.h

@@ -7,6 +7,7 @@
 namespace FlexFlow {
 
 V1ParallelComputationGraph to_v1(ParallelComputationGraph const &);
+ParallelComputationGraph from_v1(V1ParallelComputationGraph const &);
 
 } // namespace FlexFlow
 

lib/pcg/src/pcg/file_format/v1/graphs/v1_labelled_kwarg_dataflow_graph.cc

@@ -18,4 +18,7 @@ template std::pair<
 template V1LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> to_v1(
     LabelledKwargDataflowGraphView<NodeLabel, OutputLabel, SlotName> const &);
 
+template LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> from_v1(
+    V1LabelledKwargDataflowGraph<NodeLabel, OutputLabel, SlotName> const &);
+
 } // namespace FlexFlow

lib/pcg/src/pcg/file_format/v1/v1_computation_graph.cc

@@ -10,6 +10,12 @@ V1ComputationGraph to_v1(ComputationGraph const &g) {
   };
 }
 
+ComputationGraph from_v1(V1ComputationGraph const &v1) {
+  return ComputationGraph{
+      from_v1(v1.raw_graph),
+  };
+}
+
 std::pair<V1ComputationGraph, bidict<nonnegative_int, layer_guid_t>>
     to_v1_including_node_numbering(ComputationGraph const &cg) {
   std::pair<

lib/pcg/src/pcg/file_format/v1/v1_mapped_operator_task_group.cc

@@ -6,4 +6,8 @@ V1MappedOperatorTaskGroup to_v1(MappedOperatorTaskGroup const &g) {
   return V1MappedOperatorTaskGroup{g.get_shard_bindings()};
 }
 
+MappedOperatorTaskGroup from_v1(V1MappedOperatorTaskGroup const &v1) {
+  return MappedOperatorTaskGroup{v1.shard_bindings};
+}
+
 } // namespace FlexFlow

lib/pcg/src/pcg/file_format/v1/v1_mapped_parallel_computation_graph.cc

@@ -14,4 +14,13 @@ V1MappedParallelComputationGraph
   };
 }
 
+MappedParallelComputationGraph
+    from_v1(V1MappedParallelComputationGraph const &v1) {
+  return MappedParallelComputationGraph{
+      from_v1(v1.pcg),
+      map_values(v1.mapped_tasks,
+                 [](V1MappedOperatorTaskGroup const &g) { return from_v1(g); }),
+  };
+}
+
 } // namespace FlexFlow

lib/pcg/src/pcg/file_format/v1/v1_parallel_computation_graph.cc

@@ -10,4 +10,10 @@ V1ParallelComputationGraph to_v1(ParallelComputationGraph const &g) {
   };
 }
 
+ParallelComputationGraph from_v1(V1ParallelComputationGraph const &v1) {
+  return ParallelComputationGraph{
+      from_v1(v1.raw_graph),
+  };
+}
+
 } // namespace FlexFlow