Merge pull request #10759 from The-OpenROAD-Project-staging/grt_cugr_res_aware_stage

grt/cugr: implement resistance-aware stage and resistance costs during congestion handling

Author: eder-matheus

src/grt/src/GlobalRouter.cpp

@@ -208,6 +208,15 @@ std::vector<Net*> GlobalRouter::initCUGR(int min_routing_layer,
   reportNetDegree(nets);
 
   cugr_->setCongestionIterations(congestion_iterations_);
+  if (sta_->getDbNetwork()->defaultLibertyLibrary() == nullptr) {
+    if (cugr_->getCriticalNetsPercentage() != 0) {
+      logger_->warn(
+          GRT,
+          309,
+          "Timing is not available, setting critical nets percentage to 0.");
+    }
+    cugr_->setCriticalNetsPercentage(0);
+  }
   cugr_->init(min_routing_layer, max_routing_layer, clock_nets);
   return nets;
 }
@@ -2519,6 +2528,7 @@ void GlobalRouter::setResistanceAware(bool resistance_aware)
 {
   resistance_aware_ = resistance_aware;
   fastroute_->setResistanceAware(resistance_aware);
+  cugr_->setResistanceAware(resistance_aware);
 }
 
 void GlobalRouter::setResAwareNetsPercentage(float percentage)
@@ -2531,8 +2541,7 @@ void GlobalRouter::setResAwareNetsPercentage(float percentage)
                   "nets percentage to 0.");
   }
   if (use_cugr_) {
-    // TODO
-    // cugr_->setResAwareNetsPercentage(percentage);
+    cugr_->setResAwareNetsPercentage(percentage);
   } else {
     fastroute_->setResAwareNetsPercentage(percentage);
   }
@@ -3137,7 +3146,9 @@ void GlobalRouter::saveGuides(const std::vector<odb::dbNet*>& nets)
   int offset_x = grid_origin_.x();
   int offset_y = grid_origin_.y();
 
-  bool guide_is_congested = is_congested_ && !allow_congestion_;
+  // CUGR can produce congested guides that DRT can handle, resulting in
+  // DRC-free final routing.
+  bool guide_is_congested = is_congested_ && !allow_congestion_ && !use_cugr_;
 
   int net_with_jumpers, total_jumpers;
   net_with_jumpers = 0;

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

@@ -59,11 +59,22 @@ struct Constants
 
   double maze_logistic_slope = 0.5;
 
+  // Min net length (routed-tree length, gcells) for res-aware; shorter nets
+  // are skipped.
+  int resistance_min_net_length = 3;
+
+  // Scales the res-aware resistance cost to CUGR's wire-cost magnitude.
+  double resistance_weight = 50.0;
+
   double pin_patch_threshold = 20.0;
   int pin_patch_padding = 1;
   double wire_patch_threshold = 2.0;
   double wire_patch_inflation_rate = 1.2;
 
+  // Cost multiplier for wires that don't fit an edge, biasing vias to climb to
+  // a free layer; 0 disables the gate.
+  double congestion_gate_penalty = 4.0;
+
   bool write_heatmap = false;
 };
 
@@ -93,6 +104,15 @@ class CUGR
   {
     critical_nets_percentage_ = percentage;
   }
+  float getCriticalNetsPercentage() const { return critical_nets_percentage_; }
+  void setResistanceAware(bool resistance_aware)
+  {
+    resistance_aware_ = resistance_aware;
+  }
+  void setResAwareNetsPercentage(float percentage)
+  {
+    res_aware_percentage_ = percentage;
+  }
   void setCongestionIterations(int iterations)
   {
     congestion_iterations_ = iterations;
@@ -114,7 +134,16 @@ class CUGR
   void saveCongestion();
 
  private:
-  float calculatePartialSlack();
+  // Refresh net slacks, re-mark the res-aware/critical set, and demote
+  // non-critical nets so the next stage routes critical nets first.
+  void updateCriticalNets();
+  // Re-extract parasitics and refresh every net's slack from the routing.
+  void updateNetSlacks();
+  // Slack value at the critical_nets_percentage_ percentile of the nets.
+  float criticalSlackThreshold() const;
+  // Push nets with slack above the threshold to the back of the default
+  // ordering by maxing their slack; res-aware nets are exempt.
+  void demoteNonCriticalNets(float slack_th);
   float getNetSlack(odb::dbNet* net);
   void setInitialNetSlacks();
 
@@ -134,6 +163,8 @@ class CUGR
    *          at all).
    */
   std::vector<double> computeNdrCosts(odb::dbNet* db_net) const;
+
+  std::vector<int> computeNdrWidths(odb::dbNet* db_net) const;
   /**
    * @brief Builds the rip-up set of nets touching a congested edge.
    *
@@ -154,11 +185,14 @@ class CUGR
                            double threshold = 1.0);
 
   void patternRoute(std::vector<int>& net_indices);
+  // Re-route the critical nets on real 3D-tree resistance, right after the
+  // neutral first PatternRoute.
+  void patternRouteResAware(std::vector<int>& net_indices);
   void patternRouteWithDetours(std::vector<int>& net_indices);
   void mazeRoute(std::vector<int>& net_indices);
 
   /**
-   * @brief Stage 4 — iterative rip-up and re-route.
+   * @brief Stage 5 — iterative rip-up and re-route.
    *
    * Wraps the maze stage in a loop that sharpens the logistic cost
    * slope each pass (so `PatternRoute` and the maze cost surface
@@ -169,18 +203,18 @@ class CUGR
    * stay idle.
    *
    * Early-exits when the integer overflow metric (`totalOverflow()`)
-   * is already zero, so designs that finished stage 3 clean pay no
+   * is already zero, so designs that finished stage 4 clean pay no
    * cost. Emits `GRT-0117` per iteration and `GRT-0118` if overflow
    * remains when the loop ends.
    *
-   * See `src/grt/doc/01-iterative-rrr.md` for the cost-model audit
-   * and the rationale for the chosen defaults.
-   *
    * @param net_indices Reused scratch buffer (cleared on entry by
    *                    `updateCongestedNets`).
    */
   void iterativeRRR(std::vector<int>& net_indices);
-  void sortNetIndices(std::vector<int>& net_indices) const;
+  // res_aware_order selects the multi-factor res-aware ordering; false uses
+  // the default slack/bbox order.
+  void sortNetIndices(std::vector<int>& net_indices,
+                      bool res_aware_order) const;
   void getGuides(const GRNet* net,
                  std::vector<std::pair<int, grt::BoxT>>& guides);
   void printStatistics() const;
@@ -224,9 +258,28 @@ class CUGR
   int area_of_pin_patches_ = 0;
   int area_of_wire_patches_ = 0;
 
-  float critical_nets_percentage_ = 0;
+  float critical_nets_percentage_ = 10;
   int congestion_iterations_ = 5;
 
+  bool resistance_aware_ = false;
+  // Per-run normalisers for getResAwareScore (default 1 => well-defined).
+  float worst_slack_ = 1.0f;
+  float worst_resistance_ = 1.0f;
+  int worst_fanout_ = 1;
+  int worst_net_length_ = 1;
+
+  // Percent of eligible candidate nets marked res-aware; set via
+  // -res_aware_nets_percentage (FastRoute default).
+  float res_aware_percentage_ = 15.0f;
+
+  // Select the res-aware net set (like FastRoute updateSlacks) and refresh the
+  // worst_* normalisers; no-op unless resistance_aware_.
+  void markResAwareNets();
+
+  // FR-style ordering score (lower routes first): slack/resistance/fanout/
+  // length blend, each normalised by the per-run worst.
+  float getResAwareScore(const GRNet* net) const;
+
   std::vector<int> nets_to_route_;
 };