std::array for sb_loc instead of two vars

Author: soheilshahrouz

vpr/src/route/rr_graph_generation/rr_graph_chan_chan_edges.cpp

@@ -85,21 +85,21 @@ static void get_switchblocks_edges(RRGraphBuilder& rr_graph_builder,
                                    t_rr_edge_info_set& rr_edges_to_create,
                                    int& edge_count);
 
-/// Adds the fan-out edges from wire segment at (chan, seg, track) to adjacent blocks along the wire's length
-static int get_track_to_pins(RRGraphBuilder& rr_graph_builder,
-                             int layer,
-                             int seg,
-                             int chan,
-                             int track,
-                             int tracks_per_chan,
-                             RRNodeId from_rr_node,
-                             t_rr_edge_info_set& rr_edges_to_create,
-                             const t_track_to_pin_lookup& track_to_pin_lookup,
-                             const t_chan_seg_details* seg_details,
-                             e_rr_type chan_type,
-                             int chan_length,
-                             int wire_to_ipin_switch,
-                             e_directionality directionality);
+/// Adds the fan-out edges from wire segment at (chan, seg, track) to adjacent IPINs along the wire's length
+static int get_track_to_ipins(RRGraphBuilder& rr_graph_builder,
+                              int layer,
+                              int seg,
+                              int chan,
+                              int track,
+                              int tracks_per_chan,
+                              RRNodeId from_rr_node,
+                              t_rr_edge_info_set& rr_edges_to_create,
+                              const t_track_to_pin_lookup& track_to_pin_lookup,
+                              const t_chan_seg_details* seg_details,
+                              e_rr_type chan_type,
+                              int chan_length,
+                              int wire_to_ipin_switch,
+                              e_directionality directionality);
 
 //Returns how the switch type for the switch block at the specified location should be created
 //  from_chan_coord: The horizontal or vertical channel index (i.e. x-coord for CHANY, y-coord for CHANX)
@@ -239,9 +239,9 @@ static void build_rr_chan(RRGraphBuilder& rr_graph_builder,
         }
 
         // Add the edges from this track to all it's connected pins into the list
-        get_track_to_pins(rr_graph_builder, layer, start, chan_coord, track, tracks_per_chan, node, rr_edges_to_create,
-                          track_to_pin_lookup, seg_details, chan_type, seg_dimension,
-                          wire_to_ipin_switch, directionality);
+        get_track_to_ipins(rr_graph_builder, layer, start, chan_coord, track, tracks_per_chan, node, rr_edges_to_create,
+                           track_to_pin_lookup, seg_details, chan_type, seg_dimension,
+                           wire_to_ipin_switch, directionality);
 
         // Add edges going from the current track into channel segments which are perpendicular to it
         if (chan_coord > 0) {
@@ -297,7 +297,7 @@ static void build_rr_chan(RRGraphBuilder& rr_graph_builder,
             }
             if (target_seg > 0 && target_seg < seg_dimension + 1) {
                 const t_chan_seg_details* to_seg_details;
-                // AA: Same channel width for straight through connections assuming uniform width distributions along the axis
+                // Same channel width for straight through connections assuming uniform width distributions along the axis
                 int max_chan_width = 0;
                 if (chan_type == e_rr_type::CHANX) {
                     to_seg_details = chan_details_x[target_seg][y_coord].data();
@@ -319,7 +319,7 @@ static void build_rr_chan(RRGraphBuilder& rr_graph_builder,
         }
 
         // Edge arrays have now been built up.  Do everything else.
-        // AA: The cost_index should be w.r.t the index of the segment to its **parallel** segment_inf vector.
+        // The cost_index should be w.r.t the index of the segment to its **parallel** segment_inf vector.
         // Note that when building channels, we use the indices w.r.t segment_inf_x and segment_inf_y as
         // computed earlier in build_rr_graph so it's fine to use .index() for to get the correct index.
         rr_graph_builder.set_node_cost_index(node, RRIndexedDataId(cost_index_offset + seg_details[track].index()));
@@ -692,7 +692,7 @@ static void get_switchblocks_edges(RRGraphBuilder& rr_graph_builder,
     }
 }
 
-static int get_track_to_pins(RRGraphBuilder& rr_graph_builder,
+static int get_track_to_ipins(RRGraphBuilder& rr_graph_builder,
                              int layer,
                              int seg,
                              int chan,
@@ -729,7 +729,7 @@ static int get_track_to_pins(RRGraphBuilder& rr_graph_builder,
                     side = (0 == pass ? RIGHT : LEFT);
                 }
 
-                /* PAJ - if the pointed to is an EMPTY then shouldn't look for ipins */
+                // if the pointed to is an EMPTY then shouldn't look for ipins
                 t_physical_tile_type_ptr type = device_ctx.grid.get_physical_type({x, y, layer});
                 if (type == device_ctx.EMPTY_PHYSICAL_TILE_TYPE)
                     continue;

vpr/src/route/rr_graph_generation/rr_graph_sg.cpp

@@ -118,26 +118,28 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
 
     std::vector<RRNodeId> opin_nodes = node_lookup.find_pin_nodes_at_side(layer, x, y, e_rr_type::OPIN, side);
 
-    t_physical_tile_loc sb_loc0, sb_loc1;
+    // Two switch-block location adjacent to this channel segment
+    std::array<t_physical_tile_loc, 2> adjacent_sb_loc;
+    
     switch (side) {
         case TOP:
-            sb_loc0 = {x, y, layer};
-            sb_loc1 = {x - 1, y, layer};
+            adjacent_sb_loc[0] = {x, y, layer};
+            adjacent_sb_loc[1] = {x - 1, y, layer};
             break;
 
         case BOTTOM:
-            sb_loc0 = {x, y - 1, layer};
-            sb_loc1 = {x - 1, y - 1, layer};
+            adjacent_sb_loc[0] = {x, y - 1, layer};
+            adjacent_sb_loc[1] = {x - 1, y - 1, layer};
             break;
 
         case RIGHT:
-            sb_loc0 = {x, y, layer};
-            sb_loc1 = {x, y - 1, layer};
+            adjacent_sb_loc[0] = {x, y, layer};
+            adjacent_sb_loc[1] = {x, y - 1, layer};
             break;
 
         case LEFT:
-            sb_loc0 = {x - 1, y, layer};
-            sb_loc1 = {x - 1, y - 1, layer};
+            adjacent_sb_loc[0] = {x - 1, y, layer};
+            adjacent_sb_loc[1] = {x - 1, y - 1, layer};
             break;
 
         default:
@@ -147,11 +149,11 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
     const int grid_width = grid.width();
     const int grid_height = grid.height();
 
-    sb_loc0.x = std::clamp(sb_loc0.x, 0, grid_width - 1);
-    sb_loc0.y = std::clamp(sb_loc0.y, 0, grid_height - 1);
+    adjacent_sb_loc[0].x = std::clamp(adjacent_sb_loc[0].x, 0, grid_width - 1);
+    adjacent_sb_loc[0].y = std::clamp(adjacent_sb_loc[0].y, 0, grid_height - 1);
 
-    sb_loc1.x = std::clamp(sb_loc1.x, 0, grid_width - 1);
-    sb_loc1.y = std::clamp(sb_loc1.y, 0, grid_height - 1);
+    adjacent_sb_loc[1].x = std::clamp(adjacent_sb_loc[1].x, 0, grid_width - 1);
+    adjacent_sb_loc[1].y = std::clamp(adjacent_sb_loc[1].y, 0, grid_height - 1);
 
     std::vector<std::pair<RRNodeId, short>> selected_chanz_nodes0;
     std::vector<std::pair<RRNodeId, short>> selected_chanz_nodes1;
@@ -163,19 +165,19 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
         }
 
         selected_chanz_nodes0.clear();
-        for (size_t track_num = 0; track_num < interdie_3d_links[sb_loc0.x][sb_loc0.y].size(); track_num++) {
-            const t_bottleneck_link& bottleneck_link = interdie_3d_links[sb_loc0.x][sb_loc0.y][track_num];
+        for (size_t track_num = 0; track_num < interdie_3d_links[adjacent_sb_loc[0].x][adjacent_sb_loc[0].y].size(); track_num++) {
+            const t_bottleneck_link& bottleneck_link = interdie_3d_links[adjacent_sb_loc[0].x][adjacent_sb_loc[0].y][track_num];
             if (bottleneck_link.parallel_segment_index == seg_index && bottleneck_link.gather_loc.layer_num == layer) {
-                RRNodeId node_id = node_lookup.find_node(sb_loc0.layer_num, sb_loc0.x, sb_loc0.y, e_rr_type::CHANZ, track_num);
+                RRNodeId node_id = node_lookup.find_node(adjacent_sb_loc[0].layer_num, adjacent_sb_loc[0].x, adjacent_sb_loc[0].y, e_rr_type::CHANZ, track_num);
                 selected_chanz_nodes0.emplace_back(node_id, bottleneck_link.arch_wire_switch);
             }
         }
 
         selected_chanz_nodes1.clear();
-        for (size_t track_num = 0; track_num < interdie_3d_links[sb_loc1.x][sb_loc1.y].size(); track_num++) {
-            const t_bottleneck_link& bottleneck_link = interdie_3d_links[sb_loc1.x][sb_loc1.y][track_num];
+        for (size_t track_num = 0; track_num < interdie_3d_links[adjacent_sb_loc[1].x][adjacent_sb_loc[1].y].size(); track_num++) {
+            const t_bottleneck_link& bottleneck_link = interdie_3d_links[adjacent_sb_loc[1].x][adjacent_sb_loc[1].y][track_num];
             if (bottleneck_link.parallel_segment_index == seg_index && bottleneck_link.gather_loc.layer_num == layer) {
-                RRNodeId node_id = node_lookup.find_node(sb_loc1.layer_num, sb_loc1.x, sb_loc1.y, e_rr_type::CHANZ, track_num);
+                RRNodeId node_id = node_lookup.find_node(adjacent_sb_loc[1].layer_num, adjacent_sb_loc[1].x, adjacent_sb_loc[1].y, e_rr_type::CHANZ, track_num);
                 selected_chanz_nodes1.emplace_back(node_id, bottleneck_link.arch_wire_switch);
             }
         }
@@ -188,16 +190,16 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
 
                 RRNodeId chanz_node_id;
                 short switch_id;
-                if (Fc_zofs[sb_loc0.x][sb_loc0.y][seg_index] < Fc_zofs[sb_loc1.x][sb_loc1.y][seg_index]) {
-                    int chanz_idx = Fc_zofs[sb_loc0.x][sb_loc0.y][seg_index];
+                if (Fc_zofs[adjacent_sb_loc[0].x][adjacent_sb_loc[0].y][seg_index] < Fc_zofs[adjacent_sb_loc[1].x][adjacent_sb_loc[1].y][seg_index]) {
+                    int chanz_idx = Fc_zofs[adjacent_sb_loc[0].x][adjacent_sb_loc[0].y][seg_index];
                     chanz_node_id = selected_chanz_nodes0[chanz_idx % selected_chanz_nodes0.size()].first;
                     switch_id = selected_chanz_nodes0[chanz_idx % selected_chanz_nodes0.size()].second;
-                    Fc_zofs[sb_loc0.x][sb_loc0.y][seg_index]++;
+                    Fc_zofs[adjacent_sb_loc[0].x][adjacent_sb_loc[0].y][seg_index]++;
                 } else {
-                    int chanz_idx = Fc_zofs[sb_loc1.x][sb_loc1.y][seg_index];
+                    int chanz_idx = Fc_zofs[adjacent_sb_loc[1].x][adjacent_sb_loc[1].y][seg_index];
                     chanz_node_id = selected_chanz_nodes1[chanz_idx % selected_chanz_nodes1.size()].first;
                     switch_id = selected_chanz_nodes1[chanz_idx % selected_chanz_nodes1.size()].second;
-                    Fc_zofs[sb_loc1.x][sb_loc1.y][seg_index]++;
+                    Fc_zofs[adjacent_sb_loc[1].x][adjacent_sb_loc[1].y][seg_index]++;
                 }
 
                 rr_edges_to_create.emplace_back(opin_node_id, chanz_node_id, switch_id, false);