Merge pull request #9136 from eder-matheus/grt_cugr_connectivity

grt: update access point with CUGR data for parasitics estimation

Author: maliberty

src/grt/include/grt/GlobalRouter.h

@@ -390,6 +390,7 @@ class GlobalRouter
                                 Pin& pin,
                                 odb::Point& pos_on_grid,
                                 bool has_access_points);
+  void updatePinAccessPoints();
   void suggestAdjustment();
   void findFastRoutePins(Net* net,
                          std::vector<RoutePt>& pins_on_grid,

src/grt/src/GlobalRouter.cpp

@@ -45,6 +45,7 @@
 #include "odb/dbSet.h"
 #include "odb/dbShape.h"
 #include "odb/dbTypes.h"
+#include "odb/geom.h"
 #include "odb/geom_boost.h"
 #include "odb/wOrder.h"
 #include "sta/Clock.hh"
@@ -354,6 +355,7 @@ void GlobalRouter::globalRoute(bool save_guides,
           cugr_->init(min_layer, max_layer, clock_nets);
           cugr_->route();
           routes_ = cugr_->getRoutes();
+          updatePinAccessPoints();
         } else {
           if (verbose_) {
             reportResources();
@@ -1183,6 +1185,33 @@ void GlobalRouter::computePinPositionOnGrid(
   pin.setConnectionLayer(pin_position.layer());
 }
 
+void GlobalRouter::updatePinAccessPoints()
+{
+  for (const auto& [db_net, net] : db_net_map_) {
+    std::map<odb::dbITerm*, odb::Point3D> iterm_to_aps;
+    std::map<odb::dbBTerm*, odb::Point3D> bterm_to_aps;
+    cugr_->getITermsAccessPoints(db_net, iterm_to_aps);
+    cugr_->getBTermsAccessPoints(db_net, bterm_to_aps);
+
+    auto updatePinPos = [&](Pin& pin, auto* term, const auto& ap_map) {
+      if (auto it = ap_map.find(term); it != ap_map.end()) {
+        const auto& ap = it->second;
+        pin.setConnectionLayer(ap.z());
+        pin.setOnGridPosition(
+            grid_->getPositionOnGrid(odb::Point(ap.x(), ap.y())));
+      }
+    };
+
+    for (Pin& pin : net->getPins()) {
+      if (pin.isPort()) {
+        updatePinPos(pin, pin.getBTerm(), bterm_to_aps);
+      } else {
+        updatePinPos(pin, pin.getITerm(), iterm_to_aps);
+      }
+    }
+  }
+}
+
 int GlobalRouter::getNetMaxRoutingLayer(const Net* net)
 {
   return net->getSignalType() == odb::dbSigType::CLOCK

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

@@ -1,17 +1,21 @@
 #pragma once
 
 #include <csignal>
+#include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "grt/GRoute.h"
+#include "odb/geom.h"
 
 namespace odb {
 class dbDatabase;
 class dbNet;
+class dbITerm;
+class dbBTerm;
 }  // namespace odb
 
 namespace sta {
@@ -74,6 +78,12 @@ class CUGR
   void write(const std::string& guide_file);
   NetRouteMap getRoutes();
   void updateDbCongestion();
+  void getITermsAccessPoints(
+      odb::dbNet* net,
+      std::map<odb::dbITerm*, odb::Point3D>& access_points);
+  void getBTermsAccessPoints(
+      odb::dbNet* net,
+      std::map<odb::dbBTerm*, odb::Point3D>& access_points);
 
  private:
   void updateOverflowNets(std::vector<int>& netIndices);
@@ -88,6 +98,7 @@ class CUGR
   std::unique_ptr<Design> design_;
   std::unique_ptr<GridGraph> grid_graph_;
   std::vector<std::unique_ptr<GRNet>> gr_nets_;
+  std::map<odb::dbNet*, GRNet*> db_net_map_;
 
   odb::dbDatabase* db_;
   utl::Logger* logger_;

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

@@ -7,6 +7,7 @@
 #include <fstream>
 #include <iostream>
 #include <limits>
+#include <map>
 #include <memory>
 #include <set>
 #include <sstream>
@@ -26,6 +27,7 @@
 #include "geo.h"
 #include "grt/GRoute.h"
 #include "odb/db.h"
+#include "odb/geom.h"
 #include "stt/SteinerTreeBuilder.h"
 #include "utl/Logger.h"
 
@@ -58,6 +60,7 @@ void CUGR::init(const int min_routing_layer,
   gr_nets_.reserve(baseNets.size());
   for (const CUGRNet& baseNet : baseNets) {
     gr_nets_.push_back(std::make_unique<GRNet>(baseNet, grid_graph_.get()));
+    db_net_map_[baseNet.getDbNet()] = gr_nets_.back().get();
   }
 }
 
@@ -498,4 +501,28 @@ void CUGR::updateDbCongestion()
   }
 }
 
+void CUGR::getITermsAccessPoints(
+    odb::dbNet* net,
+    std::map<odb::dbITerm*, odb::Point3D>& access_points)
+{
+  GRNet* gr_net = db_net_map_.at(net);
+  for (const auto& [iterm, ap] : gr_net->getITermAccessPoints()) {
+    const int x = grid_graph_->getGridline(0, ap.point.x());
+    const int y = grid_graph_->getGridline(1, ap.point.y());
+    access_points[iterm] = odb::Point3D(x, y, ap.layers.high() + 1);
+  }
+}
+
+void CUGR::getBTermsAccessPoints(
+    odb::dbNet* net,
+    std::map<odb::dbBTerm*, odb::Point3D>& access_points)
+{
+  GRNet* gr_net = db_net_map_.at(net);
+  for (const auto& [bterm, ap] : gr_net->getBTermAccessPoints()) {
+    const int x = grid_graph_->getGridline(0, ap.point.x());
+    const int y = grid_graph_->getGridline(1, ap.point.y());
+    access_points[bterm] = odb::Point3D(x, y, ap.layers.high() + 1);
+  }
+}
+
 }  // namespace grt

src/grt/src/cugr/src/Design.cpp

@@ -75,15 +75,10 @@ void Design::readLayers()
       odb::dbTrackGrid* track_grid = block_->findTrackGrid(tech_layer);
       if (track_grid != nullptr) {
         layers_.emplace_back(tech_layer, track_grid);
-        if (tech_layer->getRoutingLevel() == 3) {
-          int track_step, track_init, num_tracks;
-          track_grid->getAverageTrackSpacing(
-              track_step, track_init, num_tracks);
-          default_gridline_spacing_ = track_step * 15;
-        }
       }
     }
   }
+  default_gridline_spacing_ = block_->getGCellTileSize();
 }
 
 void Design::readNetlist()

src/grt/src/cugr/src/GRNet.cpp

@@ -9,6 +9,7 @@
 #include "GridGraph.h"
 #include "Netlist.h"
 #include "geo.h"
+#include "odb/db.h"
 
 namespace grt {
 
@@ -19,6 +20,8 @@ GRNet::GRNet(const CUGRNet& baseNet, const GridGraph* gridGraph)
   const int numPins = baseNet.getNumPins();
   pin_access_points_.resize(numPins);
   layer_range_ = baseNet.getLayerRange();
+
+  int pin_index = 0;
   for (CUGRPin& pin : baseNet.getPins()) {
     const std::vector<BoxOnLayer> pinShapes = pin.getPinShapes();
     std::unordered_set<uint64_t> included;
@@ -36,7 +39,15 @@ GRNet::GRNet(const CUGRNet& baseNet, const GridGraph* gridGraph)
         }
       }
     }
+
+    if (pin.isPort()) {
+      pin_index_to_bterm_[pin_index] = pin.getBTerm();
+    } else {
+      pin_index_to_iterm_[pin_index] = pin.getITerm();
+    }
+    pin_index++;
   }
+
   for (const auto& accessPoints : pin_access_points_) {
     for (const auto& point : accessPoints) {
       bounding_box_.Update(point);
@@ -50,4 +61,17 @@ bool GRNet::isInsideLayerRange(int layer_index) const
          && layer_index <= layer_range_.max_layer;
 }
 
+void GRNet::addPreferredAccessPoint(int pin_index, const AccessPoint& ap)
+{
+  if (auto it = pin_index_to_iterm_.find(pin_index);
+      it != pin_index_to_iterm_.end()) {
+    odb::dbITerm* iterm = it->second;
+    iterm_to_ap_[iterm] = ap;
+  } else if (auto it = pin_index_to_bterm_.find(pin_index);
+             it != pin_index_to_bterm_.end()) {
+    odb::dbBTerm* bterm = it->second;
+    bterm_to_ap_[bterm] = ap;
+  }
+}
+
 }  // namespace grt

src/grt/src/cugr/src/GRNet.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ -28,6 +29,7 @@ class GRNet
   {
     return pin_access_points_;
   }
+
   const BoxT& getBoundingBox() const { return bounding_box_; }
   const std::shared_ptr<GRTreeNode>& getRoutingTree() const
   {
@@ -40,11 +42,24 @@ class GRNet
   }
   void clearRoutingTree() { routing_tree_ = nullptr; }
   bool isInsideLayerRange(int layer_index) const;
+  void addPreferredAccessPoint(int pin_index, const AccessPoint& ap);
+  const std::map<odb::dbBTerm*, AccessPoint>& getBTermAccessPoints() const
+  {
+    return bterm_to_ap_;
+  }
+  const std::map<odb::dbITerm*, AccessPoint>& getITermAccessPoints() const
+  {
+    return iterm_to_ap_;
+  }
 
  private:
   int index_;
   odb::dbNet* db_net_;
   std::vector<std::vector<GRPoint>> pin_access_points_;
+  std::map<int, odb::dbITerm*> pin_index_to_iterm_;
+  std::map<int, odb::dbBTerm*> pin_index_to_bterm_;
+  std::map<odb::dbBTerm*, AccessPoint> bterm_to_ap_;
+  std::map<odb::dbITerm*, AccessPoint> iterm_to_ap_;
   BoxT bounding_box_;
   std::shared_ptr<GRTreeNode> routing_tree_;
   LayerRange layer_range_;

src/grt/src/cugr/src/GridGraph.cpp

@@ -366,10 +366,11 @@ CostT GridGraph::getViaCost(const int layer_index, const PointT loc) const
   return cost;
 }
 
-void GridGraph::convertODBtoCUGR(AccessPointSet& selected_access_points,
-                                 odb::dbAccessPoint* ap,
-                                 int x,
-                                 int y) const
+void GridGraph::translateAccessPointsToGrid(
+    odb::dbAccessPoint* ap,
+    int x,
+    int y,
+    AccessPointSet& selected_access_points) const
 {
   const int amount_per_x = design_->getDieRegion().hx() / x_size_;
   const int amount_per_y = design_->getDieRegion().hy() / y_size_;
@@ -405,7 +406,7 @@ bool GridGraph::findODBAccessPoints(
         access_points.insert(
             access_points.begin(), bpin_pas.begin(), bpin_pas.end());
         for (auto ap : bpin_pas) {
-          convertODBtoCUGR(selected_access_points, ap, 0, 0);
+          translateAccessPointsToGrid(ap, 0, 0, selected_access_points);
         }
       }
     }
@@ -420,7 +421,7 @@ bool GridGraph::findODBAccessPoints(
         for (auto ap : pref_access_points) {
           int x, y;
           iterms->getInst()->getLocation(x, y);
-          convertODBtoCUGR(selected_access_points, ap, x, y);
+          translateAccessPointsToGrid(ap, x, y, selected_access_points);
         }
       }
       // Currently ignoring non preferred APs
@@ -432,7 +433,7 @@ bool GridGraph::findODBAccessPoints(
   return true;
 }
 
-AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
+AccessPointSet GridGraph::selectAccessPoints(GRNet* net) const
 {
   AccessPointHash hasher(y_size_);
   AccessPointSet selected_access_points(0, hasher);
@@ -442,6 +443,7 @@ AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
   const PointT netCenter(boundingBox.cx(), boundingBox.cy());
   // Skips calculations if DRT already created APs in ODB
   if (!findODBAccessPoints(net, selected_access_points)) {
+    int pin_idx = 0;
     for (const std::vector<GRPoint>& accessPoints : net->getPinAccessPoints()) {
       std::pair<int, int> bestAccessDist = {0, std::numeric_limits<int>::max()};
       int bestIndex = -1;
@@ -492,6 +494,9 @@ AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
           fixedLayerInterval.Update(point.getLayerIdx());
         }
       }
+
+      net->addPreferredAccessPoint(pin_idx, *it);
+      pin_idx++;
     }
   }
   return selected_access_points;

src/grt/src/cugr/src/GridGraph.h

@@ -107,7 +107,7 @@ class GridGraph
   CostT getUnitViaCost() const { return unit_via_cost_; }
 
   // Misc
-  AccessPointSet selectAccessPoints(const GRNet* net) const;
+  AccessPointSet selectAccessPoints(GRNet* net) const;
 
   // Methods for updating demands
   void commitTree(const std::shared_ptr<GRTreeNode>& tree, bool rip_up = false);
@@ -151,10 +151,11 @@ class GridGraph
   {
     return unit_length_short_costs_[layer_index];
   }
-  void convertODBtoCUGR(AccessPointSet& selected_access_points,
-                        odb::dbAccessPoint* ap,
-                        int x,
-                        int y) const;
+  void translateAccessPointsToGrid(
+      odb::dbAccessPoint* ap,
+      int x,
+      int y,
+      AccessPointSet& selected_access_points) const;
   bool findODBAccessPoints(const GRNet* net,
                            AccessPointSet& selected_access_points) const;
 

src/grt/test/BUILD

@@ -25,6 +25,7 @@ TESTS = [
     "est_rc2",
     "est_rc3",
     "est_rc4",
+    "est_rc_cugr1",
     "estimate_path_resistance",
     "gcd",
     "gcd_cugr",