Merge pull request #3170 to add CHANZ rr node type

Add CHANZ type

Author: soheilshahrouz

libs/librrgraph/src/base/check_rr_graph.cpp

@@ -58,13 +58,13 @@ void check_rr_graph(const RRGraphView& rr_graph,
         route_type = e_route_type::GLOBAL;
     }
 
-    auto total_edges_to_node = std::vector<int>(rr_graph.num_nodes());
-    auto switch_types_from_current_to_node = std::vector<unsigned char>(rr_graph.num_nodes());
+    std::vector<int> total_edges_to_node(rr_graph.num_nodes());
+    std::vector<unsigned char> switch_types_from_current_to_node(rr_graph.num_nodes());
     const int num_rr_switches = rr_graph.num_rr_switches();
 
     std::vector<std::pair<int, int>> edges;
 
-    for (const RRNodeId& rr_node : rr_graph.nodes()) {
+    for (const RRNodeId rr_node : rr_graph.nodes()) {
         size_t inode = (size_t)rr_node;
         rr_graph.validate_node(rr_node);
 
@@ -83,7 +83,7 @@ void check_rr_graph(const RRGraphView& rr_graph,
 
         check_rr_node(rr_graph, rr_indexed_data, grid, chan_width, route_type, inode, is_flat);
 
-        /* Check all the connectivity (edges, etc.) information.                    */
+        // Check all the connectivity (edges, etc.) information.
         edges.resize(0);
         edges.reserve(num_edges);
 
@@ -329,16 +329,15 @@ 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;
+    int tracks_per_node;
     RRNodeId rr_node = RRNodeId(inode);
 
+    const int grid_width = grid.width();
+    const int grid_height = grid.height();
+    const int grid_layers = grid.get_num_layers();
+
     e_rr_type rr_type = rr_graph.node_type(rr_node);
     int xlow = rr_graph.node_xlow(rr_node);
     int xhigh = rr_graph.node_xhigh(rr_node);
@@ -348,19 +347,18 @@ void check_rr_node(const RRGraphView& rr_graph,
     int ptc_num = rr_graph.node_ptc_num(rr_node);
     int capacity = rr_graph.node_capacity(rr_node);
     RRIndexedDataId cost_index = rr_graph.node_cost_index(rr_node);
-    t_physical_tile_type_ptr type = nullptr;
 
     if (xlow > xhigh || ylow > yhigh) {
         VPR_ERROR(VPR_ERROR_ROUTE,
                   "in check_rr_node: rr endpoints are (%d,%d) and (%d,%d).\n", xlow, ylow, xhigh, yhigh);
     }
 
-    if (xlow < 0 || xhigh > int(grid.width()) - 1 || ylow < 0 || yhigh > int(grid.height()) - 1) {
+    if (xlow < 0 || xhigh > grid_width - 1 || ylow < 0 || yhigh > grid_height - 1) {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                         "in check_rr_node: rr endpoints (%d,%d) and (%d,%d) are out of range.\n", xlow, ylow, xhigh, yhigh);
     }
 
-    if (layer_num < 0 || layer_num > int(grid.get_num_layers()) - 1) {
+    if (layer_num < 0 || layer_num > grid_layers - 1) {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                         "in check_rr_node: rr endpoints layer_num (%d) is out of range.\n", layer_num);
     }
@@ -375,8 +373,8 @@ void check_rr_node(const RRGraphView& rr_graph,
                         "in check_rr_node: node %d cost index (%d) is out of range.\n", inode, cost_index);
     }
 
-    /* Check that the segment is within the array and such. */
-    type = grid.get_physical_type({xlow, ylow, layer_num});
+    // Check that the segment is within the array and such.
+    t_physical_tile_type_ptr type = grid.get_physical_type({xlow, ylow, layer_num});
 
     switch (rr_type) {
         case e_rr_type::SOURCE:
@@ -416,7 +414,7 @@ void check_rr_node(const RRGraphView& rr_graph,
             break;
 
         case e_rr_type::CHANX:
-            if (xlow < 1 || xhigh > int(grid.width()) - 2 || yhigh > int(grid.height()) - 2 || yhigh != ylow) {
+            if (xlow < 1 || xhigh > grid_width - 1 || yhigh > grid_height - 1 || yhigh != ylow) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "in check_rr_node: CHANX out of range for endpoints (%d,%d) and (%d,%d)\n", xlow, ylow, xhigh, yhigh);
             }
@@ -427,7 +425,7 @@ void check_rr_node(const RRGraphView& rr_graph,
             break;
 
         case e_rr_type::CHANY:
-            if (xhigh > int(grid.width()) - 2 || ylow < 1 || yhigh > int(grid.height()) - 2 || xlow != xhigh) {
+            if (xhigh > grid_width - 1 || ylow < 1 || yhigh > grid_height - 1 || xlow != xhigh) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                 "Error in check_rr_node: CHANY out of range for endpoints (%d,%d) and (%d,%d)\n", xlow, ylow, xhigh, yhigh);
             }
@@ -437,12 +435,20 @@ void check_rr_node(const RRGraphView& rr_graph,
             }
             break;
 
+        case e_rr_type::CHANZ:
+            if (xhigh != xlow || yhigh != ylow || xhigh > grid_width - 1 || ylow < 1 || yhigh > grid_height - 1) {
+                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);
     }
 
-    /* Check that it's capacities and such make sense. */
+    // Check that its capacities and such make sense.
 
     int class_max_ptc = get_tile_class_max_ptc(type, is_flat);
     int pin_max_ptc = get_tile_pin_max_ptc(type, is_flat);
@@ -481,20 +487,9 @@ void check_rr_node(const RRGraphView& rr_graph,
         case e_rr_type::CHANX:
         case e_rr_type::CHANY:
             if (route_type == e_route_type::DETAILED) {
-                nodes_per_chan = chan_width.max;
                 tracks_per_node = 1;
             } else {
-                nodes_per_chan = 1;
-                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);
-                }
+                tracks_per_node = (rr_type == e_rr_type::CHANX) ? chan_width.x_list[ylow] : chan_width.y_list[xlow];
             }
 
             if (capacity != tracks_per_node) {
@@ -503,14 +498,26 @@ void check_rr_node(const RRGraphView& rr_graph,
             }
             break;
 
+        case e_rr_type::CHANZ:
+            if (route_type == e_route_type::DETAILED) {
+                tracks_per_node = 1;
+            } else {
+                // TODO: do checks for CHANZ type when global routing is enabled
+                //       This can be done once we have a way to specify how many chanz
+                //       nodes per switch block exist.
+                VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                                "in check_rr_node: Global routing is not supported in 3D architectures.\n");
+            }
+            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_builder.cpp

@@ -33,6 +33,7 @@ void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) {
             switch (node_type) {
                 case e_rr_type::SOURCE:
                 case e_rr_type::SINK:
+                case e_rr_type::CHANZ:
                 case e_rr_type::CHANY:
                 case e_rr_type::CHANX:
                     node_lookup_.add_node(node, node_layer, ix, iy, node_type, node_ptc_num, TOTAL_2D_SIDES[0]);

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;
 }
@@ -663,32 +663,29 @@ int t_rr_graph_storage::node_ptc_num(RRNodeId id) const {
     return node_ptc_[id].ptc_.pin_num;
 }
 
-static int get_node_pin_num(
-    vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
-    vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
-    RRNodeId id) {
+static int get_node_pin_num(vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
+                            vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
+                            RRNodeId id) {
     e_rr_type node_type = node_storage[id].type_;
     if (node_type != e_rr_type::IPIN && node_type != e_rr_type::OPIN) {
         VTR_LOG_ERROR("Attempted to access RR node 'pin_num' for non-IPIN/OPIN type '%s'", rr_node_typename[node_type]);
     }
     return node_ptc[id].ptc_.pin_num;
 }
 
-static int get_node_track_num(
-    vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
-    vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
-    RRNodeId id) {
+static int get_node_track_num(vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
+                              vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
+                              RRNodeId id) {
     e_rr_type node_type = node_storage[id].type_;
-    if (node_type != e_rr_type::CHANX && node_type != e_rr_type::CHANY) {
-        VTR_LOG_ERROR("Attempted to access RR node 'track_num' for non-CHANX/CHANY type '%s'", rr_node_typename[node_type]);
+    if (node_type != e_rr_type::CHANX && node_type != e_rr_type::CHANY && node_type != e_rr_type::CHANZ) {
+        VTR_LOG_ERROR("Attempted to access RR node 'track_num' for non-CHANX/CHANY/CHANZ type '%s'", rr_node_typename[node_type]);
     }
     return node_ptc[id].ptc_.track_num;
 }
 
-static int get_node_class_num(
-    vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
-    vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
-    RRNodeId id) {
+static int get_node_class_num(vtr::array_view_id<RRNodeId, const t_rr_node_data> node_storage,
+                              vtr::array_view_id<RRNodeId, const t_rr_node_ptc_data> node_ptc,
+                              RRNodeId id) {
     e_rr_type node_type = node_storage[id].type_;
     if (node_type != e_rr_type::SOURCE && node_type != e_rr_type::SINK) {
         VTR_LOG_ERROR("Attempted to access RR node 'class_num' for non-SOURCE/SINK type '%s'", rr_node_typename[node_type]);
@@ -760,7 +757,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;