grt: fix minmax related lifetime issue

Lesson learned the hard way

auto [min_x, max_x] = std::minmax(node->x(), child->x());

if x() returns an int this does not work!  minmax returns a pair of
const int& that then go out of scope leaving min_x/max_x dangling.
Lifetime extension does not apply to the destructed binding.  Gemini
and chatgpt both failed to figure this out without me essentially
explaining it to them (repeatedly).

auto [min_x, max_x] = std::minmax({node->x(), child->x()});

does work as the initializer list form returns a pair of ints which
get copied.  The joys of c++...

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

Author: maliberty

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

@@ -204,8 +204,8 @@ NetRouteMap CUGR::getRoutes()
           routing_tree, [&](const std::shared_ptr<GRTreeNode>& node) {
             for (const auto& child : node->children) {
               if (node->getLayerIdx() == child->getLayerIdx()) {
-                auto [min_x, max_x] = std::minmax(node->x(), child->x());
-                auto [min_y, max_y] = std::minmax(node->y(), child->y());
+                auto [min_x, max_x] = std::minmax({node->x(), child->x()});
+                auto [min_y, max_y] = std::minmax({node->y(), child->y()});
                 GSegment segment(
                     grid_graph_->getGridline(0, min_x) + half_gcell_size,
                     grid_graph_->getGridline(1, min_y) + half_gcell_size,

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

@@ -306,12 +306,12 @@ CostT GridGraph::getWireCost(const int layer_index,
   assert(u[1 - direction] == v[1 - direction]);
   CostT cost = 0;
   if (direction == MetalLayer::H) {
-    const auto [l, h] = std::minmax(u.x(), v.x());
+    const auto [l, h] = std::minmax({u.x(), v.x()});
     for (int x = l; x < h; x++) {
       cost += getWireCost(layer_index, {x, u.y()});
     }
   } else {
-    const auto [l, h] = std::minmax(u.y(), v.y());
+    const auto [l, h] = std::minmax({u.y(), v.y()});
     for (int y = l; y < h; y++) {
       cost += getWireCost(layer_index, {u.x(), y});
     }
@@ -471,14 +471,14 @@ void GridGraph::commitTree(const std::shared_ptr<GRTreeNode>& tree,
       if (node->getLayerIdx() == child->getLayerIdx()) {
         unsigned direction = layer_directions_[node->getLayerIdx()];
         if (direction == MetalLayer::H) {
-          assert(node->y == child->y);
-          const auto [l, h] = std::minmax(node->x(), child->x());
+          assert(node->y() == child->y());
+          const auto [l, h] = std::minmax({node->x(), child->x()});
           for (int x = l; x < h; x++) {
             commitWire(node->getLayerIdx(), {x, node->y()}, reverse);
           }
         } else {
-          assert(node->x == child->x);
-          const auto [l, h] = std::minmax(node->y(), child->y());
+          assert(node->x() == child->x());
+          const auto [l, h] = std::minmax({node->y(), child->y()});
           for (int y = l; y < h; y++) {
             commitWire(node->getLayerIdx(), {node->x(), y}, reverse);
           }
@@ -502,16 +502,16 @@ int GridGraph::checkOverflow(const int layer_index,
   int num = 0;
   unsigned direction = layer_directions_[layer_index];
   if (direction == MetalLayer::H) {
-    assert(u.y == v.y);
-    const auto [l, h] = std::minmax(u.x(), v.x());
+    assert(u.y() == v.y());
+    const auto [l, h] = std::minmax({u.x(), v.x()});
     for (int x = l; x < h; x++) {
       if (checkOverflow(layer_index, x, u.y())) {
         num++;
       }
     }
   } else {
-    assert(u.x == v.x);
-    const auto [l, h] = std::minmax(u.y(), v.y());
+    assert(u.x() == v.x());
+    const auto [l, h] = std::minmax({u.y(), v.y()});
     for (int y = l; y < h; y++) {
       if (checkOverflow(layer_index, u.x(), y)) {
         num++;
@@ -717,14 +717,14 @@ void GridGraph::updateWireCostView(
           if (node->getLayerIdx() == child->getLayerIdx()) {
             unsigned direction = getLayerDirection(node->getLayerIdx());
             if (direction == MetalLayer::H) {
-              assert(node->y == child->y);
+              assert(node->y() == child->y());
               int l = std::min(node->x(), child->x()),
                   h = std::max(node->x(), child->x());
               for (int x = l; x < h; x++) {
                 update(direction, x, node->y());
               }
             } else {
-              assert(node->x == child->x);
+              assert(node->x() == child->x());
               int l = std::min(node->y(), child->y()),
                   h = std::max(node->y(), child->y());
               for (int y = l; y < h; y++) {

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

@@ -167,16 +167,16 @@ class GridGraphView : public std::vector<std::vector<std::vector<Type>>>
  public:
   bool check(const PointT& u, const PointT& v) const
   {
-    assert(u.x == v.x || u.y == v.y);
+    assert(u.x() == v.x() || u.y() == v.y());
     if (u.y() == v.y()) {
-      const auto [l, h] = std::minmax(u.x(), v.x());
+      const auto [l, h] = std::minmax({u.x(), v.x()});
       for (int x = l; x < h; x++) {
         if ((*this)[MetalLayer::H][x][u.y()]) {
           return true;
         }
       }
     } else {
-      const auto [l, h] = std::minmax(u.y(), v.y());
+      const auto [l, h] = std::minmax({u.y(), v.y()});
       for (int y = l; y < h; y++) {
         if ((*this)[MetalLayer::V][u.x()][y]) {
           return true;
@@ -188,15 +188,15 @@ class GridGraphView : public std::vector<std::vector<std::vector<Type>>>
 
   Type sum(const PointT& u, const PointT& v) const
   {
-    assert(u.x == v.x || u.y == v.y);
+    assert(u.x() == v.x() || u.y() == v.y());
     Type res = 0;
     if (u.y() == v.y()) {
-      const auto [l, h] = std::minmax(u.x(), v.x());
+      const auto [l, h] = std::minmax({u.x(), v.x()});
       for (int x = l; x < h; x++) {
         res += (*this)[MetalLayer::H][x][u.y()];
       }
     } else {
-      const auto [l, h] = std::minmax(u.y(), v.y());
+      const auto [l, h] = std::minmax({u.y(), v.y()});
       for (int y = l; y < h; y++) {
         res += (*this)[MetalLayer::V][u.x()][y];
       }