update verify_rr_node_indices() to check for CHANZ

Author: soheilshahrouz

libs/librrgraph/src/base/rr_spatial_lookup.cpp

@@ -196,7 +196,7 @@ std::vector<RRNodeId> RRSpatialLookup::find_grid_nodes_at_all_sides(int layer,
     }
 
     std::vector<RRNodeId> nodes;
-    /* Reserve space to avoid memory fragmentation */
+    // Reserve space to avoid memory fragmentation
     size_t num_nodes = 0;
     for (e_side node_side : TOTAL_2D_SIDES) {
         num_nodes += find_nodes(layer,x, y, rr_type, node_side).size();

vpr/src/route/rr_graph_generation/rr_graph.cpp

@@ -256,15 +256,6 @@ static void add_pins_rr_graph(RRGraphBuilder& rr_graph_builder,
  * the delay of these edges is not necessarily zero. If the primitive block which a SINK/SRC belongs to is a combinational block, the delay of
  * the edge is equal to the pin delay. This is done in order to make the router lookahead aware of the different IPIN delays. In this way, more critical
  * nets are routed to the pins with less delay.
- * @param rr_graph_builder
- * @param arch_sw_inf_map
- * @param class_num_vec
- * @param layer
- * @param i
- * @param j
- * @param rr_edges_to_create
- * @param delayless_switch
- * @param physical_type_ptr
  */
 static void connect_tile_src_sink_to_pins(RRGraphBuilder& rr_graph_builder,
                                           std::map<int, t_arch_switch_inf>& arch_sw_inf_map,
@@ -436,17 +427,6 @@ static void add_pb_edges(RRGraphBuilder& rr_graph_builder,
 
 /**
  * Edges going in/out of collapse nodes are not added by the normal routine. This function add those edges
- * @param rr_graph_builder
- * @param rr_edges_to_create
- * @param physical_type
- * @param logical_block
- * @param cluster_pins
- * @param nodes_to_collapse
- * @param R_minW_nmos
- * @param R_minW_pmos
- * @param layer
- * @param i
- * @param j
  * @return Number of the collapsed nodes
  */
 static int add_edges_for_collapsed_nodes(RRGraphBuilder& rr_graph_builder,
@@ -462,23 +442,7 @@ static int add_edges_for_collapsed_nodes(RRGraphBuilder& rr_graph_builder,
                                          int j,
                                          bool load_rr_graph);
 /**
- * @note This function is used to add the fan-in edges of the given chain node to the chain's sink with the modified delay
- * @param rr_graph_builder
- * @param rr_edges_to_create
- * @param num_collapsed_pins
- * @param physical_type
- * @param logical_block
- * @param nodes_to_collapse
- * @param cluster_pins
- * @param chain_pins
- * @param R_minW_nmos
- * @param R_minW_pmos
- * @param chain_idx
- * @param node_idx
- * @param sink_pin_num
- * @param layer
- * @param i
- * @param j
+ * @brief This function is used to add the fan-in edges of the given chain node to the chain's sink with the modified delay
  */
 static void add_chain_node_fan_in_edges(RRGraphBuilder& rr_graph_builder,
                                         t_rr_edge_info_set& rr_edges_to_create,
@@ -604,26 +568,12 @@ static RRNodeId pick_best_direct_connect_target_rr_node(const RRGraphView& rr_gr
                                                         RRNodeId from_rr,
                                                         const std::vector<RRNodeId>& candidate_rr_nodes);
 
-/**
- *
- * @param cluster_pins
- * @param physical_type
- * @param logical_block
- * @param is_flat
- * @return A structure containing
- */
 static t_cluster_pin_chain get_cluster_directly_connected_nodes(const std::vector<int>& cluster_pins,
                                                                 t_physical_tile_type_ptr physical_type,
                                                                 t_logical_block_type_ptr logical_block,
                                                                 bool is_flat);
 
 /**
- *
- * @param physical_type
- * @param logical_block
- * @param pins_in_cluster
- * @param pin_physical_num
- * @param is_flat
  * @return A chain of nodes starting from pin_physcical_num. All of the pins in this chain has a fan-out of 1
  */
 static std::vector<int> get_directly_connected_nodes(t_physical_tile_type_ptr physical_type,
@@ -654,11 +604,6 @@ static int get_chain_idx(const std::vector<int>& pin_idx_vec, const std::vector<
 
 /**
  * If pin chain is a part of a chain already added to all_chains, add the new parts to the corresponding chain. Otherwise, add pin_chain as a new chain to all_chains.
- * @param pin_chain
- * @param chain_idx
- * @param pin_index_vec
- * @param all_chains
- * @param is_new_chain
  */
 static void add_pin_chain(const std::vector<int>& pin_chain,
                           int chain_idx,
@@ -938,7 +883,7 @@ static void add_intra_tile_edges_rr_graph(RRGraphBuilder& rr_graph_builder,
                                           int layer,
                                           int i,
                                           int j) {
-    auto pin_num_vec = get_flat_tile_pins(physical_tile);
+    std::vector<int> pin_num_vec = get_flat_tile_pins(physical_tile);
     for (int pin_physical_num : pin_num_vec) {
         if (is_pin_on_tile(physical_tile, pin_physical_num)) {
             continue;

vpr/src/route/rr_graph_generation/rr_node_indices.cpp

@@ -466,7 +466,7 @@ bool verify_rr_node_indices(const DeviceGrid& grid,
                 for (e_rr_type rr_type : RR_TYPES) {
                     // Get the list of nodes at a specific location (x, y)
                     std::vector<RRNodeId> nodes_from_lookup;
-                    if (rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY) {
+                    if (rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY || rr_type == e_rr_type::CHANZ) {
                         nodes_from_lookup = rr_graph.node_lookup().find_channel_nodes(l, x, y, rr_type);
                     } else {
                         nodes_from_lookup = rr_graph.node_lookup().find_grid_nodes_at_all_sides(l, x, y, rr_type);
@@ -515,6 +515,24 @@ 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::CHANZ) {
+                            VTR_ASSERT_MSG(rr_graph.node_xlow(inode) == rr_graph.node_xhigh(inode), "CHANZ should move only along layers");
+                            VTR_ASSERT_MSG(rr_graph.node_ylow(inode) == rr_graph.node_yhigh(inode), "CHANZ should move only along layers");
+
+                            if (x != rr_graph.node_xlow(inode)) {
+                                VPR_ERROR(VPR_ERROR_ROUTE, "RR node x position does not agree between rr_nodes (%d) and rr_node_indices (%d): %s",
+                                          rr_graph.node_xlow(inode),
+                                          x,
+                                          describe_rr_node(rr_graph, grid, rr_indexed_data, inode, is_flat).c_str());
+                            }
+
+                            if (y != rr_graph.node_ylow(inode)) {
+                                VPR_ERROR(VPR_ERROR_ROUTE, "RR node y position does not agree between rr_nodes (%d) and rr_node_indices (%d): %s",
+                                          rr_graph.node_xlow(inode),
+                                          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)) {