handled CHANZ in some RR checks

Author: soheilshahrouz

libs/librrgraph/src/base/check_rr_graph.cpp

@@ -329,14 +329,9 @@ void check_rr_node(const RRGraphView& rr_graph,
                    const enum e_route_type route_type, 
                    const int inode,
                    bool is_flat) {
-    /* This routine checks that the rr_node is inside the grid and has a valid
-     * pin number, etc.
-     */
-
     //Make sure over-flow doesn't happen
     VTR_ASSERT(inode >= 0);
     int nodes_per_chan, tracks_per_node;
-    float C, R;
     RRNodeId rr_node = RRNodeId(inode);
 
     e_rr_type rr_type = rr_graph.node_type(rr_node);
@@ -437,6 +432,14 @@ void check_rr_node(const RRGraphView& rr_graph,
             }
             break;
 
+        case e_rr_type::CHANZ:
+            if (xhigh != xlow || yhigh != ylow || xhigh > int(grid.width()) - 2 || ylow < 1 || yhigh > int(grid.height()) - 2) {
+                VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                                "Error in check_rr_node: CHANZ out of range for endpoints (%d,%d) and (%d,%d)\n", xlow, ylow, xhigh, yhigh);
+            }
+            // TODO: handle global routing case
+            break;
+
         default:
             VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                             "in check_rr_node: Unexpected segment type: %d\n", rr_type);
@@ -488,29 +491,24 @@ void check_rr_node(const RRGraphView& rr_graph,
                 tracks_per_node = ((rr_type == e_rr_type::CHANX) ? chan_width.x_list[ylow] : chan_width.y_list[xlow]);
             }
 
-            //if a chanx/chany has length 0, it means it is used to connect different dice together
-            //hence, the ptc number can be larger than nodes_per_chan
-            if(xlow != xhigh || ylow != yhigh) {
-                if (ptc_num >= nodes_per_chan) {
-                    VPR_ERROR(VPR_ERROR_ROUTE,
-                              "in check_rr_node: inode %d (type %d) has a ptc_num of %d.\n", inode, rr_type, ptc_num);
-                }
-            }
-
             if (capacity != tracks_per_node) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_rr_node: inode %d (type %d) has a capacity of %d.\n", inode, rr_type, capacity);
             }
             break;
 
+        case e_rr_type::CHANZ:
+            // TODO: do checks for CHANZ type
+            break;
+
         default:
             VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                             "in check_rr_node: Unexpected segment type: %d\n", rr_type);
     }
 
-    /* Check that the capacitance and resistance are reasonable. */
-    C = rr_graph.node_C(rr_node);
-    R = rr_graph.node_R(rr_node);
+    // Check that the capacitance and resistance are reasonable.
+    float C = rr_graph.node_C(rr_node);
+    float R = rr_graph.node_R(rr_node);
 
     if (rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY) {
         if (C < 0. || R < 0.) {

libs/librrgraph/src/base/check_rr_graph.h

@@ -12,6 +12,27 @@ void check_rr_graph(const RRGraphView& rr_graph,
                     const e_graph_type graph_type,
                     bool is_flat);
 
+/**
+ * @brief Validates the internal consistency of a single RR node in the routing resource graph.
+ *
+ * This function performs a series of checks on the specified RR node to ensure it conforms
+ * to architectural and routing constraints. It verifies:
+ *  - That the node's bounding box is valid and within the device grid bounds.
+ *  - That the node's PTC number, capacity, and cost index are within legal limits.
+ *  - That IPINs, OPINs, SOURCEs, and SINKs correspond to valid physical locations and types.
+ *  - That CHANX, CHANY, and CHANZ nodes have legal coordinate bounds and track indices.
+ *  - That electrical characteristics (resistance and capacitance) are appropriate for the node type.
+ *
+ * Errors or inconsistencies will cause fatal errors or logged messages, depending on severity.
+ *
+ * @param rr_graph The read-only view of the routing resource graph.
+ * @param rr_indexed_data Indexed data for RR node cost metrics.
+ * @param grid The device grid.
+ * @param chan_width The channel widths for different channels
+ * @param route_type The routing type (GLOBAL or DETAILED).
+ * @param inode The index of the RR node to be checked.
+ * @param is_flat Flag indicating if flat routing is enabled.
+ */
 void check_rr_node(const RRGraphView& rr_graph,
                    const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data,
                    const DeviceGrid& grid,

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -646,8 +646,8 @@ void t_rr_graph_storage::set_node_pin_num(RRNodeId id, int new_pin_num) {
 }
 
 void t_rr_graph_storage::set_node_track_num(RRNodeId id, int new_track_num) {
-    if (node_type(id) != e_rr_type::CHANX && node_type(id) != e_rr_type::CHANY) {
-        VTR_LOG_ERROR("Attempted to set RR node 'track_num' for non-CHANX/CHANY type '%s'", node_type_string(id));
+    if (node_type(id) != e_rr_type::CHANX && node_type(id) != e_rr_type::CHANY && node_type(id) != e_rr_type::CHANZ)  {
+        VTR_LOG_ERROR("Attempted to set RR node 'track_num' for non-CHANX/CHANY/CHANZ type '%s'", node_type_string(id));
     }
     node_ptc_[id].ptc_.track_num = new_track_num;
 }
@@ -760,7 +760,7 @@ void t_rr_graph_storage::set_node_capacity(RRNodeId id, short new_capacity) {
 }
 
 void t_rr_graph_storage::set_node_direction(RRNodeId id, Direction new_direction) {
-    if (node_type(id) != e_rr_type::CHANX && node_type(id) != e_rr_type::CHANY) {
+    if (node_type(id) != e_rr_type::CHANX && node_type(id) != e_rr_type::CHANY && node_type(id) != e_rr_type::CHANZ) {
         VTR_LOG_ERROR("Attempted to set RR node 'direction' for non-channel type '%s'", node_type_string(id));
     }
     node_storage_[id].dir_side_.direction = new_direction;

vpr/src/route/rr_graph_generation/rr_graph.cpp

@@ -888,22 +888,22 @@ static void add_intra_tile_edges_rr_graph(RRGraphBuilder& rr_graph_builder,
         if (is_pin_on_tile(physical_tile, pin_physical_num)) {
             continue;
         }
-        auto pin_rr_node_id = get_pin_rr_node_id(rr_graph_builder.node_lookup(),
-                                                 physical_tile,
-                                                 layer,
-                                                 i,
-                                                 j,
-                                                 pin_physical_num);
+        RRNodeId pin_rr_node_id = get_pin_rr_node_id(rr_graph_builder.node_lookup(),
+                                                     physical_tile,
+                                                     layer,
+                                                     i,
+                                                     j,
+                                                     pin_physical_num);
         VTR_ASSERT(pin_rr_node_id != RRNodeId::INVALID());
-        auto logical_block = get_logical_block_from_pin_physical_num(physical_tile, pin_physical_num);
-        auto driving_pins = get_physical_pin_src_pins(physical_tile, logical_block, pin_physical_num);
-        for (auto driving_pin : driving_pins) {
-            auto driving_pin_node_id = get_pin_rr_node_id(rr_graph_builder.node_lookup(),
-                                                          physical_tile,
-                                                          layer,
-                                                          i,
-                                                          j,
-                                                          driving_pin);
+        t_logical_block_type_ptr logical_block = get_logical_block_from_pin_physical_num(physical_tile, pin_physical_num);
+        std::vector<int> driving_pins = get_physical_pin_src_pins(physical_tile, logical_block, pin_physical_num);
+        for (int driving_pin : driving_pins) {
+            RRNodeId driving_pin_node_id = get_pin_rr_node_id(rr_graph_builder.node_lookup(),
+                                                              physical_tile,
+                                                              layer,
+                                                              i,
+                                                              j,
+                                                              driving_pin);
             VTR_ASSERT(driving_pin_node_id != RRNodeId::INVALID());
 
             int sw_idx = get_edge_sw_arch_idx(physical_tile,
@@ -918,12 +918,10 @@ static void add_intra_tile_edges_rr_graph(RRGraphBuilder& rr_graph_builder,
 }
 
 void print_rr_graph_stats() {
-    auto& device_ctx = g_vpr_ctx.device();
-
-    const auto& rr_graph = device_ctx.rr_graph;
+    const auto& rr_graph = g_vpr_ctx.device().rr_graph;
 
     size_t num_rr_edges = 0;
-    for (auto& rr_node : rr_graph.rr_nodes()) {
+    for (const t_rr_node& rr_node : rr_graph.rr_nodes()) {
         num_rr_edges += rr_graph.edges(rr_node.id()).size();
     }
 

vpr/src/route/rr_graph_generation/rr_node_indices.cpp

@@ -532,7 +532,7 @@ bool verify_rr_node_indices(const DeviceGrid& grid,
                                           y,
                                           describe_rr_node(rr_graph, grid, rr_indexed_data, inode, is_flat).c_str());
                             }
-                            
+
                         } else if (rr_graph.node_type(inode) == e_rr_type::SOURCE || rr_graph.node_type(inode) == e_rr_type::SINK) {
                             // Sources have co-ordinates covering the entire block they are in, but not sinks
                             if (!rr_graph.x_in_node_range(x, inode)) {