grt: change AccessPointMap to AccessPointSet

The (x,y) key is already part of the AccessPoint so no need to repeat
it when a custom equal_to works.

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

Author: maliberty

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

@@ -352,10 +352,10 @@ CostT GridGraph::getViaCost(const int layer_index, const PointT loc) const
   return cost;
 }
 
-GridGraph::AccessPointMap GridGraph::selectAccessPoints(const GRNet* net) const
+AccessPointSet GridGraph::selectAccessPoints(const GRNet* net) const
 {
-  PointHash hasher(y_size_);
-  AccessPointMap selected_access_points(0, hasher);
+  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();
@@ -393,11 +393,9 @@ GridGraph::AccessPointMap GridGraph::selectAccessPoints(const GRNet* net) const
       logger_->warn(utl::GRT, 274, "pin is hard to access.");
     }
     const PointT selectedPoint = accessPoints[bestIndex];
-    const PointT key{selectedPoint.x(), selectedPoint.y()};
-    if (selected_access_points.find(key) == selected_access_points.end()) {
-      selected_access_points.emplace(key, AccessPoint{selectedPoint, {}});
-    }
-    IntervalT& fixedLayerInterval = selected_access_points[key].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());
@@ -406,7 +404,7 @@ GridGraph::AccessPointMap GridGraph::selectAccessPoints(const GRNet* net) const
   }
   // 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));
   }

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

@@ -21,20 +21,38 @@ class GRNet;
 template <typename Type>
 class GridGraphView;
 
-class PointHash
+struct AccessPoint
+{
+  PointT point;
+  IntervalT layers;
+};
+
+// Only hash and compare on the point, not the layers
+class AccessPointHash
 {
  public:
-  PointHash(int y_size) : y_size_(y_size) {}
+  AccessPointHash(int y_size) : y_size_(y_size) {}
 
-  std::size_t operator()(const PointT& pt) const
+  std::size_t operator()(const AccessPoint& ap) const
   {
-    return robin_hood::hash_int(pt.x() * y_size_ + pt.y());
+    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; }
@@ -85,15 +103,7 @@ class GridGraph
   CostT getUnitViaCost() const { return unit_via_cost_; }
 
   // Misc
-  struct AccessPoint
-  {
-    PointT point;
-    IntervalT layers;
-  };
-
-  using AccessPointMap
-      = robin_hood::unordered_map<PointT, AccessPoint, PointHash>;
-  AccessPointMap selectAccessPoints(const GRNet* net) 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

@@ -26,7 +26,7 @@ void SparseGraph::init(const GridGraphView<CostT>& wire_cost_view,
   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

@@ -84,16 +84,16 @@ void PatternRoute::constructSteinerTree()
   const int degree = selectedAccessPoints.size();
   if (degree == 1) {
     const auto& accessPoint = *selectedAccessPoints.begin();
-    steiner_tree_ = std::make_shared<SteinerTreeNode>(
-        accessPoint.second.point, accessPoint.second.layers);
+    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_);
@@ -136,10 +136,10 @@ void PatternRoute::constructSteinerTree()
             constructTree(current, curIndex, nextIndex);
           }
           // Set fixed layer interval
-          const PointT current_pt{current->x(), current->y()};
-          if (selectedAccessPoints.find(current_pt)
-              != selectedAccessPoints.end()) {
-            current->setFixedLayers(selectedAccessPoints[current_pt].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) {