Merge pull request #8301 from The-OpenROAD-Project-staging/cugr-refactor

Cugr refactor

Author: maliberty

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

@@ -66,6 +66,10 @@ class CUGR
   NetRouteMap getRoutes();
 
  private:
+  void updateOverflowNets(std::vector<int>& netIndices);
+  void patternRoute(std::vector<int>& netIndices);
+  void patternRouteWithDetours(std::vector<int>& netIndices);
+  void mazeRoute(std::vector<int>& netIndices);
   void sortNetIndices(std::vector<int>& netIndices) const;
   void getGuides(const GRNet* net,
                  std::vector<std::pair<int, grt::BoxT>>& guides);

src/grt/src/cugr/src/CUGR.cpp

@@ -102,7 +102,7 @@ void Design::readNetlist()
         }
       }
 
-      pins.emplace_back(pin_count, db_bterm, pin_shapes, true);
+      pins.emplace_back(pin_count, db_bterm, pin_shapes);
       pin_count++;
     }
 
@@ -125,7 +125,7 @@ void Design::readNetlist()
         }
       }
 
-      pins.emplace_back(pin_count, db_iterm, pin_shapes, false);
+      pins.emplace_back(pin_count, db_iterm, pin_shapes);
       pin_count++;
     }
     nets_.emplace_back(net_index, db_net, pins);
@@ -240,9 +240,9 @@ int Design::readSpecialNetObstructions()
 void Design::computeGrid()
 {
   gridlines_.resize(2);
-  for (unsigned dimension = 0; dimension < 2; dimension++) {
-    const int low = die_region_[dimension].low;
-    const int high = die_region_[dimension].high;
+  for (int dimension = 0; dimension < 2; dimension++) {
+    const int low = die_region_[dimension].low();
+    const int high = die_region_[dimension].high();
     for (int i = low; i + default_gridline_spacing_ < high;
          i += default_gridline_spacing_) {
       gridlines_[dimension].push_back(i);

src/grt/src/cugr/src/Design.cpp

@@ -23,8 +23,8 @@ GRNet::GRNet(const CUGRNet& baseNet, const GridGraph* gridGraph)
     std::unordered_set<uint64_t> included;
     for (const auto& pinShape : pinShapes) {
       const BoxT cells = gridGraph->rangeSearchCells(pinShape);
-      for (int x = cells.x.low; x <= cells.x.high; x++) {
-        for (int y = cells.y.low; y <= cells.y.high; y++) {
+      for (int x = cells.x.low(); x <= cells.x.high(); x++) {
+        for (int y = cells.y.low(); y <= cells.y.high(); y++) {
           const GRPoint point(pinShape.getLayerIdx(), x, y);
           const uint64_t hash = gridGraph->hashCell(point);
           if (included.find(hash) == included.end()) {

src/grt/src/cugr/src/GRNet.cpp

@@ -35,16 +35,13 @@ class GridGraph
   GridGraph(const Design* design, const Constants& constants);
   int getLibDBU() const { return lib_dbu_; }
   int getM2Pitch() const { return m2_pitch_; }
-  unsigned getNumLayers() const { return num_layers_; }
-  unsigned getSize(unsigned dimension) const
-  {
-    return (dimension ? y_size_ : x_size_);
-  }
+  int getNumLayers() const { return num_layers_; }
+  int getSize(int dimension) const { return (dimension ? y_size_ : x_size_); }
   std::string getLayerName(int layer_index) const
   {
     return layer_names_[layer_index];
   }
-  unsigned getLayerDirection(int layer_index) const
+  int getLayerDirection(int layer_index) const
   {
     return layer_directions_[layer_index];
   }
@@ -58,7 +55,7 @@ class GridGraph
   {
     return (uint64_t) x * y_size_ + y;
   }
-  int getGridline(const unsigned dimension, const int index) const
+  int getGridline(const int dimension, const int index) const
   {
     return gridlines_[dimension][index];
   }
@@ -70,7 +67,7 @@ class GridGraph
   }
 
   // Costs
-  int getEdgeLength(unsigned direction, unsigned edge_index) const;
+  int getEdgeLength(int direction, int edge_index) const;
   CostT getWireCost(int layer_index, PointT u, PointT v) const;
   CostT getViaCost(int layer_index, PointT loc) const;
   CostT getUnitViaCost() const { return unit_via_cost_; }
@@ -114,13 +111,13 @@ class GridGraph
   const int lib_dbu_;
   int m2_pitch_;
 
-  unsigned num_layers_;
-  unsigned x_size_;
-  unsigned y_size_;
+  int num_layers_;
+  int x_size_;
+  int y_size_;
   std::vector<std::vector<int>> gridlines_;
   std::vector<std::vector<int>> grid_centers_;
   std::vector<std::string> layer_names_;
-  std::vector<unsigned> layer_directions_;
+  std::vector<int> layer_directions_;
   std::vector<int> layer_min_lengths_;
 
   // Unit costs
@@ -135,11 +132,10 @@ class GridGraph
   // (l, x, y+1)} depending on the routing direction of the layer
   Constants constants_;
 
-  IntervalT rangeSearchGridlines(unsigned dimension,
+  IntervalT rangeSearchGridlines(int dimension,
                                  const IntervalT& loc_interval) const;
   // Find the gridlines_ within [locInterval.low, locInterval.high]
-  IntervalT rangeSearchRows(unsigned dimension,
-                            const IntervalT& loc_interval) const;
+  IntervalT rangeSearchRows(int dimension, const IntervalT& loc_interval) const;
   // Find the rows/columns overlapping with [locInterval.low, locInterval.high]
 
   // Utility functions for cost calculation

src/grt/src/cugr/src/GridGraph.cpp

@@ -88,35 +88,35 @@ int MetalLayer::getTrackLocation(const int track_index) const
 IntervalT MetalLayer::rangeSearchTracks(const IntervalT& loc_range,
                                         const bool include_bound) const
 {
-  IntervalT track_range(
-      ceil(double(std::max(loc_range.low, first_track_loc_) - first_track_loc_)
-           / double(pitch_)),
-      floor(double(std::min(loc_range.high, last_track_loc_) - first_track_loc_)
-            / double(pitch_)));
+  const int lo = std::max(loc_range.low(), first_track_loc_);
+  const int hi = std::min(loc_range.high(), last_track_loc_);
+  const double pitch = pitch_;
+  IntervalT track_range(std::ceil((lo - first_track_loc_) / pitch),
+                        std::floor((hi - first_track_loc_) / pitch));
   if (!track_range.IsValid()) {
     return track_range;
   }
   if (!include_bound) {
-    if (getTrackLocation(track_range.low) == loc_range.low) {
-      ++track_range.low;
+    if (getTrackLocation(track_range.low()) == loc_range.low()) {
+      track_range.addToLow(1);
     }
-    if (getTrackLocation(track_range.high) == loc_range.high) {
-      --track_range.high;
+    if (getTrackLocation(track_range.high()) == loc_range.high()) {
+      track_range.addToHigh(-1);
     }
   }
   return track_range;
 }
 
 int MetalLayer::getParallelSpacing(const int width, const int length) const
 {
-  unsigned w = parallel_width_.size() - 1;
+  int w = parallel_width_.size() - 1;
   while (w > 0 && parallel_width_[w] >= width) {
     w--;
   }
   if (length == 0) {
     return parallel_spacing_[w][0];
   }
-  unsigned l = parallel_length_.size() - 1;
+  int l = parallel_length_.size() - 1;
   while (l > 0 && parallel_length_[l] >= length) {
     l--;
   }

src/grt/src/cugr/src/GridGraph.h

@@ -89,17 +89,16 @@ void SparseGraph::init(const GridGraphView<CostT>& wire_cost_view,
   // 3. Add same-layer connections
   edges_.resize(vertices_.size(), {-1, -1, -1});
   costs_.resize(vertices_.size(), {-1, -1, -1});
-  auto addSameLayerEdge
-      = [&](const unsigned direction, const int xi, const int yi) {
-          const int u = getVertexIndex(direction, xi, yi);
-          const int v = direction == MetalLayer::H ? u + 1 : u + xs_.size();
-          const PointT U(xs_[xi], ys_[yi]);
-          const PointT V(xs_[xi + 1 - direction], ys_[yi + direction]);
+  auto addSameLayerEdge = [&](const int direction, const int xi, const int yi) {
+    const int u = getVertexIndex(direction, xi, yi);
+    const int v = direction == MetalLayer::H ? u + 1 : u + xs_.size();
+    const PointT U(xs_[xi], ys_[yi]);
+    const PointT V(xs_[xi + 1 - direction], ys_[yi + direction]);
 
-          edges_[u][0] = v;
-          edges_[v][1] = u;
-          costs_[u][0] = costs_[v][1] = wire_cost_view.sum(U, V);
-        };
+    edges_[u][0] = v;
+    edges_[v][1] = u;
+    costs_[u][0] = costs_[v][1] = wire_cost_view.sum(U, V);
+  };
 
   for (int direction = 0; direction < 2; direction++) {
     if (direction == MetalLayer::H) {

src/grt/src/cugr/src/Layers.cpp

@@ -13,17 +13,15 @@ namespace grt {
 
 CUGRPin::CUGRPin(const int index,
                  odb::dbITerm* iterm,
-                 const std::vector<BoxOnLayer>& pin_shapes,
-                 const bool is_port)
-    : index_(index), iterm(iterm), pin_shapes_(pin_shapes), is_port_(is_port)
+                 const std::vector<BoxOnLayer>& pin_shapes)
+    : iterm(iterm), pin_shapes_(pin_shapes), index_(index), is_port_(false)
 {
 }
 
 CUGRPin::CUGRPin(const int index,
                  odb::dbBTerm* bterm,
-                 const std::vector<BoxOnLayer>& pin_shapes,
-                 const bool is_port)
-    : index_(index), bterm(bterm), pin_shapes_(pin_shapes), is_port_(is_port)
+                 const std::vector<BoxOnLayer>& pin_shapes)
+    : bterm(bterm), pin_shapes_(pin_shapes), index_(index), is_port_(true)
 {
 }
 

src/grt/src/cugr/src/MazeRoute.cpp

@@ -16,12 +16,10 @@ class CUGRPin
  public:
   CUGRPin(int index,
           odb::dbITerm* iterm,
-          const std::vector<BoxOnLayer>& pin_shapes,
-          bool is_port);
+          const std::vector<BoxOnLayer>& pin_shapes);
   CUGRPin(int index,
           odb::dbBTerm* bterm,
-          const std::vector<BoxOnLayer>& pin_shapes,
-          bool is_port);
+          const std::vector<BoxOnLayer>& pin_shapes);
 
   int getIndex() const { return index_; }
   odb::dbITerm* getITerm() const;
@@ -31,13 +29,13 @@ class CUGRPin
   std::string getName() const;
 
  private:
-  const int index_;
   union
   {
     odb::dbITerm* iterm;
     odb::dbBTerm* bterm;
   };
   std::vector<BoxOnLayer> pin_shapes_;
+  const int index_;
   const bool is_port_;
 };