grt: misc minor cugr cleanups

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

Author: maliberty

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

@@ -17,17 +17,16 @@ MetalLayer::MetalLayer(odb::dbTechLayer* tech_layer,
   index_ = tech_layer->getRoutingLevel() - 1;
   direction_
       = tech_layer->getDirection() == odb::dbTechLayerDir::HORIZONTAL ? H : V;
-  width_ = static_cast<int>(std::round(tech_layer->getWidth()));
-  min_width_ = static_cast<int>(std::round(tech_layer->getMinWidth()));
+  width_ = tech_layer->getWidth();
+  min_width_ = tech_layer->getMinWidth();
 
   track_grid->getAverageTrackSpacing(pitch_, first_track_loc_, num_tracks_);
   last_track_loc_ = first_track_loc_ + pitch_ * (num_tracks_ - 1);
 
   // Design rules not parsed thoroughly
   // Min area
   const int database_unit = tech_layer->getTech()->getDbUnitsPerMicron();
-  int min_area = static_cast<int>(
-      std::round(tech_layer->getArea() * database_unit * database_unit));
+  const int min_area = tech_layer->getArea() * database_unit * database_unit;
   min_length_ = std::max(min_area / width_ - width_, 0);
 
   // Parallel run spacing
@@ -42,7 +41,7 @@ MetalLayer::MetalLayer(odb::dbTechLayer* tech_layer,
     if (num_length > 0) {
       parallel_length_.resize(num_length);
       for (int l = 0; l < num_length; l++) {
-        parallel_length_[l] = static_cast<int>(std::round(lengths[l]));
+        parallel_length_[l] = lengths[l];
       }
     }
 
@@ -51,11 +50,10 @@ MetalLayer::MetalLayer(odb::dbTechLayer* tech_layer,
       parallel_width_.resize(num_width);
       parallel_spacing_.resize(num_width);
       for (int w = 0; w < num_width; w++) {
-        parallel_width_[w] = static_cast<int>(std::round(widths[w]));
+        parallel_width_[w] = widths[w];
         parallel_spacing_[w].resize(std::max(1, num_length), 0);
         for (int l = 0; l < num_length; l++) {
-          parallel_spacing_[w][l]
-              = static_cast<int>(std::round(spacing_table[w][l]));
+          parallel_spacing_[w][l] = spacing_table[w][l];
         }
       }
     }
@@ -88,7 +86,7 @@ int MetalLayer::getTrackLocation(const int track_index) const
 }
 
 IntervalT MetalLayer::rangeSearchTracks(const IntervalT& loc_range,
-                                        bool include_bound) const
+                                        const bool include_bound) const
 {
   IntervalT track_range(
       ceil(double(std::max(loc_range.low, first_track_loc_) - first_track_loc_)

src/grt/src/cugr/src/Layers.h

@@ -11,11 +11,13 @@ namespace grt {
 class MetalLayer
 {
  public:
-  const static unsigned H = 0;
-  const static unsigned V = 1;
+  const static int H = 0;
+  const static int V = 1;
+
   MetalLayer(odb::dbTechLayer* tech_layer, odb::dbTrackGrid* track_grid);
+
   std::string getName() const { return name_; }
-  unsigned getDirection() const { return direction_; }
+  int getDirection() const { return direction_; }
   int getWidth() const { return width_; }
   int getPitch() const { return pitch_; }
   int getTrackLocation(int track_index) const;
@@ -31,7 +33,7 @@ class MetalLayer
  private:
   std::string name_;
   int index_;
-  unsigned direction_;
+  int direction_;
   int width_;
   int min_width_;
 
@@ -47,8 +49,8 @@ class MetalLayer
   // Parallel run spacing
   std::vector<int> parallel_width_ = {0};
   std::vector<int> parallel_length_ = {0};
-  std::vector<std::vector<int>> parallel_spacing_
-      = {{0}};  // width, length -> spacing
+  // width, length -> spacing
+  std::vector<std::vector<int>> parallel_spacing_ = {{0}};
   int default_spacing_ = 0;
 
   // End-of-line spacing

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

@@ -19,14 +19,15 @@
 
 namespace grt {
 
-void SparseGraph::init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid)
+void SparseGraph::init(const GridGraphView<CostT>& wire_cost_view,
+                       const SparseGrid& grid)
 {
   // 0. Create pseudo pins
   robin_hood::unordered_map<uint64_t, std::pair<PointT, IntervalT>>
       selectedAccessPoints;
   grid_graph_->selectAccessPoints(net_, selectedAccessPoints);
   pseudo_pins_.reserve(selectedAccessPoints.size());
-  for (auto& selectedPoint : selectedAccessPoints) {
+  for (const auto& selectedPoint : selectedAccessPoints) {
     pseudo_pins_.push_back(selectedPoint.second);
   }
 
@@ -46,9 +47,8 @@ void SparseGraph::init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid)
   const int ySize = grid_graph_->getSize(1);
   xs_.reserve(xSize / grid.interval.x() + pxs.size());
   ys_.reserve(ySize / grid.interval.y() + pys.size());
-  int j = 0;
-  for (int i = 0; true; i++) {
-    int x = i * grid.interval.x() + grid.offset.x();
+  for (int i = 0, j = 0; true; i++) {
+    const int x = i * grid.interval.x() + grid.offset.x();
     for (; j < pxs.size() && pxs[j] <= x; j++) {
       if ((!xs_.empty() && pxs[j] == xs_.back()) || pxs[j] == x) {
         continue;
@@ -61,9 +61,8 @@ void SparseGraph::init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid)
       break;
     }
   }
-  j = 0;
-  for (int i = 0; true; i++) {
-    int y = i * grid.interval.y() + grid.offset.y();
+  for (int i = 0, j = 0; true; i++) {
+    const int y = i * grid.interval.y() + grid.offset.y();
     for (; j < pys.size() && pys[j] <= y; j++) {
       if ((!ys_.empty() && pys[j] == ys_.back()) || pys[j] == y) {
         continue;
@@ -79,7 +78,7 @@ void SparseGraph::init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid)
 
   // 2. Add vertices
   vertices_.reserve(2 * xs_.size() * ys_.size());
-  for (unsigned direction = 0; direction < 2; direction++) {
+  for (int direction = 0; direction < 2; direction++) {
     for (auto& y : ys_) {
       for (auto& x : xs_) {
         vertices_.emplace_back(direction, x, y);
@@ -94,15 +93,15 @@ void SparseGraph::init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid)
       = [&](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();
-          PointT U(xs_[xi], ys_[yi]);
-          PointT V(xs_[xi + 1 - direction], ys_[yi + direction]);
+          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);
         };
 
-  for (unsigned direction = 0; direction < 2; direction++) {
+  for (int direction = 0; direction < 2; direction++) {
     if (direction == MetalLayer::H) {
       for (int yi = 0; yi < ys_.size(); yi++) {
         for (int xi = 0; xi + 1 < xs_.size(); xi++) {
@@ -207,12 +206,12 @@ void MazeRoute::run()
         continue;
       }
       for (int edgeIndex = 0; edgeIndex < 3; edgeIndex++) {
-        int nextVertex = graph_.getNextVertex(solution->vertex, edgeIndex);
+        const int nextVertex = graph_.getNextVertex(solution->vertex, edgeIndex);
         if (nextVertex == -1
             || (solution->prev && nextVertex == solution->prev->vertex)) {
           continue;
         }
-        CostT nextCost
+        const CostT nextCost
             = solution->cost + graph_.getEdgeCost(solution->vertex, edgeIndex);
         if (nextCost < minCosts[nextVertex]) {
           updateSolution(
@@ -255,8 +254,8 @@ std::shared_ptr<SteinerTreeNode> MazeRoute::getSteinerTree() const
     while (temp) {
       auto it = created.find(temp->vertex);
       if (it == created.end()) {
-        PointT point = graph_.getPoint(temp->vertex);
-        auto node = std::make_shared<SteinerTreeNode>(point);
+        const PointT point = graph_.getPoint(temp->vertex);
+        const auto node = std::make_shared<SteinerTreeNode>(point);
         created.emplace(temp->vertex, node);
         if (lastNode) {
           node->addChild(lastNode);
@@ -266,7 +265,7 @@ std::shared_ptr<SteinerTreeNode> MazeRoute::getSteinerTree() const
         }
         if (!lastNode || !temp->prev) {
           // Both the start and the end of the path should contain pins
-          int pinIndex = graph_.getVertexPin(temp->vertex);
+          const int pinIndex = graph_.getVertexPin(temp->vertex);
           assert(pinIndex != -1);
           node->setFixedLayers(graph_.getPseudoPin(pinIndex).second);
         }
@@ -286,10 +285,10 @@ std::shared_ptr<SteinerTreeNode> MazeRoute::getSteinerTree() const
       tree, [&](const std::shared_ptr<SteinerTreeNode>& node) {
         for (int childIndex = 0; childIndex < node->getNumChildren();
              childIndex++) {
-          std::shared_ptr<SteinerTreeNode> child
+          const std::shared_ptr<SteinerTreeNode> child
               = node->getChildren()[childIndex];
           if (node->x() == child->x() && node->y() == child->y()) {
-            for (auto& gradchild : child->getChildren()) {
+            for (const auto& gradchild : child->getChildren()) {
               node->addChild(gradchild);
             }
             if (child->getFixedLayers().IsValid()) {
@@ -309,7 +308,7 @@ std::shared_ptr<SteinerTreeNode> MazeRoute::getSteinerTree() const
   SteinerTreeNode::preorder(
       tree, [&](const std::shared_ptr<SteinerTreeNode>& node) {
         for (std::shared_ptr<SteinerTreeNode>& child : node->getChildren()) {
-          unsigned direction
+          const int direction
               = (node->y() == child->y() ? MetalLayer::H : MetalLayer::V);
           std::shared_ptr<SteinerTreeNode> temp = child;
           while (!temp->getFixedLayers().IsValid()

src/grt/src/cugr/src/MazeRoute.h

@@ -17,9 +17,6 @@ namespace grt {
 
 struct SparseGrid
 {
-  PointT interval;
-  PointT offset;
-
   SparseGrid(int x_interval, int y_interval, int x_offset, int y_offset)
       : interval(x_interval, y_interval), offset(x_offset, y_offset)
   {
@@ -35,6 +32,9 @@ struct SparseGrid
     interval = {x_interval, y_interval};
     step();
   }
+
+  PointT interval;
+  PointT offset;
 };
 
 class SparseGraph
@@ -45,7 +45,7 @@ class SparseGraph
   {
   }
 
-  void init(GridGraphView<CostT>& wire_cost_view, SparseGrid& grid);
+  void init(const GridGraphView<CostT>& wire_cost_view, const SparseGrid& grid);
   int getNumVertices() const { return vertices_.size(); }
   int getNumPseudoPins() const { return pseudo_pins_.size(); }
   std::pair<PointT, IntervalT> getPseudoPin(int pin_index) const
@@ -95,14 +95,14 @@ class SparseGraph
 
 struct Solution
 {
-  CostT cost;
-  int vertex;
-  std::shared_ptr<Solution> prev;
-
   Solution(CostT c, int v, const std::shared_ptr<Solution>& p)
       : cost(c), vertex(v), prev(p)
   {
   }
+
+  const CostT cost;
+  const int vertex;
+  const std::shared_ptr<Solution> prev;
 };
 
 class MazeRoute
@@ -114,15 +114,15 @@ class MazeRoute
   }
 
   void run();
-  void constructSparsifiedGraph(GridGraphView<CostT>& wire_cost_view,
-                                SparseGrid& grid)
+  void constructSparsifiedGraph(const GridGraphView<CostT>& wire_cost_view,
+                                const SparseGrid& grid)
   {
     graph_.init(wire_cost_view, grid);
   }
   std::shared_ptr<SteinerTreeNode> getSteinerTree() const;
 
  private:
-  GRNet* net_;
+  const GRNet* net_;
   const GridGraph* grid_graph_;
   SparseGraph graph_;
 

src/grt/src/cugr/src/Netlist.cpp

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

src/grt/src/cugr/src/Netlist.h

@@ -31,14 +31,14 @@ class CUGRPin
   std::string getName() const;
 
  private:
-  int index_;
+  const int index_;
   union
   {
     odb::dbITerm* iterm;
     odb::dbBTerm* bterm;
   };
   std::vector<BoxOnLayer> pin_shapes_;
-  bool is_port_;
+  const bool is_port_;
 };
 
 class CUGRNet
@@ -52,7 +52,7 @@ class CUGRNet
   std::string getName() const { return db_net_->getName(); }
 
  private:
-  int index_;
+  const int index_;
   odb::dbNet* db_net_;
   std::vector<CUGRPin> pins_;
 };

src/grt/src/cugr/src/PatternRoute.h

@@ -17,18 +17,12 @@ namespace grt {
 class SteinerTreeNode : public PointT
 {
  public:
-  SteinerTreeNode(PointT point) : PointT(point) {}
-  SteinerTreeNode(PointT point, IntervalT fixed_layers)
+  SteinerTreeNode(const PointT& point) : PointT(point) {}
+  SteinerTreeNode(const PointT& point, const IntervalT& fixed_layers)
       : PointT(point), fixed_layers_(fixed_layers)
   {
   }
 
-  static void preorder(
-      const std::shared_ptr<SteinerTreeNode>& node,
-      const std::function<void(std::shared_ptr<SteinerTreeNode>)>& visit);
-  static std::string getPythonString(
-      const std::shared_ptr<SteinerTreeNode>& node);
-
   IntervalT& getFixedLayers() { return fixed_layers_; }
 
   void setFixedLayers(const IntervalT& fixed_layers)
@@ -41,7 +35,10 @@ class SteinerTreeNode : public PointT
     children_.emplace_back(child);
   }
 
-  void removeChild(int index) { children_.erase(children_.begin() + index); }
+  void removeChild(const int index)
+  {
+    children_.erase(children_.begin() + index);
+  }
 
   std::vector<std::shared_ptr<SteinerTreeNode>>& getChildren()
   {
@@ -50,6 +47,12 @@ class SteinerTreeNode : public PointT
 
   int getNumChildren() const { return children_.size(); }
 
+  static void preorder(
+      const std::shared_ptr<SteinerTreeNode>& node,
+      const std::function<void(std::shared_ptr<SteinerTreeNode>)>& visit);
+  static std::string getPythonString(
+      const std::shared_ptr<SteinerTreeNode>& node);
+
  private:
   IntervalT fixed_layers_;
   std::vector<std::shared_ptr<SteinerTreeNode>> children_;
@@ -58,11 +61,15 @@ class SteinerTreeNode : public PointT
 class PatternRoutingNode : public PointT
 {
  public:
-  PatternRoutingNode(PointT point, int index, bool optional = false)
+  PatternRoutingNode(const PointT& point,
+                     const int index,
+                     const bool optional = false)
       : PointT(point), index_(index), optional_(optional)
   {
   }
-  PatternRoutingNode(PointT point, IntervalT fixed_layers, int index = 0)
+  PatternRoutingNode(const PointT& point,
+                     const IntervalT& fixed_layers,
+                     const int index = 0)
       : PointT(point),
         index_(index),
         fixed_layers_(fixed_layers),