Merge remote-tracking branch 'origin/master' into gui-legend

Author: gadfort

docs/src/scripts/md_roff_compat.py

@@ -166,13 +166,11 @@ def man2_translate(doc, path):
         global_see_also = extract_global_see_also(text)
 
         print(f"{os.path.basename(doc)}")
-        print(
-            f"""Names: {len(func_names)},\
+        print(f"""Names: {len(func_names)},\
         Desc: {len(func_descs)},\
         Syn: {len(func_synopsis)},\
         Options: {len(func_options)},\
-        Args: {len(func_args)}"""
-        )
+        Args: {len(func_args)}""")
         print(f"Global Examples: {'Found' if global_examples else 'None'}")
         print(f"Global See Also: {'Found' if global_see_also else 'None'}")
 

src/dbSta/src/dbSta.cc

@@ -824,10 +824,10 @@ void dbSta::checkSanityDrvrVertexEdges(const Pin* pin) const
     std::set<const sta::Pin*>& loads_;
     const Pin* drvr_;
     const Network* network_;
-    ODBLoadVisitor(std::set<const sta::Pin*>& load,
+    ODBLoadVisitor(std::set<const sta::Pin*>& loads,
                    const Pin* drvr,
                    const Network* network)
-        : loads_(load), drvr_(drvr), network_(network)
+        : loads_(loads), drvr_(drvr), network_(network)
     {
     }
 
@@ -863,8 +863,8 @@ void dbSta::checkSanityDrvrVertexEdges(const Pin* pin) const
           2301,
           "Inconsistent load: ODB has load '{}' for driver '{}', but STA graph "
           "edge is missing.",
-          odb_load ? db_network_->pathName(odb_load) : "NULL",
-          pin ? db_network_->pathName(pin) : "NULL");
+          db_network_->pathName(odb_load),
+          db_network_->pathName(pin));
     }
   }
 }

src/grt/include/grt/GlobalRouter.h

@@ -231,7 +231,7 @@ class GlobalRouter
   void addNetToRoute(odb::dbNet* db_net);
   std::vector<odb::dbNet*> getNetsToRoute();
   void mergeNetsRouting(odb::dbNet* db_net1, odb::dbNet* db_net2);
-  void connectRouting(odb::dbNet* db_net1, odb::dbNet* db_net2);
+  bool connectRouting(odb::dbNet* db_net1, odb::dbNet* db_net2);
   void findBufferPinPostions(Net* net1,
                              Net* net2,
                              odb::Point& pin_pos1,
@@ -329,6 +329,7 @@ class GlobalRouter
   // Net functions
   Net* addNet(odb::dbNet* db_net);
   void removeNet(odb::dbNet* db_net);
+  void updateNetPins(Net* net);
 
   void getCongestionNets(std::set<odb::dbNet*>& congestion_nets);
   void applyAdjustments(int min_routing_layer, int max_routing_layer);
@@ -579,8 +580,8 @@ class GRouteDbCbk : public odb::dbBlockCallBackObj
 
   void inDbNetDestroy(odb::dbNet* net) override;
   void inDbNetCreate(odb::dbNet* net) override;
-  void inDbNetPreMerge(odb::dbNet* preserved_net,
-                       odb::dbNet* removed_net) override;
+  void inDbNetPostMerge(odb::dbNet* preserved_net,
+                        odb::dbNet* removed_net) override;
 
   void inDbITermPreDisconnect(odb::dbITerm* iterm) override;
   void inDbITermPostConnect(odb::dbITerm* iterm) override;

src/grt/src/GlobalRouter.cpp

@@ -335,6 +335,7 @@ void GlobalRouter::globalRoute(bool save_guides,
   } else {
     try {
       if (end_incremental) {
+        fastroute_->setResistanceAware(resistance_aware_);
         updateDirtyRoutes();
         grouter_cbk_->removeOwner();
         delete grouter_cbk_;
@@ -818,11 +819,7 @@ void GlobalRouter::updateDirtyNets(std::vector<Net*>& dirty_nets)
   initRoutingLayers(min_layer, max_layer);
   for (odb::dbNet* db_net : dirty_nets_) {
     Net* net = db_net_map_[db_net];
-    net->destroyPins();
-    // update pin positions
-    makeItermPins(net, db_net, grid_->getGridArea());
-    makeBtermPins(net, db_net, grid_->getGridArea());
-    findPins(net);
+    updateNetPins(net);
     destroyNetWire(net);
     std::string pins_not_covered;
     // compare new positions with last positions & add on vector
@@ -4211,9 +4208,7 @@ Net* GlobalRouter::addNet(odb::dbNet* db_net)
       delete db_net_map_[db_net];
     }
     db_net_map_[db_net] = net;
-    makeItermPins(net, db_net, grid_->getGridArea());
-    makeBtermPins(net, db_net, grid_->getGridArea());
-    findPins(net);
+    updateNetPins(net);
     return net;
   }
   return nullptr;
@@ -4233,6 +4228,15 @@ void GlobalRouter::removeNet(odb::dbNet* db_net)
   routes_.erase(db_net);
 }
 
+void GlobalRouter::updateNetPins(Net* net)
+{
+  odb::dbNet* db_net = net->getDbNet();
+  net->destroyPins();
+  makeItermPins(net, db_net, grid_->getGridArea());
+  makeBtermPins(net, db_net, grid_->getGridArea());
+  findPins(net);
+}
+
 Net* GlobalRouter::getNet(odb::dbNet* db_net)
 {
   return db_net_map_[db_net];
@@ -4908,22 +4912,29 @@ void GlobalRouter::mergeNetsRouting(odb::dbNet* db_net1, odb::dbNet* db_net2)
 {
   Net* net1 = db_net_map_[db_net1];
   Net* net2 = db_net_map_[db_net2];
-  // Do not merge the routing if the survivor net is already dirty.
-  if (!net1->isDirtyNet()) {
-    connectRouting(db_net1, db_net2);
+  // Try to connect the routing of the two nets
+  if (connectRouting(db_net1, db_net2)) {
     net1->setIsMergedNet(true);
     net1->setMergedNet(db_net2);
+    net1->setDirtyNet(false);
     net2->setIsMergedNet(true);
     net2->setMergedNet(db_net1);
+  } else {
+    // After failing to connect the routing, the survivor net still have
+    // uncovered pins and needs to be re-routed
+    net1->setDirtyNet(true);
   }
 }
 
-void GlobalRouter::connectRouting(odb::dbNet* db_net1, odb::dbNet* db_net2)
+bool GlobalRouter::connectRouting(odb::dbNet* db_net1, odb::dbNet* db_net2)
 {
   Net* net1 = db_net_map_[db_net1];
   Net* net2 = db_net_map_[db_net2];
 
-  // find the pin positions in the buffer that connects the two nets
+  // Find the pin positions in the buffer that connects the two nets.
+  // At the time this function is called, the buffer information still preserved
+  // on GRT data structures, allowing us to use it to define the connection
+  // position.
   odb::Point pin_pos1;
   odb::Point pin_pos2;
   findBufferPinPostions(net1, net2, pin_pos1, pin_pos2);
@@ -4940,6 +4951,10 @@ void GlobalRouter::connectRouting(odb::dbNet* db_net1, odb::dbNet* db_net2)
   } else {
     net1_route.insert(net1_route.end(), net2_route.begin(), net2_route.end());
   }
+
+  updateNetPins(net1);
+  std::string dump;
+  return netIsCovered(db_net1, dump);
 }
 
 void GlobalRouter::findBufferPinPostions(Net* net1,
@@ -5805,8 +5820,8 @@ void GRouteDbCbk::inDbNetDestroy(odb::dbNet* net)
   grouter_->removeNet(net);
 }
 
-void GRouteDbCbk::inDbNetPreMerge(odb::dbNet* preserved_net,
-                                  odb::dbNet* removed_net)
+void GRouteDbCbk::inDbNetPostMerge(odb::dbNet* preserved_net,
+                                   odb::dbNet* removed_net)
 {
   grouter_->mergeNetsRouting(preserved_net, removed_net);
 }
@@ -5815,9 +5830,7 @@ void GRouteDbCbk::inDbITermPreDisconnect(odb::dbITerm* iterm)
 {
   odb::dbNet* db_net = iterm->getNet();
   if (db_net != nullptr && !db_net->isSpecial()) {
-    Net* net = grouter_->getNet(db_net);
     grouter_->addDirtyNet(iterm->getNet());
-    net->destroyITermPin(iterm);
   }
 }
 
@@ -5851,9 +5864,7 @@ void GRouteDbCbk::inDbBTermPreDisconnect(odb::dbBTerm* bterm)
 {
   odb::dbNet* db_net = bterm->getNet();
   if (db_net != nullptr && !db_net->isSpecial()) {
-    Net* net = grouter_->getNet(db_net);
     grouter_->addDirtyNet(bterm->getNet());
-    net->destroyBTermPin(bterm);
   }
 }
 

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

@@ -106,6 +106,10 @@ struct FrNet  // A Net is a set of connected MazePoints
   bool isSoftNDR() { return is_soft_ndr_; }
   void setIsResAware(bool res_aware) { is_res_aware_ = res_aware; }
   bool isResAware() { return is_res_aware_; }
+  float getResistance() { return resistance_; }
+  void setResistance(float resistance) { resistance_ = resistance; }
+  int getNetLength() { return net_length_; }
+  void setNetLength(int net_length) { net_length_ = net_length; }
 
  private:
   odb::dbNet* db_net_;
@@ -121,6 +125,8 @@ struct FrNet  // A Net is a set of connected MazePoints
   float slack_;
   bool is_soft_ndr_ = false;
   bool is_res_aware_ = false;
+  float resistance_;
+  int net_length_;
   // Non-null when an NDR has been applied to the net.
   std::unique_ptr<std::vector<int8_t>> edge_cost_per_layer_;
 };
@@ -240,8 +246,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;
+  float res_aware_score;
   int clock;
 };
 

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

@@ -229,6 +229,7 @@ class FastRouteCore
   void setCongestionReportIterStep(int congestion_report_iter_step);
   void setCongestionReportFile(const char* congestion_file_name);
   void setGridMax(int x_max, int y_max);
+  void setDetourPenalty(int penalty);
   void getCongestionNets(std::set<odb::dbNet*>& congestion_nets);
   void computeCongestionInformation();
   std::vector<int> getOriginalResources();
@@ -287,7 +288,7 @@ class FastRouteCore
   double dbuToMicrons(int dbu);
   odb::Rect globalRoutingToBox(const GSegment& route);
   NetRouteMap getRoutes();
-  void updateSlacks(float percentage = 1);
+  void updateSlacks(float percentage = 0.15);
   void preProcessTechLayers();
   odb::dbTechLayer* getTechLayer(int layer, bool is_via);
 
@@ -383,7 +384,8 @@ class FastRouteCore
                          std::vector<int*>& points_heap_3D,
                          multi_array<int, 3>& dist_3D,
                          multi_array<Direction, 3>& directions_3D,
-                         multi_array<int, 3>& corr_edge_3D);
+                         multi_array<int, 3>& corr_edge_3D,
+                         multi_array<int, 3>& path_len_3D);
   void setupHeap3D(int netID,
                    int edgeID,
                    std::vector<int*>& src_heap_3D,
@@ -392,6 +394,7 @@ class FastRouteCore
                    multi_array<int, 3>& corr_edge_3D,
                    multi_array<int, 3>& d1_3D,
                    multi_array<int, 3>& d2_3D,
+                   multi_array<int, 3>& path_len_3D,
                    int regionX1,
                    int regionX2,
                    int regionY1,
@@ -537,16 +540,24 @@ class FastRouteCore
                          multi_array<int, 2>& layer_grid,
                          int net_cost);
   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();
   void checkRoute3D();
   void StNetOrder();
   float CalculatePartialSlack();
   float getNetSlack(odb::dbNet* net);
+
+  // Resistance-aware related functions
+  float getWireResistance(int layer, int length, FrNet* net);
+  float getViaResistance(int from_layer, int to_layer);
+  int getWireCost(int layer, int length, FrNet* net);
+  int getViaCost(int from_layer, int to_layer);
+  float getNetResistance(FrNet* net, bool assume_layer = false);
+  float getResAwareScore(FrNet* net);
+  void updateWorstMetrics(FrNet* net);
+  void resetWorstMetrics();
+
   /**
    * @brief Validates the routing of edges for a specified net.
    *
@@ -622,6 +633,10 @@ class FastRouteCore
   bool enable_resistance_aware_ = false;
   bool is_3d_step_ = false;
   bool is_incremental_grt_ = false;
+  float worst_slack_;
+  float worst_net_resistance_;
+  int worst_net_length_;
+  int worst_fanout_;
   int num_adjust_;
   int v_capacity_;
   int h_capacity_;
@@ -718,6 +733,8 @@ class FastRouteCore
   std::vector<int*> dest_heap_3D_;
   multi_array<int, 3> d1_3D_;
   multi_array<int, 3> d2_3D_;
+  multi_array<int, 3> path_len_3D_;
+  int detour_penalty_;
 };
 
 extern const char* getNetName(odb::dbNet* db_net);

src/grt/src/fastroute/src/FastRoute.cpp

@@ -65,7 +65,8 @@ FastRouteCore::FastRouteCore(odb::dbDatabase* db,
       logger_(log),
       stt_builder_(stt_builder),
       sta_(sta),
-      debug_(new DebugSetting())
+      debug_(new DebugSetting()),
+      detour_penalty_(0)
 {
 }
 
@@ -128,6 +129,8 @@ void FastRouteCore::clear()
 
   vertical_blocked_intervals_.clear();
   horizontal_blocked_intervals_.clear();
+
+  detour_penalty_ = 0;
 }
 
 void FastRouteCore::clearNets()
@@ -203,6 +206,7 @@ void FastRouteCore::setGridsAndLayers(int x, int y, int nLayers)
 
   d1_3D_.resize(boost::extents[num_layers_][y_range_][x_range_]);
   d2_3D_.resize(boost::extents[num_layers_][y_range_][x_range_]);
+  path_len_3D_.resize(boost::extents[num_layers_][y_range_][x_range_]);
 }
 
 void FastRouteCore::addVCapacity(int16_t verticalCapacity, int layer)
@@ -1371,7 +1375,7 @@ NetRouteMap FastRouteCore::run()
   int slope;
   int max_adj;
   int long_edge_len = 40;
-  const int short_edge_len = 12;
+  int short_edge_len = 12;
   const int soft_ndr_overflow_th = 10000;
 
   // call FLUTE to generate RSMT and break the nets into segments (2-pin nets)
@@ -1471,6 +1475,7 @@ NetRouteMap FastRouteCore::run()
   if (debug_->isOn() && debug_->rectilinearSTree) {
     for (const int& netID : net_ids_) {
       if (nets_[netID]->getDbNet() == debug_->net) {
+        logger_->report("RST Tree before overflow iterations");
         StTreeVisualization(sttrees_[netID], nets_[netID], false);
       }
     }
@@ -1759,9 +1764,9 @@ NetRouteMap FastRouteCore::run()
 
   // Debug mode Tree 2D after overflow iterations
   if (debug_->isOn() && debug_->tree2D) {
-    logger_->report("Tree 2D after overflow iterations");
     for (const int& netID : net_ids_) {
       if (nets_[netID]->getDbNet() == debug_->net) {
+        logger_->report("Tree 2D after overflow iterations");
         StTreeVisualization(sttrees_[netID], nets_[netID], false);
       }
     }
@@ -1812,6 +1817,7 @@ NetRouteMap FastRouteCore::run()
     // Increase ripup threshold if res-aware is enabled
     if (enable_resistance_aware_) {
       long_edge_len = BIG_INT;
+      short_edge_len = BIG_INT;
     }
 
     mazeRouteMSMDOrder3D(enlarge_, 0, long_edge_len);
@@ -1843,6 +1849,7 @@ NetRouteMap FastRouteCore::run()
   if (debug_->isOn() && debug_->tree3D) {
     for (const int& netID : net_ids_) {
       if (nets_[netID]->getDbNet() == debug_->net) {
+        logger_->report("Tree 3D after maze route 3D");
         StTreeVisualization(sttrees_[netID], nets_[netID], true);
       }
     }
@@ -2005,6 +2012,11 @@ void FastRouteCore::setGridMax(int x_max, int y_max)
   y_grid_max_ = y_max;
 }
 
+void FastRouteCore::setDetourPenalty(int penalty)
+{
+  detour_penalty_ = penalty;
+}
+
 std::vector<int> FastRouteCore::getOriginalResources()
 {
   std::vector<int> original_resources(num_layers_);

src/grt/src/fastroute/src/RSMT.cpp

@@ -680,6 +680,7 @@ void FastRouteCore::gen_brk_RSMT(const bool congestionDriven,
     }
     if (debug_->isOn() && debug_->steinerTree
         && net->getDbNet() == debug_->net) {
+      logger_->report("Steiner Tree 2D");
       steinerTreeVisualization(rsmt, net);
     }