gui: add handling of nets with sinks for route guides

Signed-off-by: Peter Gadfort <peter.gadfort@gmail.com>

Author: gadfort

src/gui/src/dbDescriptors.cpp

@@ -1316,32 +1316,131 @@ void DbNetDescriptor::findPath(NodeMap& graph,
   }
 }
 
-std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(odb::dbNet* net) const
+void DbNetDescriptor::findPath(PointMap& graph,
+                               const odb::Point& source,
+                               const odb::Point& sink,
+                               std::vector<odb::Point>& path) const
+{
+  // find path from source to sink using A*
+  // https://en.wikipedia.org/w/index.php?title=A*_search_algorithm&oldid=1050302256
+
+  auto distance = [](const odb::Point& node0, const odb::Point& node1) -> int {
+    return odb::Point::manhattanDistance(node0, node1);
+  };
+
+  std::map<odb::Point, odb::Point> came_from;
+  std::map<odb::Point, int> g_score;
+  std::map<odb::Point, int> f_score;
+
+  struct DistNode
+  {
+    odb::Point node;
+    int dist;
+
+   public:
+    // used for priority queue
+    bool operator<(const DistNode& other) const { return dist > other.dist; }
+  };
+  std::priority_queue<DistNode> open_set;
+  std::set<odb::Point> open_set_nodes;
+  const int source_sink_dist = distance(source, sink);
+  open_set.push({source, source_sink_dist});
+  open_set_nodes.insert(source);
+
+  for (const auto& [node, nodes] : graph) {
+    g_score[node] = std::numeric_limits<int>::max();
+    f_score[node] = std::numeric_limits<int>::max();
+  }
+  g_score[source] = 0;
+  f_score[source] = source_sink_dist;
+
+  while (!open_set.empty()) {
+    auto current = open_set.top().node;
+
+    open_set.pop();
+    open_set_nodes.erase(current);
+
+    if (current == sink) {
+      // build path
+      while (current != source) {
+        path.emplace_back(current);
+        current = came_from[current];
+      }
+      path.emplace_back(current);
+      return;
+    }
+
+    const int current_g_score = g_score[current];
+    for (const auto& neighbor : graph[current]) {
+      const int possible_g_score
+          = current_g_score + distance(current, neighbor);
+      if (possible_g_score < g_score[neighbor]) {
+        const int new_f_score = possible_g_score + distance(neighbor, sink);
+        came_from[neighbor] = current;
+        g_score[neighbor] = possible_g_score;
+        f_score[neighbor] = new_f_score;
+
+        if (open_set_nodes.find(neighbor) == open_set_nodes.end()) {
+          open_set.push({neighbor, new_f_score});
+          open_set_nodes.insert(neighbor);
+        }
+      }
+    }
+  }
+}
+
+std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(
+    odb::dbNet* net,
+    DbTargets& sources,
+    DbTargets& sinks) const
 {
+  sources.clear();
+  sinks.clear();
+
   auto guides = net->getGuides();
   if (guides.empty()) {
     return {};
   }
 
   std::set<odb::Line> lines;
 
+  struct DbIO
+  {
+    bool is_sink;
+    bool is_source;
+  };
+  std::map<odb::dbObject*, DbIO> io_map;
+
   std::map<odb::dbTechLayer*, std::map<odb::dbObject*, std::set<odb::Rect>>>
       terms;
   for (odb::dbITerm* term : net->getITerms()) {
     if (!term->getInst()->isPlaced()) {
       continue;
     }
+    const auto iotype = term->getIoType();
+    const bool is_sink
+        = iotype == odb::dbIoType::INPUT || iotype == odb::dbIoType::INOUT;
+    const bool is_source
+        = iotype == odb::dbIoType::OUTPUT || iotype == odb::dbIoType::INOUT;
+    io_map[term] = {is_sink, is_source};
     for (const auto& [layer, itermbox] : term->getGeometries()) {
       terms[layer][term].insert(itermbox);
     }
   }
   for (odb::dbBTerm* term : net->getBTerms()) {
+    const auto iotype = term->getIoType();
+    const bool is_sink
+        = iotype == odb::dbIoType::OUTPUT || iotype == odb::dbIoType::INOUT;
+    const bool is_source
+        = iotype == odb::dbIoType::INPUT || iotype == odb::dbIoType::INOUT;
+    io_map[term] = {is_sink, is_source};
+
     for (odb::dbBPin* pin : term->getBPins()) {
       if (!pin->getPlacementStatus().isPlaced()) {
         continue;
       }
       for (odb::dbBox* box : pin->getBoxes()) {
-        terms[box->getTechLayer()][pin].insert(box->getBox());
+        terms[box->getTechLayer()][term].insert(box->getBox());
       }
     }
   }
@@ -1374,7 +1473,9 @@ std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(odb::dbNet* net) const
     if (guide->isConnectedToTerm()) {
       std::vector<odb::Point> anchors = {p0, center, p1};
 
-      auto draw_term_connection = [&anchors, &lines](const odb::Point& term) {
+      auto find_term_connection = [&anchors, &lines, &io_map, &sources, &sinks](
+                                      odb::dbObject* dbterm,
+                                      const odb::Point& term) {
         // draw shortest flywire
         std::stable_sort(anchors.begin(),
                          anchors.end(),
@@ -1383,6 +1484,12 @@ std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(odb::dbNet* net) const
                                   < odb::Point::manhattanDistance(term, pt1);
                          });
         lines.emplace(term, anchors[0]);
+        if (io_map[dbterm].is_sink) {
+          sinks[dbterm].insert(term);
+        }
+        if (io_map[dbterm].is_source) {
+          sources[dbterm].insert(term);
+        }
       };
 
       for (const auto& [obj, objbox] : terms[guide->getLayer()]) {
@@ -1392,16 +1499,16 @@ std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(odb::dbNet* net) const
             candidates.push_back(&termbox);
           }
         }
-        bool drawn = false;
+        bool found = false;
         for (const auto* termbox : candidates) {
           if (termbox->overlaps(box)) {
-            draw_term_connection(termbox->center());
-            drawn = true;
+            find_term_connection(obj, termbox->center());
+            found = true;
             break;
           }
         }
-        if (!drawn && !candidates.empty()) {
-          draw_term_connection(candidates[0]->center());
+        if (!found && !candidates.empty()) {
+          find_term_connection(obj, candidates[0]->center());
         }
       }
     }
@@ -1410,6 +1517,44 @@ std::set<odb::Line> DbNetDescriptor::convertGuidesToLines(odb::dbNet* net) const
   return lines;
 }
 
+void DbNetDescriptor::drawPathSegmentWithGuides(
+    const std::set<odb::Line>& lines,
+    DbTargets& sources,
+    DbTargets& sinks,
+    const odb::dbObject* sink,
+    Painter& painter) const
+{
+  PointMap pointmap;
+  for (const auto& line : lines) {
+    pointmap[line.pt0()].insert(line.pt1());
+    pointmap[line.pt1()].insert(line.pt0());
+  }
+
+  for (const auto& [obj, srcs] : sources) {
+    for (const auto& src_pt : srcs) {
+      for (const auto& dst_pt : sinks[sink]) {
+        std::vector<odb::Point> path;
+        findPath(pointmap, src_pt, dst_pt, path);
+
+        if (!path.empty()) {
+          odb::Point prev_pt = path[0];
+          for (const auto& pt : path) {
+            if (pt == prev_pt) {
+              continue;
+            }
+
+            painter.drawLine(prev_pt, pt);
+            prev_pt = pt;
+          }
+        } else {
+          // unable to find path so just draw a fly-wire
+          painter.drawLine(src_pt, dst_pt);
+        }
+      }
+    }
+  }
+}
+
 // additional_data is used define the related sink for this net
 // this will limit the fly-wires to just those related to that sink
 // if nullptr, all flywires will be drawn
@@ -1514,8 +1659,13 @@ void DbNetDescriptor::highlight(std::any object, Painter& painter) const
         highlight_color.a = 255;
         painter.setPen(highlight_color, true, 4);
 
-        std::set<odb::Line> lines = convertGuidesToLines(net);
+        DbTargets sources;
+        DbTargets sinks;
+        std::set<odb::Line> lines = convertGuidesToLines(net, sources, sinks);
+
         if (sink_object != nullptr) {
+          drawPathSegmentWithGuides(
+              lines, sources, sinks, sink_object, painter);
         } else {
           for (const auto& line : lines) {
             painter.drawLine(line);

src/gui/src/dbDescriptors.h

@@ -178,13 +178,23 @@ class DbNetDescriptor : public BaseDbDescriptor<odb::dbNet>
   using Node = odb::dbWireGraph::Node;
   using NodeList = std::set<const Node*>;
   using NodeMap = std::map<const Node*, NodeList>;
+  using PointList = std::set<odb::Point>;
+  using PointMap = std::map<odb::Point, PointList>;
   using GraphTarget = std::pair<const odb::Rect, const odb::dbTechLayer*>;
+  using DbTargets = std::map<const odb::dbObject*, std::set<odb::Point>>;
 
-  std::set<odb::Line> convertGuidesToLines(odb::dbNet* net) const;
+  std::set<odb::Line> convertGuidesToLines(odb::dbNet* net,
+                                           DbTargets& sources,
+                                           DbTargets& sinks) const;
 
   void drawPathSegmentWithGraph(odb::dbNet* net,
                                 const odb::dbObject* sink,
                                 Painter& painter) const;
+  void drawPathSegmentWithGuides(const std::set<odb::Line>& lines,
+                                 DbTargets& sources,
+                                 DbTargets& sinks,
+                                 const odb::dbObject* sink,
+                                 Painter& painter) const;
   void findSourcesAndSinksInGraph(odb::dbNet* net,
                                   const odb::dbObject* sink,
                                   odb::dbWireGraph* graph,
@@ -198,6 +208,10 @@ class DbNetDescriptor : public BaseDbDescriptor<odb::dbNet>
                 const Node* source,
                 const Node* sink,
                 std::vector<odb::Point>& path) const;
+  void findPath(PointMap& graph,
+                const odb::Point& source,
+                const odb::Point& sink,
+                std::vector<odb::Point>& path) const;
 
   void buildNodeMap(odb::dbWireGraph* graph, NodeMap& node_map) const;