grt: Use custom hash function in AccessPointMap (cugr)

Avoid the clients having to hash themselves.

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

Author: maliberty

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

@@ -354,7 +354,8 @@ CostT GridGraph::getViaCost(const int layer_index, const PointT loc) const
 
 GridGraph::AccessPointMap GridGraph::selectAccessPoints(const GRNet* net) const
 {
-  AccessPointMap selected_access_points;
+  PointHash hasher(y_size_);
+  AccessPointMap selected_access_points(0, hasher);
   // cell hash (2d) -> access point, fixed layer interval
   selected_access_points.reserve(net->getNumPins());
   const auto& boundingBox = net->getBoundingBox();
@@ -392,11 +393,11 @@ GridGraph::AccessPointMap GridGraph::selectAccessPoints(const GRNet* net) const
       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, {}});
+    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[hash].layers;
+    IntervalT& fixedLayerInterval = selected_access_points[key].layers;
     for (const auto& point : accessPoints) {
       if (point.x() == selectedPoint.x() && point.y() == selectedPoint.y()) {
         fixedLayerInterval.Update(point.getLayerIdx());

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

@@ -21,6 +21,20 @@ class GRNet;
 template <typename Type>
 class GridGraphView;
 
+class PointHash
+{
+ public:
+  PointHash(int y_size) : y_size_(y_size) {}
+
+  std::size_t operator()(const PointT& pt) const
+  {
+    return robin_hood::hash_int(pt.x() * y_size_ + pt.y());
+  }
+
+ private:
+  const uint64_t y_size_;
+};
+
 struct GraphEdge
 {
   CapacityT getResource() const { return capacity - demand; }
@@ -53,10 +67,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];
@@ -81,7 +91,8 @@ class GridGraph
     IntervalT layers;
   };
 
-  using AccessPointMap = robin_hood::unordered_map<uint64_t, AccessPoint>;
+  using AccessPointMap
+      = robin_hood::unordered_map<PointT, AccessPoint, PointHash>;
   AccessPointMap selectAccessPoints(const GRNet* net) const;
 
   // Methods for updating demands

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

@@ -136,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 PointT current_pt{current->x(), current->y()};
+          if (selectedAccessPoints.find(current_pt)
+              != selectedAccessPoints.end()) {
+            current->setFixedLayers(selectedAccessPoints[current_pt].layers);
           }
           // Connect current to parent
           if (parent == nullptr) {