DPL GUI: layout device graph using topological sort

ktf · ktf · commit 5ac37dc9f76e · 2018-10-02T12:22:02.000+02:00
This provides a somewhat nicer layout, by layering data processors
according to the pass in the topological sort they belong to.
diff --git a/Framework/Core/src/FrameworkGUIDevicesGraph.cxx b/Framework/Core/src/FrameworkGUIDevicesGraph.cxx
@@ -15,6 +15,7 @@
 #include "Framework/LogParsingHelpers.h"
 #include "Framework/PaletteHelpers.h"
 #include "FrameworkGUIDeviceInspector.h"
+#include "../src/WorkflowHelpers.h"
 #include "DebugGUI/imgui.h"
 #include <algorithm>
 #include <cmath>
@@ -95,6 +96,59 @@ void displayGrid(bool show_grid, ImVec2 offset, ImDrawList* draw_list)
   }
 }
 
+// Private helper struct for the graph model
+struct Node {
+  int ID;
+  char Name[32];
+  ImVec2 Size;
+  float Value;
+  ImVec4 Color;
+  int InputsCount, OutputsCount;
+
+  Node(int id, const char* name, float value, const ImVec4& color, int inputs_count, int outputs_count)
+  {
+    ID = id;
+    strncpy(Name, name, 31);
+    Name[31] = 0;
+    Value = value;
+    Color = color;
+    InputsCount = inputs_count;
+    OutputsCount = outputs_count;
+  }
+};
+
+// Private helper struct for the layout of the graph
+struct NodePos {
+  ImVec2 pos;
+  static ImVec2 GetInputSlotPos(ImVector<Node> const& infos, ImVector<NodePos> const& positions, int nodeId, int slot_no)
+  {
+    ImVec2 const& pos = positions[nodeId].pos;
+    ImVec2 const& size = infos[nodeId].Size;
+    float inputsCount = infos[nodeId].InputsCount;
+    return ImVec2(pos.x, pos.y + size.y * ((float)slot_no + 1) / (inputsCount + 1));
+  }
+  static ImVec2 GetOutputSlotPos(ImVector<Node> const& infos, ImVector<NodePos> const& positions, int nodeId, int slot_no)
+  {
+    ImVec2 const& pos = positions[nodeId].pos;
+    ImVec2 const& size = infos[nodeId].Size;
+    float outputsCount = infos[nodeId].OutputsCount;
+    return ImVec2(pos.x + size.x, pos.y + size.y * ((float)slot_no + 1) / (outputsCount + 1));
+  }
+};
+
+// Private helper struct for the edges in the graph
+struct NodeLink {
+  int InputIdx, InputSlot, OutputIdx, OutputSlot;
+
+  NodeLink(int input_idx, int input_slot, int output_idx, int output_slot)
+  {
+    InputIdx = input_idx;
+    InputSlot = input_slot;
+    OutputIdx = output_idx;
+    OutputSlot = output_slot;
+  }
+};
+
 void showTopologyNodeGraph(WorkspaceGUIState& state,
                            const std::vector<DeviceInfo>& infos,
                            const std::vector<DeviceSpec>& specs,
@@ -110,58 +164,6 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
 
   ImGui::Begin("Physical topology view", nullptr, ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
 
-  // Dummy
-  struct Node {
-    int ID;
-    char Name[32];
-    ImVec2 Size;
-    float Value;
-    ImVec4 Color;
-    int InputsCount, OutputsCount;
-
-    Node(int id, const char* name, float value, const ImVec4& color, int inputs_count, int outputs_count)
-    {
-      ID = id;
-      strncpy(Name, name, 31);
-      Name[31] = 0;
-      Value = value;
-      Color = color;
-      InputsCount = inputs_count;
-      OutputsCount = outputs_count;
-    }
-
-  };
-
-  struct NodePos {
-    ImVec2 pos;
-    static ImVec2 GetInputSlotPos(ImVector<Node> const& infos, ImVector<NodePos> const& positions, int nodeId, int slot_no)
-    {
-      ImVec2 const& pos = positions[nodeId].pos;
-      ImVec2 const& size = infos[nodeId].Size;
-      float inputsCount = infos[nodeId].InputsCount;
-      return ImVec2(pos.x, pos.y + size.y * ((float)slot_no + 1) / (inputsCount + 1));
-    }
-    static ImVec2 GetOutputSlotPos(ImVector<Node> const& infos, ImVector<NodePos> const& positions, int nodeId, int slot_no)
-    {
-      ImVec2 const& pos = positions[nodeId].pos;
-      ImVec2 const& size = infos[nodeId].Size;
-      float outputsCount = infos[nodeId].OutputsCount;
-      return ImVec2(pos.x + size.x, pos.y + size.y * ((float)slot_no + 1) / (outputsCount + 1));
-    }
-  };
-
-  struct NodeLink {
-    int InputIdx, InputSlot, OutputIdx, OutputSlot;
-
-    NodeLink(int input_idx, int input_slot, int output_idx, int output_slot)
-    {
-      InputIdx = input_idx;
-      InputSlot = input_slot;
-      OutputIdx = output_idx;
-      OutputSlot = output_slot;
-    }
-  };
-
   static ImVector<Node> nodes;
   static ImVector<NodeLink> links;
   static ImVector<NodePos> positions;
@@ -180,18 +182,17 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
     for (int si = 0; si < specs.size(); ++si) {
       int oi = 0;
       for (auto&& output : specs[si].outputChannels) {
-        linkToIndex.insert(std::make_pair(output.name, LinkInfo{si, oi}));
+        linkToIndex.insert(std::make_pair(output.name, LinkInfo{ si, oi }));
         oi += 1;
       }
     }
+    // Do matching between inputs and outputs
     for (int si = 0; si < specs.size(); ++si) {
       auto& spec = specs[si];
-      // FIXME: display nodes using topological sort
       nodeList.push_back(Node(si, spec.id.c_str(), 0.5f,
                               ImColor(255, 100, 100),
                               spec.inputChannels.size(),
                               spec.outputChannels.size()));
-      positions.push_back(NodePos{ImVec2(40 + 120 * si, 50 + (120 * si) % 500)});
       int ii = 0;
       for (auto& input : spec.inputChannels) {
         auto const& outName = input.name;
@@ -204,6 +205,34 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
         ii += 1;
       }
     }
+
+    // ImVector does boudary checks, so I bypass the case there is no
+    // edges.
+    std::vector<TopoIndexInfo> sortedNodes = { { 0, 0 } };
+    if (links.size()) {
+      sortedNodes = WorkflowHelpers::topologicalSort(specs.size(), &(links[0].InputIdx), &(links[0].OutputIdx), sizeof(links[0]), links.size());
+    }
+    /// We resort them again, this time with the added layer information
+    std::sort(sortedNodes.begin(), sortedNodes.end());
+
+    std::vector<int> layerEntries(1024, 0);
+    std::vector<int> layerMax(1024, 0);
+    for (auto& node : sortedNodes) {
+      layerMax[node.layer < 1023 ? node.layer : 1023] += 1;
+    }
+
+    assert(specs.size() == sortedNodes.size());
+    // FIXME: display nodes using topological sort
+    // Update positions
+    for (int si = 0; si < specs.size(); ++si) {
+      auto& node = sortedNodes[si];
+      assert(node.index == si);
+      int xpos = 40 + 240 * node.layer;
+      int ypos = 300 + (600 / (layerMax[node.layer] + 1)) * (layerEntries[node.layer] - layerMax[node.layer] / 2);
+      positions.push_back(NodePos{ ImVec2(xpos, ypos) });
+      layerEntries[node.layer] += 1;
+    }
+
   };
 
   if (!inited) {
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
@@ -24,20 +24,26 @@ namespace o2
 namespace framework
 {
 
-std::vector<size_t>
-WorkflowHelpers::topologicalSort(size_t nodeCount,
-                                 const size_t *edgeIn,
-                                 const size_t *edgeOut,
-                                 size_t stride,
-                                 size_t edgesCount) {
-  using NodeIndex = size_t;
-  using EdgeIndex = size_t;
+std::ostream& operator<<(std::ostream& out, TopoIndexInfo const& info)
+{
+  out << "(" << info.index << ", " << info.layer << ")";
+  return out;
+}
+
+std::vector<TopoIndexInfo>
+  WorkflowHelpers::topologicalSort(size_t nodeCount,
+                                   int const* edgeIn,
+                                   int const* edgeOut,
+                                   size_t byteStride,
+                                   size_t edgesCount)
+{
+  size_t stride = byteStride / sizeof(int);
+  using EdgeIndex = int;
   // Create the index which will be returned.
-  std::vector<NodeIndex> index(nodeCount);
-  for (NodeIndex wi = 0; wi < nodeCount; ++wi) {
-    index[wi] = wi;
+  std::vector<TopoIndexInfo> index(nodeCount);
+  for (int wi = 0; wi < nodeCount; ++wi) {
+    index[wi] = { wi, 0 };
   }
-  // Temporary vector holding vertices to be processed
   std::vector<EdgeIndex> remainingEdgesIndex(edgesCount);
   for (EdgeIndex ei = 0; ei < edgesCount; ++ei) {
     remainingEdgesIndex[ei] = ei;
@@ -47,44 +53,55 @@ WorkflowHelpers::topologicalSort(size_t nodeCount,
   // if the vector has dependencies, false otherwise
   std::vector<bool> nodeDeps(nodeCount, false);
   for (EdgeIndex ei = 0; ei < edgesCount; ++ei) {
-    nodeDeps[*(edgeOut+ei*stride)] = true;
+    nodeDeps[*(edgeOut + ei * stride)] = true;
   }
 
-  std::list<NodeIndex> L;
-  std::vector<NodeIndex> S;
-  std::set<NodeIndex> nextVertex;
-  std::vector<EdgeIndex> nextEdges;
-
-  for (size_t ii = 0, ie = index.size(); ii < ie; ++ii) {
+  // We start with all those which do not have any dependencies
+  // They are layer 0.
+  std::list<TopoIndexInfo> L;
+  for (int ii = 0; ii < index.size(); ++ii) {
     if (nodeDeps[ii] == false) {
-      L.push_back(ii);
+      L.push_back({ ii, 0 });
     }
   }
+
+  // The final result.
+  std::vector<TopoIndexInfo> S;
+  // The set of vertices which can be reached by the current node
+  std::set<TopoIndexInfo> nextVertex;
+  // The set of edges which are not related to the current node.
+  std::vector<EdgeIndex> nextEdges;
   while (!L.empty()) {
     auto node = L.front();
     S.push_back(node);
     L.pop_front();
     nextVertex.clear();
     nextEdges.clear();
 
-    for (EdgeIndex ei = 0, ee = remainingEdgesIndex.size(); ei < ee; ++ei) {
-      if (*(edgeIn+ei*stride) == node) {
-        nextVertex.insert(*(edgeOut+ei*stride));
+    // After this, nextVertex will contain all the vertices
+    // which have the current node as incoming.
+    // nextEdges will contain all the edges which are not related
+    // to the current node.
+    for (auto& ei : remainingEdgesIndex) {
+      if (*(edgeIn + ei * stride) == node.index) {
+        nextVertex.insert({ *(edgeOut + ei * stride), node.layer + 1 });
       } else {
-        nextEdges.push_back(remainingEdgesIndex[ei]);
+        nextEdges.push_back(ei);
       }
     }
     remainingEdgesIndex.swap(nextEdges);
 
-    std::set<NodeIndex> hasPredecessors;
-    for (auto &ei : remainingEdgesIndex) {
-      for (auto &m : nextVertex) {
-        if (m == *(edgeOut+ei*stride)) {
-          hasPredecessors.insert(m);
+    // Of all the vertices which have node as incoming,
+    // check if there is any other incoming node.
+    std::set<TopoIndexInfo> hasPredecessors;
+    for (auto& ei : remainingEdgesIndex) {
+      for (auto& m : nextVertex) {
+        if (m.index == *(edgeOut + ei * stride)) {
+          hasPredecessors.insert({ m.index, m.layer });
         }
       }
     }
-    std::vector<NodeIndex> withPredecessor;
+    std::vector<TopoIndexInfo> withPredecessor;
     std::set_difference(nextVertex.begin(), nextVertex.end(),
                         hasPredecessors.begin(), hasPredecessors.end(),
                         std::back_inserter(withPredecessor));
diff --git a/Framework/Core/src/WorkflowHelpers.h b/Framework/Core/src/WorkflowHelpers.h
@@ -17,6 +17,7 @@
 
 #include <cstddef>
 #include <vector>
+#include <iosfwd>
 
 namespace o2
 {
@@ -102,22 +103,39 @@ struct EdgeAction {
   bool requiresNewChannel = false;
 };
 
+/// Helper struct to keep track of the results of the topological sort
+struct TopoIndexInfo {
+  int index; //!< the index in the actual storage of the nodes to be sorted topologically
+  int layer; //!< the associated layer in the sorting procedure
+  bool operator<(TopoIndexInfo const& rhs) const
+  {
+    return index < rhs.index;
+  }
+  bool operator==(TopoIndexInfo const& rhs) const
+  {
+    return index == rhs.index;
+  }
+
+  friend std::ostream& operator<<(std::ostream& out, TopoIndexInfo const& info);
+};
+
 /// A set of internal helper classes to manipulate a Workflow
 struct WorkflowHelpers {
   /// Topological sort for a graph of @a nodeCount nodes.
-  ///  
+  ///
   /// @a edgeIn pointer to the index of the input node for the first edge
   /// @a edgeOut pointer to the index of the out node for the first edge
-  /// @a stride distance (in size_t) between the first and the second element the array
+  /// @a stride distance (in bytes) between the first and the second element the array
   ///    holding the edges
   /// @return an index vector for the @a nodeCount nodes, where the order is a topological
-  /// sort according to the information provided in edges.
-  static std::vector<size_t> topologicalSort(size_t nodeCount,
-                                             const size_t *edgeIn,
-                                             const size_t *edgeOut,
-                                             size_t stride,
-                                             size_t edgesCount
-      );
+  /// sort according to the information provided in edges. The first element of
+  /// the pair is the index in the nodes array, the second one is the layer in the topological
+  /// sort.
+  static std::vector<TopoIndexInfo> topologicalSort(size_t nodeCount,
+                                                    int const* edgeIn,
+                                                    int const* edgeOut,
+                                                    size_t stride,
+                                                    size_t edgesCount);
 
   // Helper method to verify that a given workflow is actually valid e.g. that
   // it contains no empty labels.
diff --git a/Framework/Core/test/test_WorkflowHelpers.cxx b/Framework/Core/test/test_WorkflowHelpers.cxx
