Merge pull request #8344 from The-OpenROAD-Project-staging/cugr-refactor4

Cugr refactor4

Author: maliberty

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

@@ -352,12 +352,10 @@ CostT GridGraph::getViaCost(const int layer_index, const PointT loc) const
   return cost;
 }
 
-void GridGraph::selectAccessPoints(
-    const GRNet* net,
-    robin_hood::unordered_map<uint64_t, AccessPoint>& selected_access_points)
-    const
+AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
 {
-  selected_access_points.clear();
+  AccessPointHash hasher(y_size_);
+  AccessPointSet selected_access_points(0, hasher);
   // cell hash (2d) -> access point, fixed layer interval
   selected_access_points.reserve(net->getNumPins());
   const auto& boundingBox = net->getBoundingBox();
@@ -395,11 +393,9 @@ void GridGraph::selectAccessPoints(
       logger_->warn(utl::GRT, 274, "pin is hard to access.");
     }
     const PointT selectedPoint = accessPoints[bestIndex];
-    const uint64_t hash = hashCell(selectedPoint.x(), selectedPoint.y());
-    if (selected_access_points.find(hash) == selected_access_points.end()) {
-      selected_access_points.emplace(hash, AccessPoint{selectedPoint, {}});
-    }
-    IntervalT& fixedLayerInterval = selected_access_points[hash].layers;
+    const AccessPoint ap{selectedPoint, {}};
+    auto it = selected_access_points.emplace(ap).first;
+    IntervalT& fixedLayerInterval = it->layers;
     for (const auto& point : accessPoints) {
       if (point.x() == selectedPoint.x() && point.y() == selectedPoint.y()) {
         fixedLayerInterval.Update(point.getLayerIdx());
@@ -408,10 +404,11 @@ void GridGraph::selectAccessPoints(
   }
   // Extend the fixed layers to 2 layers higher to facilitate track switching
   for (auto& accessPoint : selected_access_points) {
-    IntervalT& fixedLayers = accessPoint.second.layers;
+    IntervalT& fixedLayers = accessPoint.layers;
     fixedLayers.SetHigh(
         std::min(fixedLayers.high() + 2, (int) getNumLayers() - 1));
   }
+  return selected_access_points;
 }
 
 void GridGraph::commit(const int layer_index,

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

@@ -21,6 +21,38 @@ class GRNet;
 template <typename Type>
 class GridGraphView;
 
+struct AccessPoint
+{
+  PointT point;
+  IntervalT layers;
+};
+
+// Only hash and compare on the point, not the layers
+class AccessPointHash
+{
+ public:
+  AccessPointHash(int y_size) : y_size_(y_size) {}
+
+  std::size_t operator()(const AccessPoint& ap) const
+  {
+    return robin_hood::hash_int(ap.point.x() * y_size_ + ap.point.y());
+  }
+
+ private:
+  const uint64_t y_size_;
+};
+
+struct AccessPointEqual
+{
+  bool operator()(const AccessPoint& lhs, const AccessPoint& rhs) const
+  {
+    return lhs.point == rhs.point;
+  }
+};
+
+using AccessPointSet
+    = robin_hood::unordered_set<AccessPoint, AccessPointHash, AccessPointEqual>;
+
 struct GraphEdge
 {
   CapacityT getResource() const { return capacity - demand; }
@@ -53,10 +85,6 @@ class GridGraph
     return ((uint64_t) point.getLayerIdx() * x_size_ + point.x()) * y_size_
            + point.y();
   };
-  uint64_t hashCell(const int x, const int y) const
-  {
-    return (uint64_t) x * y_size_ + y;
-  }
   int getGridline(const int dimension, const int index) const
   {
     return gridlines_[dimension][index];
@@ -75,15 +103,7 @@ class GridGraph
   CostT getUnitViaCost() const { return unit_via_cost_; }
 
   // Misc
-  struct AccessPoint
-  {
-    PointT point;
-    IntervalT layers;
-  };
-
-  void selectAccessPoints(const GRNet* net,
-                          robin_hood::unordered_map<uint64_t, AccessPoint>&
-                              selected_access_points) const;
+  AccessPointSet selectAccessPoints(const GRNet* net) const;
 
   // Methods for updating demands
   void commitTree(const std::shared_ptr<GRTreeNode>& tree, bool rip_up = false);

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

@@ -23,12 +23,10 @@ void SparseGraph::init(const GridGraphView<CostT>& wire_cost_view,
                        const SparseGrid& grid)
 {
   // 0. Create pseudo pins
-  robin_hood::unordered_map<uint64_t, GridGraph::AccessPoint>
-      selectedAccessPoints;
-  grid_graph_->selectAccessPoints(net_, selectedAccessPoints);
+  const auto selectedAccessPoints = grid_graph_->selectAccessPoints(net_);
   pseudo_pins_.reserve(selectedAccessPoints.size());
   for (const auto& selectedPoint : selectedAccessPoints) {
-    pseudo_pins_.push_back(selectedPoint.second);
+    pseudo_pins_.push_back(selectedPoint);
   }
 
   // 1. Collect additional routing grid lines

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

@@ -48,7 +48,7 @@ class SparseGraph
   void init(const GridGraphView<CostT>& wire_cost_view, const SparseGrid& grid);
   int getNumVertices() const { return vertices_.size(); }
   int getNumPseudoPins() const { return pseudo_pins_.size(); }
-  GridGraph::AccessPoint getPseudoPin(int pin_index) const
+  AccessPoint getPseudoPin(int pin_index) const
   {
     return pseudo_pins_[pin_index];
   }
@@ -81,7 +81,7 @@ class SparseGraph
   GRNet* net_;
   const GridGraph* grid_graph_;
 
-  std::vector<GridGraph::AccessPoint> pseudo_pins_;
+  std::vector<AccessPoint> pseudo_pins_;
 
   std::vector<int> xs_;
   std::vector<int> ys_;

src/grt/src/cugr/src/PatternRoute.cpp

@@ -79,24 +79,21 @@ std::string PatternRoutingNode::getPythonString(
 
 void PatternRoute::constructSteinerTree()
 {
-  robin_hood::unordered_map<uint64_t, GridGraph::AccessPoint>
-      selectedAccessPoints;
-  grid_graph_->selectAccessPoints(net_, selectedAccessPoints);
+  auto selectedAccessPoints = grid_graph_->selectAccessPoints(net_);
 
   const int degree = selectedAccessPoints.size();
   if (degree == 1) {
-    for (auto& accessPoint : selectedAccessPoints) {
-      steiner_tree_ = std::make_shared<SteinerTreeNode>(
-          accessPoint.second.point, accessPoint.second.layers);
-    }
+    const auto& accessPoint = *selectedAccessPoints.begin();
+    steiner_tree_ = std::make_shared<SteinerTreeNode>(accessPoint.point,
+                                                      accessPoint.layers);
     return;
   }
 
   std::vector<int> xs;
   std::vector<int> ys;
   for (auto& accessPoint : selectedAccessPoints) {
-    xs.push_back(accessPoint.second.point.x());
-    ys.push_back(accessPoint.second.point.y());
+    xs.push_back(accessPoint.point.x());
+    ys.push_back(accessPoint.point.y());
   }
 
   stt::Tree flutetree = stt_builder_->flute(xs, ys, flute_accuracy_);
@@ -139,10 +136,10 @@ void PatternRoute::constructSteinerTree()
             constructTree(current, curIndex, nextIndex);
           }
           // Set fixed layer interval
-          const uint64_t hash
-              = grid_graph_->hashCell(current->x(), current->y());
-          if (selectedAccessPoints.find(hash) != selectedAccessPoints.end()) {
-            current->setFixedLayers(selectedAccessPoints[hash].layers);
+          const AccessPoint current_pt{{current->x(), current->y()}, {}};
+          if (auto it = selectedAccessPoints.find(current_pt);
+              it != selectedAccessPoints.end()) {
+            current->setFixedLayers(it->layers);
           }
           // Connect current to parent
           if (parent == nullptr) {

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

@@ -20,11 +20,9 @@ using utl::format_as;
 class PointT
 {
  public:
-  PointT(int x = std::numeric_limits<int>::max(),
-         int y = std::numeric_limits<int>::max())
-      : x_(x), y_(y)
-  {
-  }
+  PointT() = default;
+  PointT(int x, int y) : x_(x), y_(y) {}
+
   bool IsValid() { return *this != PointT(); }
 
   int x() const { return x_; }
@@ -71,8 +69,8 @@ class PointT
   }
 
  private:
-  int x_;
-  int y_;
+  int x_{std::numeric_limits<int>::max()};
+  int y_{std::numeric_limits<int>::max()};
 };
 
 // Interval template