grt: add CUGR global_route_debug -st visualization support

src/grt/include/grt/GlobalRouter.h

@@ -269,6 +269,12 @@ class GlobalRouter
   void initDebugFastRoute(std::unique_ptr<AbstractFastRouteRenderer> renderer);
   AbstractFastRouteRenderer* getDebugFastRoute() const;
 
+  void initDebugCUGR(std::unique_ptr<AbstractFastRouteRenderer> renderer);
+  AbstractFastRouteRenderer* getDebugCUGR() const;
+
+  bool hasCUGR() const { return cugr_ != nullptr; }
+  bool hasFastRoute() const { return fastroute_ != nullptr; }
+
   void setDebugNet(const odb::dbNet* net);
   void setDebugSteinerTree(bool steinerTree);
   void setDebugRectilinearSTree(bool rectilinearSTree);

src/grt/src/GlobalRouter-py.i

@@ -14,7 +14,9 @@ using namespace grt;
 
 %ignore grt::GlobalRouter::init;
 %ignore grt::GlobalRouter::initDebugFastRoute;
+%ignore grt::GlobalRouter::initDebugCUGR;
 %ignore grt::GlobalRouter::getDebugFastRoute;
+%ignore grt::GlobalRouter::getDebugCUGR;
 %ignore grt::GlobalRouter::setRenderer;
 %ignore grt::GlobalRouter::initGui;
 

src/grt/src/GlobalRouter.cpp

@@ -5751,33 +5751,83 @@ void GlobalRouter::initDebugFastRoute(
 {
   fastroute_->setDebugOn(std::move(renderer));
 }
+AbstractFastRouteRenderer* GlobalRouter::getDebugCUGR() const
+{
+  if (cugr_) {
+    return cugr_->getDebugRenderer();
+  }
+  return nullptr;
+}
+
+void GlobalRouter::initDebugCUGR(
+    std::unique_ptr<AbstractFastRouteRenderer> renderer)
+{
+  if (cugr_) {
+    cugr_->setDebugOn(std::move(renderer));
+  }
+}
 AbstractFastRouteRenderer* GlobalRouter::getDebugFastRoute() const
 {
   return fastroute_->fastrouteRender();
 }
 void GlobalRouter::setDebugSteinerTree(bool steinerTree)
 {
-  fastroute_->setDebugSteinerTree(steinerTree);
+  if (fastroute_) {
+    fastroute_->setDebugSteinerTree(steinerTree);
+  }
+  if (cugr_) {
+    cugr_->setDebugSteinerTree(steinerTree);
+  }
 }
+
 void GlobalRouter::setDebugNet(const odb::dbNet* net)
 {
-  fastroute_->setDebugNet(net);
+  if (fastroute_) {
+    fastroute_->setDebugNet(net);
+  }
+  if (cugr_) {
+    cugr_->setDebugNet(net);
+  }
 }
+
 void GlobalRouter::setDebugRectilinearSTree(bool rectilinearSTree)
 {
-  fastroute_->setDebugRectilinearSTree(rectilinearSTree);
+  if (fastroute_) {
+    fastroute_->setDebugRectilinearSTree(rectilinearSTree);
+  }
+  if (cugr_) {
+    cugr_->setDebugRectilinearSTree(rectilinearSTree);
+  }
 }
+
 void GlobalRouter::setDebugTree2D(bool tree2D)
 {
-  fastroute_->setDebugTree2D(tree2D);
+  if (fastroute_) {
+    fastroute_->setDebugTree2D(tree2D);
+  }
+  if (cugr_) {
+    cugr_->setDebugTree2D(tree2D);
+  }
 }
+
 void GlobalRouter::setDebugTree3D(bool tree3D)
 {
-  fastroute_->setDebugTree3D(tree3D);
+  if (fastroute_) {
+    fastroute_->setDebugTree3D(tree3D);
+  }
+  if (cugr_) {
+    cugr_->setDebugTree3D(tree3D);
+  }
 }
+
 void GlobalRouter::setSttInputFilename(const char* file_name)
 {
-  fastroute_->setSttInputFilename(file_name);
+  if (fastroute_) {
+    fastroute_->setSttInputFilename(file_name);
+  }
+  if (cugr_) {
+    cugr_->setSttInputFilename(file_name);
+  }
 }
 
 // For rsz::makeBufferedNetGlobalRoute so Pin/Net classes do not have to be

src/grt/src/GlobalRouter.i

@@ -22,7 +22,9 @@ using sta::LibertyPort;
 
 %ignore grt::GlobalRouter::init;
 %ignore grt::GlobalRouter::initDebugFastRoute;
+%ignore grt::GlobalRouter::initDebugCUGR;
 %ignore grt::GlobalRouter::getDebugFastRoute;
+%ignore grt::GlobalRouter::getDebugCUGR;
 %ignore grt::GlobalRouter::setRenderer;
 
 %import <stl.i>
@@ -232,9 +234,18 @@ void set_global_route_debug_cmd(const odb::dbNet *net,
   }
 
   GlobalRouter* global_router = getGlobalRouter();
-  if (global_router->getDebugFastRoute() == nullptr) {
-    global_router->initDebugFastRoute(std::make_unique<FastRouteRenderer>(
-      global_router->db()->getTech()));
+
+  if (global_router->hasFastRoute()) {
+    if (global_router->getDebugFastRoute() == nullptr) {
+      global_router->initDebugFastRoute(
+          std::make_unique<FastRouteRenderer>(global_router->db()->getTech()));
+    }
+  }
+  if (global_router->hasCUGR()) {
+    if (global_router->getDebugCUGR() == nullptr) {
+      global_router->initDebugCUGR(
+          std::make_unique<FastRouteRenderer>(global_router->db()->getTech()));
+    }
   }
   getGlobalRouter()->setDebugNet(net);
   getGlobalRouter()->setDebugSteinerTree(steinerTree);

src/grt/src/cugr/include/CUGR.h

@@ -25,6 +25,7 @@ class dbNetwork;
 
 namespace stt {
 class SteinerTreeBuilder;
+struct Tree;
 }  // namespace stt
 
 namespace utl {
@@ -34,11 +35,18 @@ class CallBackHandler;
 
 namespace grt {
 
+class AbstractFastRouteRenderer;
 class Design;
 class GridGraph;
 class GRNet;
 class BoxT;
 
+struct StTree;
+struct FrNet;
+
+// DebugSetting is defined in fastroute/include/FastRoute.h
+struct DebugSetting;
+
 struct Constants
 {
   double weight_wire_length = 0.5;
@@ -95,6 +103,19 @@ class CUGR
   void updateNet(odb::dbNet* net);
   void routeIncremental();
 
+  // Debug functions 
+  void setDebugOn(std::unique_ptr<AbstractFastRouteRenderer> renderer); 
+  void setDebugNet(const odb::dbNet* net);
+  void setDebugSteinerTree(bool steinerTree);
+  void setDebugRectilinearSTree(bool rectilinearSTree); 
+  void setDebugTree2D(bool tree2D); 
+  void setDebugTree3D(bool tree3D);
+  void setSttInputFilename(const char* file_name);
+  std::string getSttInputFileName();
+  AbstractFastRouteRenderer* getDebugRenderer() const;
+  const odb::dbNet* getDebugNet();
+  bool hasSaveSttInput();
+
  private:
   float calculatePartialSlack();
   float getNetSlack(odb::dbNet* net);
@@ -108,6 +129,12 @@ class CUGR
                  std::vector<std::pair<int, grt::BoxT>>& guides);
   void printStatistics() const;
 
+  void steinerTreeVisualization(const stt::Tree& stree, GRNet* net);
+  void StTreeVisualization(const StTree& stree,
+                           GRNet* net,
+                           bool is3DVisualization);
+  void FrNetInit(GRNet* net, FrNet* frnet);
+
   std::unique_ptr<Design> design_;
   std::unique_ptr<GridGraph> grid_graph_;
   std::vector<int> net_indices_;
@@ -129,6 +156,8 @@ class CUGR
   float critical_nets_percentage_ = 0;
 
   std::vector<int> nets_to_route_;
+
+  std::unique_ptr<DebugSetting> debug_;
 };
 
 }  // namespace grt

src/grt/src/cugr/src/CUGR.cpp

@@ -36,6 +36,10 @@
 #include "utl/CallBackHandler.h"
 #include "utl/Logger.h"
 
+#include "../../fastroute/include/FastRoute.h"
+#include "../../fastroute/include/AbstractFastRouteRenderer.h"
+#include "../../fastroute/include/DataType.h"
+
 using utl::GRT;
 
 namespace grt {
@@ -49,7 +53,8 @@ CUGR::CUGR(odb::dbDatabase* db,
       logger_(log),
       callback_handler_(callback_handler),
       stt_builder_(stt_builder),
-      sta_(sta)
+      sta_(sta),
+      debug_(std::make_unique<DebugSetting>())
 {
 }
 
@@ -159,6 +164,14 @@ void CUGR::patternRoute(std::vector<int>& net_indices)
                                constants_,
                                logger_);
     pattern_route.constructSteinerTree();
+
+    GRNet* net = gr_nets_[net_index].get();
+    if  (debug_->isOn() && debug_->steinerTree && net->getDbNet() == debug_->net && pattern_route.hasSttTree()) {
+
+                steinerTreeVisualization(pattern_route.getSttTree(), net);
+
+        } 
+
     pattern_route.constructRoutingDAG();
     pattern_route.run();
     grid_graph_->addTreeUsage(gr_nets_[net_index]->getRoutingTree());
@@ -262,6 +275,22 @@ void CUGR::route()
     }
   }
 
+  if (debug_->isOn()) {
+    const int x_corner = grid_graph_->getGridline(0, 0);
+    const int y_corner = grid_graph_->getGridline(1, 0);
+    int tile_size = 0;
+    if (grid_graph_->getXSize() > 0) {
+      tile_size = grid_graph_->getGridline(0, 1) - x_corner;
+    }
+    if (tile_size <= 0 && grid_graph_->getYSize() > 0) {
+      tile_size = grid_graph_->getGridline(1, 1) - y_corner;
+    }
+    if (tile_size <= 0) {
+      tile_size = std::max(1, grid_graph_->getM2Pitch());
+    }
+    debug_->renderer->setGridVariables(tile_size, x_corner, y_corner);
+  }
+
   patternRoute(net_indices);
 
   patternRouteWithDetours(net_indices);
@@ -696,5 +725,123 @@ void CUGR::routeIncremental()
 
   printStatistics();
 }
+//debug functions 
+void CUGR::setDebugOn(std::unique_ptr<AbstractFastRouteRenderer> renderer) 
+{
+  debug_->renderer = std::move(renderer);
+}
+void CUGR::setDebugNet(const odb::dbNet* net) 
+{
+  debug_->net = net;
+}
+void CUGR::setDebugSteinerTree(bool steinerTree) 
+{
+  debug_->steinerTree = steinerTree;
+}
+void CUGR::setDebugRectilinearSTree(bool rectilinearSTree)
+{
+  debug_->rectilinearSTree = rectilinearSTree;
+}
+void CUGR::setDebugTree2D(bool tree2D)
+{
+  debug_->tree2D = tree2D;
+}
+void CUGR::setDebugTree3D(bool tree3D)
+{
+  debug_->tree3D = tree3D;
+}
+void CUGR::setSttInputFilename(const char* file_name) 
+{
+  debug_->sttInputFileName = std::string(file_name);
+}
+
+AbstractFastRouteRenderer* CUGR::getDebugRenderer() const
+{
+  if (debug_ && debug_->renderer) {
+    return debug_->renderer.get();
+  }
+  return nullptr;
+}
+std::string CUGR::getSttInputFileName()
+{
+  return debug_->sttInputFileName;
+}
+const odb::dbNet* CUGR::getDebugNet()
+{
+  return debug_->net;
+}
+bool CUGR::hasSaveSttInput()
+{
+  return !debug_->sttInputFileName.empty();
+}
+
+void CUGR::steinerTreeVisualization(const stt::Tree& stree, GRNet* net) 
+{
+  if (!debug_->isOn()) {
+    return;
+  }
+
+  // Create FrNet wrapper as renderer expects FrNet*
+  FrNet frnet;
+  bool is_clock = (net->getDbNet()->getSigType() == odb::dbSigType::CLOCK);
+
+  frnet.reset(net->getDbNet(),
+              is_clock,
+              0,
+              0,
+              constants_.min_routing_layer,
+              grid_graph_->getNumLayers() - 1,
+              0.0,
+              nullptr);
+
+  FrNetInit(net, &frnet);
+
+  debug_->renderer->highlight(&frnet);
+  debug_->renderer->setIs3DVisualization(false);
+  debug_->renderer->setSteinerTree(stree);
+  debug_->renderer->setTreeStructure(grt::TreeStructure::steinerTreeByStt);
+  debug_->renderer->redrawAndPause();
+  debug_->renderer->highlight(nullptr);
+
+}
+
+void CUGR::StTreeVisualization(const StTree& stree, GRNet* net, bool is3DVisualization)
+{
+  if (!debug_->isOn()) {
+    return;
+  }
+
+  // Create FrNet wrapper as renderer expects FrNet*
+  FrNet frnet;
+  bool is_clock = (net->getDbNet()->getSigType() == odb::dbSigType::CLOCK);
+
+  frnet.reset(net->getDbNet(),
+              is_clock,
+              0,
+              0,
+              constants_.min_routing_layer,
+              grid_graph_->getNumLayers() - 1,
+              0.0,
+              nullptr);
+
+  FrNetInit(net, &frnet);
+
+  debug_->renderer->highlight(&frnet);
+  debug_->renderer->setIs3DVisualization(is3DVisualization);
+  debug_->renderer->setStTreeValues(stree);
+  debug_->renderer->setTreeStructure(grt::TreeStructure::steinerTreeByFastroute);
+  debug_->renderer->redrawAndPause();
+  debug_->renderer->highlight(nullptr);
+}
+
+void CUGR::FrNetInit(GRNet* net, FrNet* frnet)
+{
+  for (const auto& pin_aps : net->getPinAccessPoints()) {
+    if (!pin_aps.empty()) {
+      const auto& ap = pin_aps[0];
+      frnet->addPin(ap.x(), ap.y(), ap.getLayerIdx());
+    }
+  }
+}
 
 }  // namespace grt