Merge pull request #8686 from The-OpenROAD-Project-staging/grt-resistance-aware-update

grt: resistance-aware update

Author: maliberty

src/est/src/EstimateParasitics.cpp

@@ -618,6 +618,18 @@ void EstimateParasitics::makeWireParasitic(Net* net,
   double wire_cap = wire_length * wireSignalCapacitance(corner);
   double wire_res = wire_length * wireSignalResistance(corner);
   parasitics->incrCap(n1, wire_cap / 2.0);
+
+  // Reduce resistance if the net has NDR with increased width
+  odb::dbTechNonDefaultRule* ndr
+      = db_network_->staToDb(net)->getNonDefaultRule();
+  if (ndr) {
+    std::vector<odb::dbTechLayerRule*> layer_rules;
+    ndr->getLayerRules(layer_rules);
+    float ndr_ratio = (float) layer_rules.at(0)->getWidth()
+                      / layer_rules.at(0)->getLayer()->getWidth();
+    wire_res /= ndr_ratio;
+  }
+
   parasitics->makeResistor(parasitic, 1, wire_res, n1, n2);
   parasitics->incrCap(n2, wire_cap / 2.0);
 }
@@ -719,6 +731,18 @@ void EstimateParasitics::estimateWireParasiticSteiner(const Pin* drvr_pin,
           double length = dbuToMeters(wire_length_dbu);
           double cap = length * wire_cap;
           double res = length * wire_res;
+
+          // Reduce resistance if the net has NDR with increased width
+          odb::dbTechNonDefaultRule* ndr
+              = db_network_->staToDb(net)->getNonDefaultRule();
+          if (ndr) {
+            std::vector<odb::dbTechLayerRule*> layer_rules;
+            ndr->getLayerRules(layer_rules);
+            float ratio = (float) layer_rules.at(0)->getWidth()
+                          / layer_rules.at(0)->getLayer()->getWidth();
+            res /= ratio;
+          }
+
           // Make pi model for the wire.
           debugPrint(logger_,
                      EST,

src/est/src/EstimateParasiticsCallBack.cpp

@@ -11,7 +11,7 @@ namespace est {
 void EstimateParasiticsCallBack::onEstimateParasiticsRequired()
 {
   estimate_parasitics_->clearParasitics();
-  auto routes = estimate_parasitics_->getGlobalRouter()->getRoutes();
+  auto routes = estimate_parasitics_->getGlobalRouter()->getPartialRoutes();
   for (auto& [db_net, route] : routes) {
     estimate_parasitics_->estimateGlobalRouteParasitics(db_net, route);
   }

src/est/src/MakeWireParasitics.cpp

@@ -215,7 +215,7 @@ void MakeWireParasitics::makeRouteParasitics(
                  segment.final_layer,
                  units->resistanceUnit()->asString(res));
     } else if (segment.init_layer == segment.final_layer) {
-      layerRC(wire_length_dbu, segment.init_layer, corner, res, cap);
+      layerRC(wire_length_dbu, segment.init_layer, corner, net, res, cap);
       debugPrint(logger_,
                  EST,
                  "est_rc",
@@ -297,7 +297,7 @@ void MakeWireParasitics::makeParasiticsToPin(
     int wire_length_dbu
         = abs(pt.getX() - grid_pt.getX()) + abs(pt.getY() - grid_pt.getY());
     float res, cap;
-    layerRC(wire_length_dbu, layer, corner, res, cap);
+    layerRC(wire_length_dbu, layer, corner, net, res, cap);
     sta::Units* units = sta_->units();
     debugPrint(
         logger_,
@@ -404,7 +404,7 @@ void MakeWireParasitics::makePartialParasiticsToPin(
     int wire_length_dbu
         = abs(pt.getX() - grid_pt.getX()) + abs(pt.getY() - grid_pt.getY());
     float res, cap;
-    layerRC(wire_length_dbu, layer, corner, res, cap);
+    layerRC(wire_length_dbu, layer, corner, net, res, cap);
     sta::Units* units = sta_->units();
     debugPrint(
         logger_,
@@ -466,7 +466,7 @@ void MakeWireParasitics::layerRC(int wire_length_dbu,
 
   if (cap_per_meter == 0.0) {
     const float cap_pf_per_micron = layer_width * layer->getCapacitance()
-                                    + 2 * layer->getEdgeCapacitance();
+                                    + (2 * layer->getEdgeCapacitance());
     cap_per_meter = 1E+6 * 1E-12 * cap_pf_per_micron;  // F/meter
   }
 
@@ -475,6 +475,44 @@ void MakeWireParasitics::layerRC(int wire_length_dbu,
   cap = cap_per_meter * wire_length;
 }
 
+void MakeWireParasitics::layerRC(int wire_length_dbu,
+                                 int layer_id,
+                                 sta::Corner* corner,
+                                 odb::dbNet* net,
+                                 // Return values.
+                                 float& res,
+                                 float& cap) const
+{
+  odb::dbTechLayer* layer = tech_->findRoutingLayer(layer_id);
+  double r_per_meter = 0.0;    // ohm/meter
+  double cap_per_meter = 0.0;  // F/meter
+
+  estimate_parasitics_->layerRC(layer, corner, r_per_meter, cap_per_meter);
+
+  const float layer_width = block_->dbuToMicrons(layer->getWidth());
+  if (r_per_meter == 0.0) {
+    const float res_ohm_per_micron = layer->getResistance() / layer_width;
+    r_per_meter = 1E+6 * res_ohm_per_micron;  // ohm/meter
+  }
+
+  if (cap_per_meter == 0.0) {
+    const float cap_pf_per_micron = (layer_width * layer->getCapacitance())
+                                    + (2 * layer->getEdgeCapacitance());
+    cap_per_meter = 1E+6 * 1E-12 * cap_pf_per_micron;  // F/meter
+  }
+
+  // Reduce resistance if the net has NDR with increased width
+  if (net->getNonDefaultRule()) {
+    odb::dbTechLayerRule* rule = net->getNonDefaultRule()->getLayerRule(layer);
+    float ndr_ratio = (float) rule->getWidth() / layer->getWidth();
+    r_per_meter /= ndr_ratio;
+  }
+
+  const float wire_length = dbuToMeters(wire_length_dbu);
+  res = r_per_meter * wire_length;
+  cap = cap_per_meter * wire_length;
+}
+
 double MakeWireParasitics::dbuToMeters(int dbu) const
 {
   return (double) dbu / (tech_->getDbUnitsPerMicron() * 1E+6);

src/est/src/MakeWireParasitics.h

@@ -106,6 +106,13 @@ class MakeWireParasitics
                // Return values.
                float& res,
                float& cap) const;
+  void layerRC(int wire_length_dbu,
+               int layer,
+               sta::Corner* corner,
+               odb::dbNet* net,
+               // Return values.
+               float& res,
+               float& cap) const;
   float getCutLayerRes(odb::dbTechLayer* cut_layer,
                        sta::Corner* corner,
                        int num_cuts = 1) const;

src/grt/include/grt/GlobalRouter.h

@@ -180,6 +180,7 @@ class GlobalRouter
                    bool end_incremental = false);
   void saveCongestion();
   NetRouteMap& getRoutes();
+  NetRouteMap getPartialRoutes();
   Net* getNet(odb::dbNet* db_net);
   int getTileSize() const;
   bool isNonLeafClock(odb::dbNet* db_net);
@@ -480,6 +481,7 @@ class GlobalRouter
   std::vector<RoutingTracks> routing_tracks_;
 
   // Flow variables
+  bool is_incremental;
   float adjustment_;
   int layer_for_guide_dimension_;
   int congestion_iterations_{50};

src/grt/src/GlobalRouter.cpp

@@ -213,6 +213,29 @@ NetRouteMap& GlobalRouter::getRoutes()
   return routes_;
 }
 
+NetRouteMap GlobalRouter::getPartialRoutes()
+{
+  NetRouteMap net_routes;
+  // TODO: still need to fix this during incremental grt
+  if (is_incremental) {
+    for (const auto& [db_net, net] : db_net_map_) {
+      if (routes_[db_net].empty()) {
+        GRoute route;
+        net_routes.insert({db_net, route});
+        fastroute_->getPlanarRoute(db_net, net_routes[db_net]);
+      }
+    }
+  } else {
+    partial_routes_.clear();
+    if (routes_.empty()) {
+      partial_routes_ = fastroute_->getPlanarRoutes();
+      net_routes = partial_routes_;
+    }
+  }
+
+  return net_routes;
+}
+
 bool GlobalRouter::haveRoutes()
 {
   if (!designIsPlaced()) {
@@ -281,6 +304,8 @@ void GlobalRouter::globalRoute(bool save_guides,
                                bool end_incremental)
 {
   bool has_routable_nets = false;
+  is_incremental = (start_incremental || end_incremental);
+
   for (auto net : db_->getChip()->getBlock()->getNets()) {
     if (net->getITerms().size() + net->getBTerms().size() > 1) {
       has_routable_nets = true;

src/grt/src/fastroute/include/DataType.h

@@ -111,6 +111,8 @@ struct FrNet  // A Net is a set of connected MazePoints
   void setIsCritical(bool is_critical) { is_critical_ = is_critical; }
   void setIsSoftNDR(bool is_soft) { is_soft_ndr_ = is_soft; }
   bool isSoftNDR() { return is_soft_ndr_; }
+  void setIsResAware(bool res_aware) { is_res_aware_ = res_aware; }
+  bool isResAware() { return is_res_aware_; }
 
  private:
   odb::dbNet* db_net_;
@@ -125,6 +127,7 @@ struct FrNet  // A Net is a set of connected MazePoints
   int max_layer_;
   float slack_;
   bool is_soft_ndr_ = false;
+  bool is_res_aware_ = false;
   // Non-null when an NDR has been applied to the net.
   std::unique_ptr<std::vector<int8_t>> edge_cost_per_layer_;
 };
@@ -241,6 +244,7 @@ struct OrderNetPin
   int minX;
   float length_per_pin;  // net length over pin count
   int ndr_priority;      // NDR nets are assigned first
+  int res_aware;
   float slack;
 };
 

src/grt/src/fastroute/include/FastRoute.h

@@ -250,6 +250,8 @@ class FastRouteCore
   std::string getSttInputFileName();
   const odb::dbNet* getDebugNet();
   bool hasSaveSttInput();
+
+  // NDR related functions
   void clearNDRnets();
   void computeCongestedNDRnets();
   void updateSoftNDRNetUsage(int net_id, int edge_cost);
@@ -268,6 +270,7 @@ class FastRouteCore
       std::vector<std::pair<odb::Point, bool>>& overflow_pos);
 
   NetRouteMap getPlanarRoutes();
+  void getPlanarRoute(odb::dbNet* db_net, GRoute& route);
 
  private:
   int getEdgeCapacity(FrNet* net, int x1, int y1, EdgeDirection direction);
@@ -277,6 +280,9 @@ class FastRouteCore
   double dbuToMicrons(int dbu);
   odb::Rect globalRoutingToBox(const GSegment& route);
   NetRouteMap getRoutes();
+  void updateSlacks(float percentage = 0.75);
+  void preProcessTechLayers();
+  odb::dbTechLayer* getTechLayer(int layer, bool is_via);
 
   // maze functions
   // Maze-routing in different orders
@@ -525,6 +531,7 @@ class FastRouteCore
   void assignEdge(int netID, int edgeID, bool processDIR);
   int getLayerResistance(int layer, int length, FrNet* net);
   int getViaResistance(int from_layer, int to_layer);
+  bool needResistanceAware(int net_id);
   void recoverEdge(int netID, int edgeID);
   void layerAssignmentV4();
   void netpinOrderInc();
@@ -598,10 +605,13 @@ class FastRouteCore
   int congestion_report_iter_step_;
   std::string congestion_file_name_;
   std::vector<odb::dbTechLayerDir> layer_directions_;
+  std::vector<odb::dbTechLayer*> db_layers_;
   int x_range_;
   int y_range_;
 
+  bool estimate_parasitics_ = false;
   bool resistance_aware_ = false;
+  bool enable_resistance_aware_ = false;
   int num_adjust_;
   int v_capacity_;
   int h_capacity_;