refactor chan node adjacency checks

soheilshahrouz · soheilshahrouz · commit fff2dc571f40 · 2025-07-05T20:17:37.000-04:00
diff --git a/libs/librrgraph/src/base/rr_graph_utils.cpp b/libs/librrgraph/src/base/rr_graph_utils.cpp
@@ -3,6 +3,7 @@
 #include "vpr_error.h"
 #include "rr_graph_obj.h"
 #include "rr_graph_builder.h"
+#include "rr_graph_view.h"
 
 /*
  * @brief Walk backwards from origin SINK, and insert all cluster-edge IPINs to which origin is connected to sink_ipins
@@ -255,3 +256,130 @@ bool inter_layer_connections_limited_to_opin(const RRGraphView& rr_graph) {
 
     return limited_to_opin;
 }
+
+bool chanx_chany_nodes_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2) {
+    e_rr_type type1 = rr_graph.node_type(node1);
+    e_rr_type type2 = rr_graph.node_type(node2);
+    VTR_ASSERT((type1 == e_rr_type::CHANX && type2 == e_rr_type::CHANY) || (type1 == e_rr_type::CHANY && type2 == e_rr_type::CHANX));
+
+    // Make sure node1 is CHANX for consistency
+    if (type1 == e_rr_type::CHANY) {
+        std::swap(node1, node2);
+        std::swap(type1, type2);
+    }
+
+    RRNodeId chanx_node = node1;
+    RRNodeId chany_node = node2;
+
+    // Check vertical (Y) adjacency
+    if (rr_graph.node_ylow(chany_node) > rr_graph.node_ylow(chanx_node) + 1 ||
+        rr_graph.node_yhigh(chany_node) < rr_graph.node_ylow(chanx_node)) {
+        return false;
+    }
+
+    // Check horizontal (X) adjacency
+    if (rr_graph.node_xlow(chanx_node) > rr_graph.node_xlow(chany_node) + 1 ||
+        rr_graph.node_xhigh(chanx_node) < rr_graph.node_xlow(chany_node)) {
+        return false;
+    }
+
+    return true;
+}
+
+bool chanxy_chanz_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2) {
+    e_rr_type type1 = rr_graph.node_type(node1);
+    e_rr_type type2 = rr_graph.node_type(node2);
+
+    // Ensure one is CHANZ, the other is CHANX or CHANY
+    VTR_ASSERT((type1 == e_rr_type::CHANZ && (type2 == e_rr_type::CHANX || type2 == e_rr_type::CHANY))
+               || (type2 == e_rr_type::CHANZ && (type1 == e_rr_type::CHANX || type1 == e_rr_type::CHANY)));
+
+    // Make sure chanz_node is second for unified handling
+    if (type1 == e_rr_type::CHANZ) {
+        std::swap(node1, node2);
+        std::swap(type1, type2);
+    }
+
+    // node1 is CHANX or CHANY, node2 is CHANZ
+    RRNodeId chanxy_node = node1;
+    RRNodeId chanz_node = node2;
+    e_rr_type chanxy_node_type = type1;
+
+    int chanz_x = rr_graph.node_xlow(chanz_node);
+    int chanz_y = rr_graph.node_ylow(chanz_node);
+    VTR_ASSERT_SAFE(chanz_x == rr_graph.node_xhigh(chanz_node));
+    VTR_ASSERT_SAFE(chanz_y == rr_graph.node_yhigh(chanz_node));
+
+    if (chanxy_node_type == e_rr_type::CHANX) {
+        // CHANX runs horizontally: match Y, overlap X
+        return chanz_y == rr_graph.node_ylow(chanxy_node)
+               && chanz_x >= rr_graph.node_xlow(chanxy_node) - 1
+               && chanz_x <= rr_graph.node_xhigh(chanxy_node) + 1;
+    } else {
+        // CHANY runs vertically: match X, overlap Y
+        return chanz_x == rr_graph.node_xlow(chanxy_node)
+               && chanz_y >= rr_graph.node_ylow(chanxy_node) - 1
+               && chanz_y <= rr_graph.node_yhigh(chanxy_node) + 1;
+    }
+}
+
+bool chan_same_type_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2) {
+    e_rr_type type = rr_graph.node_type(node1);
+    VTR_ASSERT(type == rr_graph.node_type(node2));
+
+    int xlow1 = rr_graph.node_xlow(node1);
+    int xhigh1 = rr_graph.node_xhigh(node1);
+    int ylow1 = rr_graph.node_ylow(node1);
+    int yhigh1 = rr_graph.node_yhigh(node1);
+    int layer1 = rr_graph.node_layer(node1);
+
+    int xlow2 = rr_graph.node_xlow(node2);
+    int xhigh2 = rr_graph.node_xhigh(node2);
+    int ylow2 = rr_graph.node_ylow(node2);
+    int yhigh2 = rr_graph.node_yhigh(node2);
+    int layer2 = rr_graph.node_layer(node2);
+
+    if (type == e_rr_type::CHANX) {
+        if (ylow1 != ylow2) {
+            return false;
+        }
+
+        // Adjacent ends or overlapping segments
+        if (xhigh1 == xlow2 - 1 || xhigh2 == xlow1 - 1) {
+            return true;
+        }
+
+        for (int x = xlow1; x <= xhigh1; ++x) {
+            if (x >= xlow2 && x <= xhigh2) {
+                return true;
+            }
+        }
+        return false;
+
+    } else if (type == e_rr_type::CHANY) {
+        if (xlow1 != xlow2) {
+            return false;
+        }
+
+        if (yhigh1 == ylow2 - 1 || yhigh2 == ylow1 - 1) {
+            return true;
+        }
+
+        for (int y = ylow1; y <= yhigh1; ++y) {
+            if (y >= ylow2 && y <= yhigh2) {
+                return true;
+            }
+        }
+        return false;
+
+    } else if (type == e_rr_type::CHANZ) {
+        // Same X/Y span, adjacent layer
+        bool same_xy = (xlow1 == xlow2 && xhigh1 == xhigh2 && ylow1 == ylow2 && yhigh1 == yhigh2);
+        bool adjacent_layer = std::abs(layer1 - layer2) == 1;
+        return same_xy && adjacent_layer;
+    } else {
+        VTR_ASSERT_MSG(false, "Unexpected RR node type in chan_same_type_are_adjacent().\n");
+    }
+
+    return false; // unreachable
+}
diff --git a/libs/librrgraph/src/base/rr_graph_utils.h b/libs/librrgraph/src/base/rr_graph_utils.h
@@ -5,16 +5,14 @@
  * @brief This file includes the most-utilized functions that manipulate the RRGraph object.
  */
 
-/* Include header files which include data structures used by
- * the function declaration
- */
 #include <vector>
 #include "rr_graph_builder.h"
 #include "rr_graph_fwd.h"
 #include "rr_node_types.h"
-#include "rr_graph_view.h"
 #include "device_grid.h"
 
+class RRGraphView;
+
 struct t_pin_chain_node {
     int pin_physical_num = OPEN;
     int nxt_node_idx = OPEN;
@@ -93,8 +91,36 @@ int seg_index_of_sblock(const RRGraphView& rr_graph, int from_node, int to_node)
  * if that is the case. Can be used for multiple purposes. For example, to determine which type of bounding
  * box to be used to estimate the wire-length of a net.
  *
- * @param rr_graph
+ * @param rr_graph The routing resource graph
  *
  * @return limited_to_opin
  */
 bool inter_layer_connections_limited_to_opin(const RRGraphView& rr_graph);
+
+/**
+ * @brief Check if a CHANX and a CHANY node are adjacent, regardless of their order.
+ *
+ * This function checks spatial adjacency between a CHANX and CHANY node without assuming
+ * any particular input order. If the node types are not one CHANX and one CHANY, an error is thrown.
+ *
+ * @param rr_graph The routing resource graph
+ * @param node1 One of the nodes (CHANX or CHANY)
+ * @param node2 The other node (CHANX or CHANY)
+ * @return true if the nodes are spatially adjacent, false otherwise
+ */
+bool chanx_chany_nodes_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2);
+
+/**
+ * @brief Check if a CHANX or CHANY node is adjacent to a CHANZ node.
+ *
+ * @param rr_graph The routing resource graph
+ * @param node1 One of the RR nodes (CHANX, CHANY, or CHANZ)
+ * @param node2 The other RR node
+ * @return true if spatially adjacent, false otherwise
+ *
+ * @note Exactly one node must be CHANZ; the other must be CHANX or CHANY.
+ */
+bool chanxy_chanz_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2);
+
+bool chan_same_type_are_adjacent(const RRGraphView& rr_graph, RRNodeId node1, RRNodeId node2);
+
diff --git a/libs/librrgraph/src/base/rr_graph_view.h b/libs/librrgraph/src/base/rr_graph_view.h
@@ -59,6 +59,7 @@
 #include "physical_types.h"
 #include "rr_spatial_lookup.h"
 #include "vtr_geometry.h"
+#include "rr_graph_utils.h"
 
 class RRGraphView {
     /* -- Constructors -- */
@@ -262,19 +263,37 @@ class RRGraphView {
                  && (node_xhigh(node) == -1) && (node_yhigh(node) == -1));
     }
 
-    /** @brief Check if two routing resource nodes are adjacent (must be a CHANX and a CHANY). 
-     * @note This function performs error checking by determining whether two nodes are physically adjacent based on their geometry.
-     * It does not verify the routing edges to confirm if a connection is feasible within the current routing graph.
+    /**
+     * @brief Check if two CHANX, CHANY, or CHANZ nodes are spatially adjacent.
+     * @param node1 First routing resource node
+     * @param node2 Second routing resource node
+     * @return true if the nodes are adjacent, false otherwise
      */
-    inline bool nodes_are_adjacent(RRNodeId chanx_node, RRNodeId chany_node) const {
-        VTR_ASSERT(node_type(chanx_node) == e_rr_type::CHANX && node_type(chany_node) == e_rr_type::CHANY);
-        if (node_ylow(chany_node) > node_ylow(chanx_node) + 1 || // verifies that chany_node is not more than one unit above chanx_node
-            node_yhigh(chany_node) < node_ylow(chanx_node))      // verifies that chany_node is not more than one unit beneath chanx_node
-            return false;
-        if (node_xlow(chanx_node) > node_xlow(chany_node) + 1 || // verifies that chany_node is not more than one unit to the left of chanx_node
-            node_xhigh(chanx_node) < node_xlow(chany_node))      // verifies that chany_node is not more than one unit to the right of chanx_node
-            return false;
-        return true;
+    inline bool chan_nodes_are_adjacent(RRNodeId node1, RRNodeId node2) const {
+        e_rr_type type1 = node_type(node1);
+        e_rr_type type2 = node_type(node2);
+        VTR_ASSERT(type1 == e_rr_type::CHANX || type1 == e_rr_type::CHANY || type1 == e_rr_type::CHANZ);
+        VTR_ASSERT(type2 == e_rr_type::CHANX || type2 == e_rr_type::CHANY || type2 == e_rr_type::CHANZ);
+
+        if ((type1 == e_rr_type::CHANX && type2 == e_rr_type::CHANY)
+            || (type1 == e_rr_type::CHANY && type2 == e_rr_type::CHANX)) {
+            return chanx_chany_nodes_are_adjacent(*this, node1, node2);
+        }
+
+        // CHANX/CHANY to CHANZ (in any order)
+        if ((type1 == e_rr_type::CHANZ || type2 == e_rr_type::CHANZ) &&
+            (type1 == e_rr_type::CHANX || type1 == e_rr_type::CHANY ||
+             type2 == e_rr_type::CHANX || type2 == e_rr_type::CHANY)) {
+            return chanxy_chanz_adjacent(*this, node1, node2);
+        }
+
+        // Same-type channel nodes (CHANX–CHANX, CHANY–CHANY, CHANZ–CHANZ)
+        if (type1 == type2) {
+            return chan_same_type_are_adjacent(*this, node1, node2);
+        }
+
+        VTR_ASSERT_MSG(false, "Invalid CHAN node combination passed to chan_nodes_are_adjacent()");
+        return false;
     }
 
     /**
diff --git a/vpr/src/route/check_route.cpp b/vpr/src/route/check_route.cpp
@@ -84,12 +84,6 @@ static void check_net_for_stubs(const Netlist<>& net_list,
                                 ParentNetId net,
                                 bool is_flat);
 
-/**
- * @brief Returns true if the given CHANX or CHANY node is adjacent to the given CHANZ node.
- * @note Only performs geometric adjacency check; does not validate routing connectivity.
- */
-static bool chanxy_chanz_adjacent(RRNodeId chanxy_node, RRNodeId chanz_node);
-
 /************************ Subroutine definitions ****************************/
 
 void check_route(const Netlist<>& net_list,
@@ -420,27 +414,9 @@ static bool check_adjacent(RRNodeId from_node, RRNodeId to_node, bool is_flat) {
 
         case e_rr_type::CHANX:
             if (to_type == e_rr_type::IPIN) {
-                num_adj += 1; //adjacent
-            } else if (to_type == e_rr_type::CHANX) {
-                from_xhigh = rr_graph.node_xhigh(from_node);
-                to_xhigh = rr_graph.node_xhigh(to_node);
-                if (from_ylow == to_ylow) {
-                    /*For Fs > 3, can connect to overlapping wire segment */
-                    if (to_xhigh == from_xlow - 1 || from_xhigh == to_xlow - 1) {
-                        num_adj++;
-                    } else { // Overlapping
-                        for (int i = from_xlow; i <= from_xhigh; i++) {
-                            if (i >= to_xlow && i <= to_xhigh) {
-                                num_adj++;
-                                break;
-                            }
-                        }
-                    }
-                }
-            } else if (to_type == e_rr_type::CHANY) {
-                num_adj += rr_graph.nodes_are_adjacent(from_node, to_node);
-            } else if (to_type == e_rr_type::CHANZ) {
-                num_adj += chanxy_chanz_adjacent(from_node, to_node);
+                num_adj += 1; // adjacent
+            } else if (to_type == e_rr_type::CHANX || to_type == e_rr_type::CHANY || to_type == e_rr_type::CHANZ) {
+                num_adj += rr_graph.chan_nodes_are_adjacent(from_node, to_node);
             } else {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_adjacent: %d and %d are not adjacent", from_node, to_node);
@@ -449,39 +425,18 @@ static bool check_adjacent(RRNodeId from_node, RRNodeId to_node, bool is_flat) {
 
         case e_rr_type::CHANY:
             if (to_type == e_rr_type::IPIN) {
-                num_adj += 1; //adjacent
-            } else if (to_type == e_rr_type::CHANY) {
-                from_yhigh = rr_graph.node_yhigh(from_node);
-                to_yhigh = rr_graph.node_yhigh(to_node);
-                if (from_xlow == to_xlow) {
-                    if (to_yhigh == from_ylow - 1 || from_yhigh == to_ylow - 1) {
-                        num_adj++;
-                    } else { // Overlapping
-                        for (int j = from_ylow; j <= from_yhigh; j++) {
-                            if (j >= to_ylow && j <= to_yhigh) {
-                                num_adj++;
-                                break;
-                            }
-                        }
-                    }
-                }
-            } else if (to_type == e_rr_type::CHANX) {
-                num_adj += rr_graph.nodes_are_adjacent(to_node, from_node);
-            } else if (to_type == e_rr_type::CHANZ) {
-                num_adj += chanxy_chanz_adjacent(from_node, to_node);
+                num_adj += 1; // adjacent
+            } else if (to_type == e_rr_type::CHANX || to_type == e_rr_type::CHANY || to_type == e_rr_type::CHANZ) {
+                num_adj += rr_graph.chan_nodes_are_adjacent(from_node, to_node);
             } else {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_adjacent: %d and %d are not adjacent", from_node, to_node);
             }
             break;
 
         case e_rr_type::CHANZ:
-            if (to_type == e_rr_type::CHANX || to_type == e_rr_type::CHANY) {
-                num_adj += chanxy_chanz_adjacent(to_node, from_node);
-            } else if (to_type == e_rr_type::CHANZ) {
-                if (from_xlow == to_xlow && from_xhigh == to_xhigh && from_ylow == to_ylow && from_yhigh == to_yhigh && std::abs(from_layer - to_layer) == 1) {
-                    num_adj++;
-                }
+            if (to_type == e_rr_type::CHANX || to_type == e_rr_type::CHANY || to_type == e_rr_type::CHANZ) {
+                num_adj += rr_graph.chan_nodes_are_adjacent(from_node, to_node);
             } else {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_adjacent: %d and %d are not adjacent", from_node, to_node);
@@ -501,7 +456,7 @@ static bool check_adjacent(RRNodeId from_node, RRNodeId to_node, bool is_flat) {
 
     VPR_ERROR(VPR_ERROR_ROUTE,
               "in check_adjacent: num_adj = %d. Expected 0 or 1.\n", num_adj);
-    return false; //Should not reach here once thrown
+    return false; // Should not reach here once thrown
 }
 
 void recompute_occupancy_from_scratch(const Netlist<>& net_list, bool is_flat) {
@@ -872,30 +827,6 @@ void check_net_for_stubs(const Netlist<>& net_list,
     }
 }
 
-static bool chanxy_chanz_adjacent(RRNodeId chanxy_node, RRNodeId chanz_node) {
-    const RRGraphView& rr_graph = g_vpr_ctx.device().rr_graph;
-    VTR_ASSERT(rr_graph.node_type(chanz_node) == e_rr_type::CHANZ);
-    e_rr_type chanxy_node_type = rr_graph.node_type(chanxy_node);
-    VTR_ASSERT(chanxy_node_type == e_rr_type::CHANX || chanxy_node_type == e_rr_type::CHANY);
-
-    int chanz_x = rr_graph.node_xlow(chanz_node);
-    int chanz_y = rr_graph.node_ylow(chanz_node);
-    VTR_ASSERT_SAFE(chanz_x == rr_graph.node_xhigh(chanz_node));
-    VTR_ASSERT_SAFE(chanz_y == rr_graph.node_yhigh(chanz_node));
-
-    if (chanxy_node_type == e_rr_type::CHANX) {
-        // CHANX runs horizontally, so y must match and x must overlap
-        return chanz_y == rr_graph.node_ylow(chanxy_node)
-               && chanz_x >= rr_graph.node_xlow(chanxy_node) - 1
-               && chanz_x <= rr_graph.node_xhigh(chanxy_node) + 1;
-    } else {
-        // CHANY runs vertically, so x must match and y must overlap
-        return chanz_x == rr_graph.node_xlow(chanxy_node)
-               && chanz_y >= rr_graph.node_ylow(chanxy_node) - 1
-               && chanz_y <= rr_graph.node_yhigh(chanxy_node) + 1;
-    }
-}
-
 bool StubFinder::CheckNet(ParentNetId net) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     stub_nodes_.clear();
