Merge remote-tracking branch 'origin/master' into drt-incremental-pa

Signed-off-by: osamahammad21 <[email protected]>

Author: osamahammad21

src/Design.cc

@@ -3,6 +3,7 @@
 
 #include "ord/Design.h"
 
+#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <istream>
@@ -224,7 +225,7 @@ std::uint64_t Design::getNetRoutedLength(odb::dbNet* net)
     for (odb::dbSWire* swire : net->getSWires()) {
       for (odb::dbSBox* wire : swire->getWires()) {
         if (wire != nullptr && !(wire->isVia())) {
-          route_length += wire->getLength();
+          route_length += std::max(wire->getDX(), wire->getDY());
         }
       }
     }

src/dpl/src/PlacementDRC.cpp

@@ -13,6 +13,7 @@
 #include "odb/dbTransform.h"
 #include "odb/dbTypes.h"
 #include "odb/geom.h"
+#include "odb/isotropy.h"
 
 namespace dpl {
 
@@ -36,7 +37,7 @@ odb::Rect transformEdgeRect(const odb::Rect& edge_rect,
 odb::Rect getQueryRect(const odb::Rect& edge_box, const int spc)
 {
   odb::Rect query_rect(edge_box);
-  bool is_vertical_edge = edge_box.getDir() == 0;
+  bool is_vertical_edge = edge_box.getDir() == odb::vertical;
   if (is_vertical_edge) {
     // vertical edge
     query_rect = query_rect.bloat(spc, odb::Orientation2D::Horizontal);
@@ -89,7 +90,7 @@ bool PlacementDRC::checkEdgeSpacing(const Node* cell,
                   + 1;  // +1 to account for EXACT rules
     odb::Rect edge1_box = cell_edges::transformEdgeRect(
         edge1.getBBox(), cell, x_real, y_real, orient);
-    bool is_vertical_edge = edge1_box.getDir() == 0;
+    bool is_vertical_edge = edge1_box.getDir() == odb::vertical;
     odb::Rect query_rect = cell_edges::getQueryRect(edge1_box, max_spc);
     GridX xMin = grid_->gridX(DbuX(query_rect.xMin()));
     GridX xMax = grid_->gridEndX(DbuX(query_rect.xMax()));

src/dpl/src/infrastructure/Grid.cpp

@@ -149,7 +149,7 @@ void Grid::markBlocked(odb::dbBlock* block)
           if (routing_level <= 1 || routing_level > 3) {  // considering M2, M3
             return;
           }
-          if (wire_rect.getDir() == 1) {  // horizontal
+          if (wire_rect.getDir() == odb::horizontal) {
             return;
           }
           wire_rect.moveDelta(-core.xMin(), -core.yMin());

src/drt/src/gc/FlexGC_main.cpp

@@ -21,6 +21,7 @@
 #include "gc/FlexGC_impl.h"
 #include "odb/dbTypes.h"
 #include "odb/geom.h"
+#include "odb/isotropy.h"
 
 using odb::dbTechLayerType;
 
@@ -3873,7 +3874,8 @@ void FlexGCWorker::Impl::patchMetalShape_minStep()
           } else {
             continue;
           }
-          if (enc_box.getDir() == 1 && markerBBox.yMin() == enc_box.yMin()
+          if (enc_box.getDir() == odb::horizontal
+              && markerBBox.yMin() == enc_box.yMin()
               && markerBBox.yMax() == enc_box.yMax()) {
             int bloating_dist = std::max(0, min_step_length - markerBBox.dx());
             if (markerBBox.xMin() >= enc_box.xMin()
@@ -3885,7 +3887,7 @@ void FlexGCWorker::Impl::patchMetalShape_minStep()
             } else {
               continue;
             }
-          } else if (enc_box.getDir() == 0
+          } else if (enc_box.getDir() == odb::vertical
                      && markerBBox.xMin() == enc_box.xMin()
                      && markerBBox.xMax() == enc_box.xMax()) {
             int bloating_dist = std::max(0, min_step_length - markerBBox.dy());

src/drt/src/io/GuideProcessor.cpp

@@ -24,6 +24,7 @@
 #include "frBaseTypes.h"
 #include "frDesign.h"
 #include "frProfileTask.h"
+#include "global.h"
 #include "odb/db.h"
 #include "odb/dbTypes.h"
 #include "odb/geom.h"
@@ -207,7 +208,8 @@ Point3D findBestPinLocation(frDesign* design,
  */
 int findClosestGuide(const Point3D& best_pin_loc_coords,
                      const std::vector<frRect>& guides,
-                     const frCoord layer_change_penalty)
+                     const frCoord layer_change_penalty,
+                     const RouterConfiguration* router_cfg)
 {
   int closest_guide_idx = 0;
   int dist = 0;
@@ -217,6 +219,9 @@ int findClosestGuide(const Point3D& best_pin_loc_coords,
     dist = odb::manhattanDistance(guide.getBBox(), best_pin_loc_coords);
     dist += abs(guide.getLayerNum() - best_pin_loc_coords.z())
             * layer_change_penalty;
+    if (guide.getLayerNum() < router_cfg->BOTTOM_ROUTING_LAYER) {
+      dist += 1e9;
+    }
     if (dist < min_dist) {
       min_dist = dist;
       closest_guide_idx = guide_idx;
@@ -352,41 +357,6 @@ void fillGuidesUpToZ(const Point3D& best_pin_loc_coords,
                         net);
   }
 }
-/**
- * @brief Connects the guides with the best pin shape location (on the 2D
- * plane only)
- *
- * The function creates a patch guide that connects the closest guide to
- * best_pin_loc_coords (without consideration to different layers)
- *
- * @param guide_pt The center of the gcell on the guide that is closest to
- * best_pin_loc_coords
- * @param best_pin_loc_coords The gcell center point of the chosen pin shape
- * @param gcell_half_size_horz Half the horizontal size of the gcell
- * @param gcell_half_size_vert Half the vertical size of the gcell
- */
-void connectGuidesWithBestPinLoc(const Point3D& guide_pt,
-                                 const odb::Point& best_pin_loc_coords,
-                                 const frCoord gcell_half_size_horz,
-                                 const frCoord gcell_half_size_vert,
-                                 frNet* net,
-                                 std::vector<frRect>& guides)
-{
-  if (guide_pt.x() != best_pin_loc_coords.x()
-      || guide_pt.y() != best_pin_loc_coords.y()) {
-    const odb::Point pl = {std::min(best_pin_loc_coords.x(), guide_pt.x()),
-                           std::min(best_pin_loc_coords.y(), guide_pt.y())};
-    const odb::Point ph = {std::max(best_pin_loc_coords.x(), guide_pt.x()),
-                           std::max(best_pin_loc_coords.y(), guide_pt.y())};
-
-    guides.emplace_back(pl.x() - gcell_half_size_horz,
-                        pl.y() - gcell_half_size_vert,
-                        ph.x() + gcell_half_size_horz,
-                        ph.y() + gcell_half_size_vert,
-                        guide_pt.z(),
-                        net);
-  }
-}
 
 /**
  * @brief logs the number of guides read so far
@@ -949,6 +919,43 @@ void GuideProcessor::buildGCellPatterns()
   }
 }
 
+void GuideProcessor::connectGuidesWithBestPinLoc(
+    Point3D& guide_pt,
+    const odb::Point& best_pin_loc_coords,
+    const frCoord gcell_half_size_horz,
+    const frCoord gcell_half_size_vert,
+    frNet* net,
+    std::vector<frRect>& guides)
+{
+  if (guide_pt.x() != best_pin_loc_coords.x()
+      || guide_pt.y() != best_pin_loc_coords.y()) {
+    const odb::Point pl = {std::min(best_pin_loc_coords.x(), guide_pt.x()),
+                           std::min(best_pin_loc_coords.y(), guide_pt.y())};
+    const odb::Point ph = {std::max(best_pin_loc_coords.x(), guide_pt.x()),
+                           std::max(best_pin_loc_coords.y(), guide_pt.y())};
+    bool is_horizontal = pl.x() != ph.x();
+    bool is_vertical = pl.y() != ph.y();
+    frLayerNum layer_num = guide_pt.z();
+    if (is_horizontal ^ is_vertical) {
+      if ((is_vertical && design_->isHorizontalLayer(layer_num))
+          || (is_horizontal && design_->isVerticalLayer(layer_num))) {
+        if (layer_num + 2 <= router_cfg_->TOP_ROUTING_LAYER) {
+          layer_num += 2;
+        } else {
+          layer_num -= 2;
+        }
+      }
+    }
+    guide_pt.setZ(layer_num);
+    guides.emplace_back(pl.x() - gcell_half_size_horz,
+                        pl.y() - gcell_half_size_vert,
+                        ph.x() + gcell_half_size_horz,
+                        ph.y() + gcell_half_size_vert,
+                        layer_num,
+                        net);
+  }
+}
+
 void GuideProcessor::patchGuides_helper(frNet* net,
                                         std::vector<frRect>& guides,
                                         const Point3D& best_pin_loc_idx,
@@ -1021,7 +1028,7 @@ void GuideProcessor::patchGuides(frNet* net,
   // get the guide that is closest to the gCell
   // TODO: test passing layer_change_penalty = gcell size
   const int closest_guide_idx
-      = findClosestGuide(best_pin_loc_coords, guides, 1);
+      = findClosestGuide(best_pin_loc_coords, guides, 1, router_cfg_);
 
   patchGuides_helper(
       net, guides, best_pin_loc_idx, best_pin_loc_coords, closest_guide_idx);

src/drt/src/io/GuideProcessor.h

@@ -91,6 +91,25 @@ class GuideProcessor
                           const Point3D& best_pin_loc_idx,
                           const Point3D& best_pin_loc_coords,
                           int closest_guide_idx);
+  /**
+   * @brief Connects the guides with the best pin shape location (on the 2D
+   * plane only)
+   *
+   * The function creates a patch guide that connects the closest guide to
+   * best_pin_loc_coords (without consideration to different layers)
+   *
+   * @param guide_pt The center of the gcell on the guide that is closest to
+   * best_pin_loc_coords
+   * @param best_pin_loc_coords The gcell center point of the chosen pin shape
+   * @param gcell_half_size_horz Half the horizontal size of the gcell
+   * @param gcell_half_size_vert Half the vertical size of the gcell
+   */
+  void connectGuidesWithBestPinLoc(Point3D& guide_pt,
+                                   const odb::Point& best_pin_loc_coords,
+                                   frCoord gcell_half_size_horz,
+                                   frCoord gcell_half_size_vert,
+                                   frNet* net,
+                                   std::vector<frRect>& guides);
   /**
    * @brief Patches guides to cover part of the pin if needed.
    *

src/drt/src/io/io.cpp

@@ -962,9 +962,7 @@ void io::Parser::updateNetRouting(frNet* netIn, odb::dbNet* net)
               == getTech()->name2via_.end()) {
             logger_->error(DRT, 109, "Unsupported via in db.");
           } else {
-            int x, y;
-            box->getViaXY(x, y);
-            odb::Point p(x, y);
+            const odb::Point p = box->getViaXY();
             auto viaDef = getTech()->name2via_[viaName];
             auto tmpP = std::make_unique<frVia>(viaDef);
             tmpP->setOrigin(p);
@@ -2675,11 +2673,10 @@ void io::Parser::setMasters(odb::dbDatabase* db)
                               master->getName(),
                               _term->getName());
               }
-              int x, y;
-              box->getViaXY(x, y);
+              const odb::Point pt = box->getViaXY();
               auto viaDef = getTech()->name2via_[box->getTechVia()->getName()];
               auto tmpP = std::make_unique<frVia>(viaDef);
-              tmpP->setOrigin({x, y});
+              tmpP->setOrigin(pt);
               // layer1 rect
               addPinFig(
                   tmpP->getLayer1BBox(), viaDef->getLayer1Num(), pinIn.get());

src/grt/src/GlobalRouter.cpp

@@ -1408,7 +1408,7 @@ std::vector<LayerId> GlobalRouter::findTransitionLayers()
     int via_width = 0;
     for (const auto box : default_vias[tech_layer]->getBoxes()) {
       if (box->getTechLayer() == tech_layer) {
-        via_width = vertical ? box->getWidth() : box->getLength();
+        via_width = vertical ? box->getDY() : box->getDX();
         break;
       }
     }
@@ -3487,17 +3487,17 @@ void getViaDims(std::map<odb::dbTechLayer*, odb::dbTechVia*> default_vias,
   if (default_vias.find(tech_layer) != default_vias.end()) {
     for (auto box : default_vias[tech_layer]->getBoxes()) {
       if (box->getTechLayer() == tech_layer) {
-        width_up = std::min(box->getWidth(), box->getLength());
-        prl_up = std::max(box->getWidth(), box->getLength());
+        width_up = std::min(box->getDX(), box->getDY());
+        prl_up = std::max(box->getDX(), box->getDY());
         break;
       }
     }
   }
   if (default_vias.find(bottom_layer) != default_vias.end()) {
     for (auto box : default_vias[bottom_layer]->getBoxes()) {
       if (box->getTechLayer() == tech_layer) {
-        width_down = std::min(box->getWidth(), box->getLength());
-        prl_down = std::max(box->getWidth(), box->getLength());
+        width_down = std::min(box->getDX(), box->getDY());
+        prl_down = std::max(box->getDX(), box->getDY());
         break;
       }
     }