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

grt: minor refactoring cugr code

Author: maliberty

src/grt/BUILD

@@ -96,14 +96,9 @@ cc_library(
     ],
     deps = [
         ":groute",
-        "//src/dbSta",
         "//src/odb",
         "//src/stt",
         "//src/utl",
-        "@boost.container_hash",
-        "@boost.geometry",
-        "@boost.icl",
-        "@boost.multi_array",
     ],
 )
 

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

@@ -1,9 +1,5 @@
 #pragma once
 
-#include "geo.h"
-#include "grt/GRoute.h"
-
-// STL libraries
 #include <bitset>
 #include <csignal>
 #include <fstream>
@@ -16,13 +12,8 @@
 #include <tuple>
 #include <vector>
 
-// Boost libraries
-// #include <boost/functional/hash.hpp>
-#include <boost/geometry.hpp>
-#include <boost/geometry/geometries/box.hpp>
-#include <boost/geometry/geometries/point.hpp>
-#include <boost/geometry/index/rtree.hpp>
-
+#include "geo.h"
+#include "grt/GRoute.h"
 #include "odb/geom.h"
 
 namespace odb {
@@ -43,37 +34,30 @@ class Design;
 class GridGraph;
 class GRNet;
 
-namespace bg = boost::geometry;
-namespace bgi = boost::geometry::index;
-
-using boostPoint = bg::model::point<int, 2, bg::cs::cartesian>;
-using boostBox = bg::model::box<boostPoint>;
-using RTree = bgi::rtree<std::pair<boostBox, int>, bgi::rstar<32>>;
-
 struct Constants
 {
-  double weight_wire_length;
-  double weight_via_number;
-  double weight_short_area;
+  double weight_wire_length = 0.5;
+  double weight_via_number = 4.0;
+  double weight_short_area = 500.0;
 
-  int min_routing_layer;
+  int min_routing_layer = 1;
 
-  double cost_logistic_slope;
+  double cost_logistic_slope = 1.0;
 
   // allowed stem length increase to trunk length ratio
-  double max_detour_ratio;
-  int target_detour_count;
+  double max_detour_ratio = 0.25;
+  int target_detour_count = 20;
 
-  double via_multiplier;
+  double via_multiplier = 2.0;
 
-  double maze_logistic_slope;
+  double maze_logistic_slope = 0.5;
 
-  double pin_patch_threshold;
-  int pin_patch_padding;
-  double wire_patch_threshold;
-  double wire_patch_inflation_rate;
+  double pin_patch_threshold = 20.0;
+  int pin_patch_padding = 1;
+  double wire_patch_threshold = 2.0;
+  double wire_patch_inflation_rate = 1.2;
 
-  bool write_heatmap;
+  bool write_heatmap = false;
 };
 
 class CUGR
@@ -93,8 +77,8 @@ class CUGR
                  std::vector<std::pair<int, grt::BoxT<int>>>& guides);
   void printStatistics() const;
 
-  Design* design_;
-  GridGraph* grid_graph_;
+  Design* design_ = nullptr;
+  GridGraph* grid_graph_ = nullptr;
   std::vector<GRNet*> gr_nets_;
 
   odb::dbDatabase* db_;
@@ -103,8 +87,8 @@ class CUGR
 
   Constants constants_;
 
-  int area_of_pin_patches_;
-  int area_of_wire_patches_;
+  int area_of_pin_patches_ = 0;
+  int area_of_wire_patches_ = 0;
 };
 
-}  // namespace grt
+}  // namespace grt

src/grt/src/cugr/include/geo.h

@@ -58,7 +58,7 @@ class PointT
   bool operator==(const PointT& rhs) const { return x == rhs.x && y == rhs.y; }
   bool operator!=(const PointT& rhs) const { return !(*this == rhs); }
 
-  friend inline std::ostream& operator<<(std::ostream& os, const PointT& pt)
+  friend std::ostream& operator<<(std::ostream& os, const PointT& pt)
   {
     os << "(" << pt.x << ", " << pt.y << ")";
     return os;
@@ -67,21 +67,21 @@ class PointT
 
 // L-1 (Manhattan) distance between points
 template <typename T>
-inline T Dist(const PointT<T>& pt1, const PointT<T>& pt2)
+T Dist(const PointT<T>& pt1, const PointT<T>& pt2)
 {
   return std::abs(pt1.x - pt2.x) + std::abs(pt1.y - pt2.y);
 }
 
 // L-2 (Euclidean) distance between points
 template <typename T>
-inline double L2Dist(const PointT<T>& pt1, const PointT<T>& pt2)
+double L2Dist(const PointT<T>& pt1, const PointT<T>& pt2)
 {
   return std::sqrt(std::pow(pt1.x - pt2.x, 2) + std::pow(pt1.y - pt2.y, 2));
 }
 
 // L-inf distance between points
 template <typename T>
-inline T LInfDist(const PointT<T>& pt1, const PointT<T>& pt2)
+T LInfDist(const PointT<T>& pt1, const PointT<T>& pt2)
 {
   return std::max(std::abs(pt1.x - pt2.x), std::abs(pt1.y - pt2.y));
 }
@@ -226,8 +226,8 @@ class IntervalT
   }
   bool operator!=(const IntervalT& rhs) const { return !(*this == rhs); }
 
-  friend inline std::ostream& operator<<(std::ostream& os,
-                                         const IntervalT<T>& interval)
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const IntervalT<T>& interval)
   {
     os << "(" << interval.low << ", " << interval.high << ")";
     return os;
@@ -236,13 +236,13 @@ class IntervalT
 
 // Distance between intervals/points (assume valid intervals)
 template <typename T>
-inline T Dist(const IntervalT<T>& intvl, const T val)
+T Dist(const IntervalT<T>& intvl, const T val)
 {
   return std::abs(intvl.GetNearestPointTo(val) - val);
 }
 
 template <typename T>
-inline T Dist(const IntervalT<T>& int1, const IntervalT<T>& int2)
+T Dist(const IntervalT<T>& int1, const IntervalT<T>& int2)
 {
   if (int1.high <= int2.low) {
     return int2.low - int1.high;
@@ -391,7 +391,7 @@ class BoxT
   }
   bool operator!=(const BoxT& rhs) const { return !(*this == rhs); }
 
-  friend inline std::ostream& operator<<(std::ostream& os, const BoxT<T>& box)
+  friend std::ostream& operator<<(std::ostream& os, const BoxT<T>& box)
   {
     os << "[x: " << box.x << ", y: " << box.y << "]";
     return os;
@@ -400,34 +400,34 @@ class BoxT
 
 // L-1 (Manhattan) distance between boxes/points (assume valid boxes)
 template <typename T>
-inline T Dist(const BoxT<T>& box, const PointT<T>& point)
+T Dist(const BoxT<T>& box, const PointT<T>& point)
 {
   return Dist(box.x, point.x) + Dist(box.y, point.y);
 }
 template <typename T>
-inline T Dist(const BoxT<T>& box1, const BoxT<T>& box2)
+T Dist(const BoxT<T>& box1, const BoxT<T>& box2)
 {
   return Dist(box1.x, box2.x) + Dist(box1.y, box2.y);
 }
 
 // L-2 (Euclidean) distance between boxes
 template <typename T>
-inline double L2Dist(const BoxT<T>& box1, const BoxT<T>& box2)
+double L2Dist(const BoxT<T>& box1, const BoxT<T>& box2)
 {
   return std::sqrt(std::pow(Dist(box1.x, box2.x), 2)
                    + std::pow(Dist(box1.y, box2.y), 2));
 }
 
 // L-Inf (max) distance between boxes
 template <typename T>
-inline T LInfDist(const BoxT<T>& box1, const BoxT<T>& box2)
+T LInfDist(const BoxT<T>& box1, const BoxT<T>& box2)
 {
   return std::max(Dist(box1.x, box2.x), Dist(box1.y, box2.y));
 }
 
 //  Parallel run length between boxes
 template <typename T>
-inline T ParaRunLength(const BoxT<T>& box1, const BoxT<T>& box2)
+T ParaRunLength(const BoxT<T>& box1, const BoxT<T>& box2)
 {
   return std::max(box1.x.ParaRunLength(box2.x), box1.y.ParaRunLength(box2.y));
 }

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

@@ -18,20 +18,6 @@ CUGR::CUGR(odb::dbDatabase* db,
            stt::SteinerTreeBuilder* stt_builder)
     : db_(db), logger_(log), stt_builder_(stt_builder)
 {
-  constants_.weight_wire_length = 0.5;
-  constants_.weight_via_number = 4.0;
-  constants_.weight_short_area = 500.0;
-  constants_.min_routing_layer = 1;
-  constants_.cost_logistic_slope = 1.0;
-  constants_.max_detour_ratio = 0.25;
-  constants_.target_detour_count = 20;
-  constants_.via_multiplier = 2.0;
-  constants_.maze_logistic_slope = 0.5;
-  constants_.pin_patch_threshold = 20.0;
-  constants_.pin_patch_padding = 1;
-  constants_.wire_patch_threshold = 2.0;
-  constants_.wire_patch_inflation_rate = 1.2;
-  constants_.write_heatmap = false;
 }
 
 void CUGR::init(const int min_routing_layer, const int max_routing_layer)

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

@@ -262,8 +262,7 @@ int GridGraph::getEdgeLength(unsigned direction, unsigned edge_index) const
          - grid_centers_[direction][edge_index];
 }
 
-inline double GridGraph::logistic(const CapacityT& input,
-                                  const double slope) const
+double GridGraph::logistic(const CapacityT& input, const double slope) const
 {
   return 1.0 / (1.0 + exp(input * slope));
 }

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

@@ -16,48 +16,45 @@ struct GraphEdge
   CapacityT capacity{0};
   CapacityT demand{0};
 
-  GraphEdge() = default;
   CapacityT getResource() const { return capacity - demand; }
 };
 
 class GridGraph
 {
  public:
   GridGraph(const Design* design, const Constants& constants);
-  inline int getLibDBU() const { return lib_dbu_; }
-  inline int getM2Pitch() const { return m2_pitch_; }
-  inline unsigned getNumLayers() const { return num_layers_; }
-  inline unsigned getSize(unsigned dimension) const
+  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_);
   }
-  inline std::string getLayerName(int layer_index) const
+  std::string getLayerName(int layer_index) const
   {
     return layer_names_[layer_index];
   }
-  inline unsigned getLayerDirection(int layer_index) const
+  unsigned getLayerDirection(int layer_index) const
   {
     return layer_directions_[layer_index];
   }
 
-  inline uint64_t hashCell(const GRPoint& point) const
+  uint64_t hashCell(const GRPoint& point) const
   {
     return ((uint64_t) point.getLayerIdx() * x_size_ + point.x) * y_size_
            + point.y;
   };
-  inline uint64_t hashCell(const int x, const int y) const
+  uint64_t hashCell(const int x, const int y) const
   {
     return (uint64_t) x * y_size_ + y;
   }
-  inline int getGridline(const unsigned dimension, const int index) const
+  int getGridline(const unsigned dimension, const int index) const
   {
     return gridlines_[dimension][index];
   }
   BoxT<int> getCellBox(PointT<int> point) const;
   BoxT<int> rangeSearchCells(const BoxT<int>& box) const;
-  inline GraphEdge getEdge(const int layer_index,
-                           const int x,
-                           const int y) const
+  GraphEdge getEdge(const int layer_index, const int x, const int y) const
   {
     return graph_edges_[layer_index][x][y];
   }
@@ -66,7 +63,7 @@ class GridGraph
   int getEdgeLength(unsigned direction, unsigned edge_index) const;
   CostT getWireCost(int layer_index, PointT<int> u, PointT<int> v) const;
   CostT getViaCost(int layer_index, PointT<int> loc) const;
-  inline CostT getUnitViaCost() const { return unit_via_cost_; }
+  CostT getUnitViaCost() const { return unit_via_cost_; }
 
   // Misc
   void selectAccessPoints(
@@ -80,7 +77,7 @@ class GridGraph
                   bool reverse = false);
 
   // Checks
-  inline bool checkOverflow(int layer_index, int x, int y) const
+  bool checkOverflow(int layer_index, int x, int y) const
   {
     return getEdge(layer_index, x, y).getResource() < 0.0;
   }
@@ -137,14 +134,14 @@ class GridGraph
   // Find the rows/columns overlapping with [locInterval.low, locInterval.high]
 
   // Utility functions for cost calculation
-  inline CostT getUnitLengthWireCost() const { return unit_length_wire_cost_; }
+  CostT getUnitLengthWireCost() const { return unit_length_wire_cost_; }
   // CostT getUnitViaCost() const { return unit_via_cost_; }
-  inline CostT getUnitLengthShortCost(int layer_index) const
+  CostT getUnitLengthShortCost(int layer_index) const
   {
     return unit_length_short_costs_[layer_index];
   }
 
-  inline double logistic(const CapacityT& input, double slope) const;
+  double logistic(const CapacityT& input, double slope) const;
   CostT getWireCost(int layer_index,
                     PointT<int> lower,
                     CapacityT demand = 1.0) const;

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

@@ -67,7 +67,7 @@ class SparseGraph
   GRPoint getPoint(const int vertex) const { return vertices_[vertex]; }
 
  private:
-  inline int getVertexIndex(int direction, int xi, int yi) const
+  int getVertexIndex(int direction, int xi, int yi) const
   {
     return direction * xs_.size() * ys_.size() + yi * xs_.size() + xi;
   }