Grt: Jumper insertion for repair antenna violations

src/ant/include/ant/AntennaChecker.hh

@@ -70,6 +70,9 @@ struct NodeInfo
   double diff_CAR;
   double diff_CSR;
 
+  double ratio_PAR;
+  double ratio_PSR;
+
   std::vector<odb::dbITerm*> iterms;
 
   NodeInfo& operator+=(const NodeInfo& a)
@@ -98,6 +101,9 @@ struct NodeInfo
     CSR = 0.0;
     diff_CAR = 0.0;
     diff_CSR = 0.0;
+
+    ratio_PAR = 1.0;
+    ratio_PSR = 1.0;
   }
 };
 
@@ -123,6 +129,7 @@ struct Violation
   int routing_level;
   std::vector<odb::dbITerm*> gates;
   int diode_count_per_gate;
+  double ratio;
 };
 
 using LayerToNodeInfo = std::map<odb::dbTechLayer*, NodeInfo>;
@@ -186,7 +193,7 @@ class AntennaChecker
   void calculateCAR(GateToLayerToNodeInfo& gate_info);
   bool checkRatioViolations(odb::dbNet* db_net,
                             odb::dbTechLayer* layer,
-                            const NodeInfo& node_info,
+                            NodeInfo& node_info,
                             float ratio_margin,
                             bool verbose,
                             bool report);
@@ -204,13 +211,13 @@ class AntennaChecker
   void calculateWirePar(odb::dbTechLayer* tech_layer, NodeInfo& info);
   bool checkPAR(odb::dbNet* db_net,
                 odb::dbTechLayer* tech_layer,
-                const NodeInfo& info,
+                NodeInfo& info,
                 float ratio_margin,
                 bool verbose,
                 bool report);
   bool checkPSR(odb::dbNet* db_net,
                 odb::dbTechLayer* tech_layer,
-                const NodeInfo& info,
+                NodeInfo& info,
                 float ratio_margin,
                 bool verbose,
                 bool report);

src/ant/src/AntennaChecker.cc

@@ -524,7 +524,7 @@ void AntennaChecker::calculateCAR(GateToLayerToNodeInfo& gate_info)
 
 bool AntennaChecker::checkPAR(odb::dbNet* db_net,
                               odb::dbTechLayer* tech_layer,
-                              const NodeInfo& info,
+                              NodeInfo& info,
                               const float ratio_margin,
                               bool verbose,
                               bool report)
@@ -544,6 +544,7 @@ bool AntennaChecker::checkPAR(odb::dbNet* db_net,
   // check PAR or diff_PAR
   if (PAR_ratio != 0) {
     violation = info.PAR > PAR_ratio;
+    info.ratio_PAR = std::max(info.ratio_PAR, info.PAR / PAR_ratio);
     if (report) {
       std::string par_report = fmt::format(
           "      Partial area ratio: {:7.2f}\n      Required ratio: "
@@ -557,6 +558,8 @@ bool AntennaChecker::checkPAR(odb::dbNet* db_net,
   } else {
     if (diff_PAR_PWL_ratio != 0) {
       violation = info.diff_PAR > diff_PAR_PWL_ratio;
+      info.ratio_PAR
+          = std::max(info.ratio_PAR, info.diff_PAR / diff_PAR_PWL_ratio);
     }
     if (report) {
       std::string diff_par_report = fmt::format(
@@ -574,7 +577,7 @@ bool AntennaChecker::checkPAR(odb::dbNet* db_net,
 
 bool AntennaChecker::checkPSR(odb::dbNet* db_net,
                               odb::dbTechLayer* tech_layer,
-                              const NodeInfo& info,
+                              NodeInfo& info,
                               const float ratio_margin,
                               bool verbose,
                               bool report)
@@ -595,6 +598,7 @@ bool AntennaChecker::checkPSR(odb::dbNet* db_net,
   // check PSR or diff_PSR
   if (PSR_ratio != 0) {
     violation = info.PSR > PSR_ratio;
+    info.ratio_PSR = std::max(info.ratio_PSR, info.PSR / PSR_ratio);
     if (report) {
       std::string psr_report = fmt::format(
           "      Partial area ratio: {:7.2f}\n      Required ratio: "
@@ -608,6 +612,8 @@ bool AntennaChecker::checkPSR(odb::dbNet* db_net,
   } else {
     if (diff_PSR_PWL_ratio != 0) {
       violation = info.diff_PSR > diff_PSR_PWL_ratio;
+      info.ratio_PSR
+          = std::max(info.ratio_PSR, info.diff_PSR / diff_PSR_PWL_ratio);
     }
     if (report) {
       std::string diff_psr_report = fmt::format(
@@ -719,7 +725,7 @@ bool AntennaChecker::checkCSR(odb::dbNet* db_net,
 
 bool AntennaChecker::checkRatioViolations(odb::dbNet* db_net,
                                           odb::dbTechLayer* layer,
-                                          const NodeInfo& node_info,
+                                          NodeInfo& node_info,
                                           const float ratio_margin,
                                           bool verbose,
                                           bool report)
@@ -771,7 +777,7 @@ int AntennaChecker::checkGates(odb::dbNet* db_net,
   std::string net_name = fmt::format("Net: {}", db_net->getConstName());
   net_to_report_.at(db_net).report += net_name + "\n";
 
-  for (const auto& [node, layer_to_node] : gate_info) {
+  for (auto& [node, layer_to_node] : gate_info) {
     bool pin_has_violation = false;
 
     odb::dbMTerm* mterm = node->getMTerm();
@@ -781,7 +787,7 @@ int AntennaChecker::checkGates(odb::dbNet* db_net,
                                        mterm->getMaster()->getConstName());
     net_to_report_.at(db_net).report += pin_name + "\n";
 
-    for (const auto& [layer, node_info] : layer_to_node) {
+    for (auto& [layer, node_info] : layer_to_node) {
       if (layer->hasDefaultAntennaRule()) {
         std::string layer_name
             = fmt::format("    Layer: {}", layer->getConstName());
@@ -833,6 +839,11 @@ int AntennaChecker::checkGates(odb::dbNet* db_net,
                                         false,
                                         false);
           bool violated = par_violation || psr_violation;
+          double ratio = 1.0;
+          if (violated) {
+            ratio
+                = std::max(violation_info.ratio_PAR, violation_info.ratio_PSR);
+          }
           // while it has violation, increase iterm_diff_area
           if (diode_mterm) {
             while (par_violation || psr_violation) {
@@ -874,7 +885,8 @@ int AntennaChecker::checkGates(odb::dbNet* db_net,
           if (violated) {
             antenna_violations.push_back({layer->getRoutingLevel(),
                                           gates_for_diode_insertion,
-                                          diode_count_per_gate});
+                                          diode_count_per_gate,
+                                          ratio});
           }
 
           bool car_violation
@@ -897,7 +909,8 @@ int AntennaChecker::checkGates(odb::dbNet* db_net,
             }
             antenna_violations.push_back({layer->getRoutingLevel(),
                                           std::move(gates_for_diode_insertion),
-                                          1});
+                                          1,
+                                          1.0});
           }
         }
       }

src/grt/include/grt/GRoute.h

@@ -57,7 +57,7 @@ struct GSegment
   GSegment() = default;
   GSegment(int x0, int y0, int l0, int x1, int y1, int l1);
   bool isVia() const { return (init_x == final_x && init_y == final_y); }
-  int length()
+  int length() const
   {
     return std::abs(init_x - final_x) + std::abs(init_y - final_y);
   }

src/grt/include/grt/GlobalRouter.h

@@ -219,6 +219,10 @@ class GlobalRouter : public ant::GlobalRouteSource
                       int iterations,
                       float ratio_margin,
                       int num_threads = 1);
+  bool hasCapacity(bool is_horizontal,
+                   const int& pos_x,
+                   const int& pos_y,
+                   const int& layer_level);
 
   // Incremental global routing functions.
   // See class IncrementalGRoute.

src/grt/src/GlobalRouter.cpp

@@ -381,6 +381,19 @@ void GlobalRouter::repairAntennas(odb::dbMTerm* diode_mterm,
     nets_to_repair.push_back(db_net);
   }
 
+  violations = repair_antennas_->checkAntennaViolations(routes_,
+                                                        nets_to_repair,
+                                                        max_routing_layer_,
+                                                        diode_mterm,
+                                                        ratio_margin,
+                                                        num_threads);
+
+  if (violations) {
+    repair_antennas_->jumperInsertion(
+        routes_, grid_->getTileSize(), max_routing_layer_);
+    repair_antennas_->clearViolations();
+  }
+
   while (violations && itr < iterations) {
     if (verbose_) {
       logger_->info(GRT, 6, "Repairing antennas, iteration {}.", itr + 1);
@@ -1566,6 +1579,24 @@ void GlobalRouter::computeRegionAdjustments(const odb::Rect& region,
   }
 }
 
+bool GlobalRouter::hasCapacity(bool is_horizontal,
+                               const int& pos_x,
+                               const int& pos_y,
+                               const int& layer_level)
+{
+  int grid_x = (int) ((pos_x - grid_->getXMin()) / grid_->getTileSize());
+  int grid_y = (int) ((pos_y - grid_->getYMin()) / grid_->getTileSize());
+  int cap = 0;
+  if (is_horizontal) {
+    cap = fastroute_->getEdgeCapacity(
+        grid_x, grid_y, grid_x + 1, grid_y, layer_level);
+  } else {
+    cap = fastroute_->getEdgeCapacity(
+        grid_x, grid_y, grid_x, grid_y + 1, layer_level);
+  }
+  return (cap >= 1);
+}
+
 void GlobalRouter::applyObstructionAdjustment(const odb::Rect& obstruction,
                                               odb::dbTechLayer* tech_layer)
 {