grt: encapsulate Interval and unsigned->int

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

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

@@ -170,10 +170,10 @@ void CUGR::write(const std::string& guide_file)
     ss << net->getName() << '\n';
     ss << "(\n";
     for (const auto& guide : guides) {
-      ss << grid_graph_->getGridline(0, guide.second.x.low) << " "
-         << grid_graph_->getGridline(1, guide.second.y.low) << " "
-         << grid_graph_->getGridline(0, guide.second.x.high + 1) << " "
-         << grid_graph_->getGridline(1, guide.second.y.high + 1) << " "
+      ss << grid_graph_->getGridline(0, guide.second.x.low()) << " "
+         << grid_graph_->getGridline(1, guide.second.y.low()) << " "
+         << grid_graph_->getGridline(0, guide.second.x.high() + 1) << " "
+         << grid_graph_->getGridline(1, guide.second.y.high() + 1) << " "
          << grid_graph_->getLayerName(guide.first) << "\n";
     }
     ss << ")\n";
@@ -285,7 +285,7 @@ void CUGR::getGuides(const GRNet* net,
 
   auto getSpareResource = [&](const GRPoint& point) {
     double resource = std::numeric_limits<double>::max();
-    unsigned direction = grid_graph_->getLayerDirection(point.getLayerIdx());
+    int direction = grid_graph_->getLayerDirection(point.getLayerIdx());
     if (point[direction] + 1 < grid_graph_->getSize(direction)) {
       resource = std::min(
           resource,
@@ -337,8 +337,7 @@ void CUGR::getGuides(const GRNet* net,
         for (const auto& child : node->getChildren()) {
           if (node->getLayerIdx() == child->getLayerIdx()) {
             double wire_patch_threshold = constants_.wire_patch_threshold;
-            unsigned direction
-                = grid_graph_->getLayerDirection(node->getLayerIdx());
+            int direction = grid_graph_->getLayerDirection(node->getLayerIdx());
             int l = std::min((*node)[direction], (*child)[direction]);
             int h = std::max((*node)[direction], (*child)[direction]);
             int r = (*node)[1 - direction];
@@ -391,7 +390,7 @@ void CUGR::printStatistics() const
         net->getRoutingTree(), [&](const std::shared_ptr<GRTreeNode>& node) {
           for (const auto& child : node->getChildren()) {
             if (node->getLayerIdx() == child->getLayerIdx()) {
-              unsigned direction
+              int direction
                   = grid_graph_->getLayerDirection(node->getLayerIdx());
               int l = std::min((*node)[direction], (*child)[direction]);
               int h = std::max((*node)[direction], (*child)[direction]);
@@ -417,7 +416,7 @@ void CUGR::printStatistics() const
   for (int layerIndex = constants_.min_routing_layer;
        layerIndex < grid_graph_->getNumLayers();
        layerIndex++) {
-    unsigned direction = grid_graph_->getLayerDirection(layerIndex);
+    int direction = grid_graph_->getLayerDirection(layerIndex);
     for (int x = 0; x < grid_graph_->getSize(0) - 1 + direction; x++) {
       for (int y = 0; y < grid_graph_->getSize(1) - direction; y++) {
         CapacityT resource

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

@@ -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/GRNet.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/GridGraph.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.h

@@ -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/Layers.cpp

@@ -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/MazeRoute.cpp

@@ -250,7 +250,7 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
                  && !node->getPaths()[0][0]->isOptional());
           auto& path = node->getPaths()[0][0];
           buildScaffolds(path);
-          unsigned direction
+          int direction
               = (node->y() == path->y() ? MetalLayer::H : MetalLayer::V);
           if (!scaffoldNodes[direction][path->getIndex()]
               && congestion_view.check(*node, *path)) {
@@ -261,7 +261,7 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
           for (auto& childPaths : node->getPaths()) {
             for (auto& path : childPaths) {
               buildScaffolds(path);
-              unsigned direction
+              int direction
                   = (node->y() == path->y() ? MetalLayer::H : MetalLayer::V);
               if (path->isOptional()) {
                 if (!scaffoldNodes[direction][node->getIndex()]
@@ -289,7 +289,7 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
               }
             }
             for (auto& child : node->getChildren()) {
-              for (unsigned direction = 0; direction < 2; direction++) {
+              for (int direction = 0; direction < 2; direction++) {
                 if (scaffoldNodes[direction][child->getIndex()]) {
                   scaffolds[direction].emplace_back(
                       std::make_shared<ScaffoldNode>(node));
@@ -304,7 +304,7 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
       };
 
   buildScaffolds(routing_dag_);
-  for (unsigned direction = 0; direction < 2; direction++) {
+  for (int direction = 0; direction < 2; direction++) {
     if (scaffoldNodes[direction][routing_dag_->getIndex()]) {
       scaffolds[direction].emplace_back(
           std::make_shared<ScaffoldNode>(nullptr));
@@ -316,12 +316,12 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
   std::function<void(const std::shared_ptr<ScaffoldNode>&,
                      IntervalT&,
                      std::vector<int>&,
-                     unsigned,
+                     int,
                      bool)>
       getTrunkAndStems = [&](const std::shared_ptr<ScaffoldNode>& scaffoldNode,
                              IntervalT& trunk,
                              std::vector<int>& stems,
-                             unsigned direction,
+                             int direction,
                              bool starting) {
         if (starting) {
           if (scaffoldNode->node) {
@@ -362,9 +362,9 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
   };
 
   std::function<std::shared_ptr<PatternRoutingNode>(
-      std::shared_ptr<ScaffoldNode>, unsigned, int)>
+      std::shared_ptr<ScaffoldNode>, int, int)>
       buildDetour = [&](const std::shared_ptr<ScaffoldNode>& scaffoldNode,
-                        unsigned direction,
+                        int direction,
                         int shiftAmount) {
         std::shared_ptr<PatternRoutingNode> treeNode = scaffoldNode->node;
         if (treeNode->getFixedLayers().IsValid()) {
@@ -416,7 +416,7 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
         return shiftedTreeNode;
       };
 
-  for (unsigned direction = 0; direction < 2; direction++) {
+  for (int direction = 0; direction < 2; direction++) {
     for (const std::shared_ptr<ScaffoldNode>& scaffold : scaffolds[direction]) {
       assert(scaffold->children.size() == 1);
 
@@ -428,30 +428,29 @@ void PatternRoute::constructDetours(GridGraphView<bool>& congestion_view)
       int originalLength = getTotalStemLength(stems, trunkPos);
       IntervalT shiftInterval(trunkPos);
       int maxLengthIncrease = trunk.range() * constants_.max_detour_ratio;
-      while (shiftInterval.low - 1 >= 0
-             && getTotalStemLength(stems, shiftInterval.low - 1)
+      while (shiftInterval.low() - 1 >= 0
+             && getTotalStemLength(stems, shiftInterval.low() - 1)
                         - originalLength
                     <= maxLengthIncrease) {
-        shiftInterval.low--;
+        shiftInterval.addToLow(-1);
       }
-      while (shiftInterval.high + 1 < grid_graph_->getSize(1 - direction)
-             && getTotalStemLength(stems, shiftInterval.high - 1)
+      while (shiftInterval.high() + 1 < grid_graph_->getSize(1 - direction)
+             && getTotalStemLength(stems, shiftInterval.high() - 1)
                         - originalLength
                     <= maxLengthIncrease) {
-        shiftInterval.high++;
+        shiftInterval.addToHigh(1);
       }
       int step = 1;
-      while ((trunkPos - shiftInterval.low) / (step + 1)
-                 + (shiftInterval.high - trunkPos) / (step + 1)
+      while ((trunkPos - shiftInterval.low()) / (step + 1)
+                 + (shiftInterval.high() - trunkPos) / (step + 1)
              >= constants_.target_detour_count) {
         step++;
       }
 
-      shiftInterval.low
-          = trunkPos - (trunkPos - shiftInterval.low) / step * step;
-      shiftInterval.high
-          = trunkPos + (shiftInterval.high - trunkPos) / step * step;
-      for (int pos = shiftInterval.low; pos <= shiftInterval.high;
+      shiftInterval.Set(
+          trunkPos - (trunkPos - shiftInterval.low()) / step * step,
+          trunkPos + (shiftInterval.high() - trunkPos) / step * step);
+      for (int pos = shiftInterval.low(); pos <= shiftInterval.high();
            pos += step) {
         int shiftAmount = (pos - trunkPos);
         if (shiftAmount == 0) {
@@ -540,8 +539,7 @@ void PatternRoute::calculateRoutingCosts(
     for (int pathIndex = 0; pathIndex < childPaths.size(); pathIndex++) {
       std::shared_ptr<PatternRoutingNode>& path = childPaths[pathIndex];
       calculateRoutingCosts(path);
-      unsigned direction
-          = node->x() == path->x() ? MetalLayer::V : MetalLayer::H;
+      int direction = node->x() == path->x() ? MetalLayer::V : MetalLayer::H;
       assert((*node)[1 - direction] == (*path)[1 - direction]);
       for (int layerIndex = constants_.min_routing_layer;
            layerIndex < grid_graph_->getNumLayers();
@@ -577,11 +575,11 @@ void PatternRoute::calculateRoutingCosts(
                            + grid_graph_->getViaCost(layerIndex - 1, *node);
   }
   IntervalT fixedLayers(node->getFixedLayers());
-  fixedLayers.low = std::min(fixedLayers.low,
-                             static_cast<int>(grid_graph_->getNumLayers()) - 1);
-  fixedLayers.high = std::max(fixedLayers.high, constants_.min_routing_layer);
+  fixedLayers.Set(std::min(fixedLayers.low(),
+                           static_cast<int>(grid_graph_->getNumLayers()) - 1),
+                  std::max(fixedLayers.high(), constants_.min_routing_layer));
 
-  for (int lowLayerIndex = 0; lowLayerIndex <= fixedLayers.low;
+  for (int lowLayerIndex = 0; lowLayerIndex <= fixedLayers.low();
        lowLayerIndex++) {
     std::vector<CostT> minChildCosts;
     std::vector<std::pair<int, int>> bestPaths;
@@ -603,7 +601,7 @@ void PatternRoute::calculateRoutingCosts(
               childCosts[child_index][layerIndex].second, layerIndex);
         }
       }
-      if (layerIndex >= fixedLayers.high) {
+      if (layerIndex >= fixedLayers.high()) {
         CostT cost = viaCosts[layerIndex] - viaCosts[lowLayerIndex];
         for (CostT childCost : minChildCosts) {
           cost += childCost;
@@ -682,13 +680,13 @@ std::shared_ptr<GRTreeNode> PatternRoute::getRoutingTree(
       }
     }
   }
-  if (lowestRoutingNode->getLayerIdx() > node->getFixedLayers().low) {
+  if (lowestRoutingNode->getLayerIdx() > node->getFixedLayers().low()) {
     lowestRoutingNode->addChild(std::make_shared<GRTreeNode>(
-        node->getFixedLayers().low, node->x(), node->y()));
+        node->getFixedLayers().low(), node->x(), node->y()));
   }
-  if (highestRoutingNode->getLayerIdx() < node->getFixedLayers().high) {
+  if (highestRoutingNode->getLayerIdx() < node->getFixedLayers().high()) {
     highestRoutingNode->addChild(std::make_shared<GRTreeNode>(
-        node->getFixedLayers().high, node->x(), node->y()));
+        node->getFixedLayers().high(), node->x(), node->y()));
   }
   return routingNode;
 }