some cleanups in rr_graph files

Author: soheilshahrouz

vpr/src/route/rr_graph_generation/rr_graph.cpp

@@ -963,8 +963,7 @@ static void build_rr_graph(e_graph_type graph_type,
     //   alloc_and_load_rr_switch_inf()
     device_ctx.rr_graph_builder.reserve_switches(device_ctx.all_sw_inf.size());
     // Create the switches
-    for (const auto& sw_pair : device_ctx.all_sw_inf) {
-        const t_arch_switch_inf& arch_sw = sw_pair.second;
+    for (const t_arch_switch_inf& arch_sw : device_ctx.all_sw_inf | std::views::values) {
         t_rr_switch_inf rr_switch = create_rr_switch_from_arch_switch(arch_sw,
                                                                       R_minW_nmos,
                                                                       R_minW_pmos);
@@ -1278,7 +1277,7 @@ std::vector<vtr::Matrix<int>> alloc_and_load_actual_fc(const std::vector<t_physi
         for (const t_fc_specification& fc_spec : type.fc_specs) {
             if (fc_type != fc_spec.fc_type) continue;
 
-            VTR_ASSERT(fc_spec.pins.size() > 0);
+            VTR_ASSERT(!fc_spec.pins.empty());
 
             int iseg = fc_spec.seg_index;
 
@@ -2941,7 +2940,7 @@ static int get_opin_direct_connections(RRGraphBuilder& rr_graph_builder,
                             inodes = rr_graph_builder.node_lookup().find_nodes_at_all_sides(layer, final_ipin_x, final_ipin_y, e_rr_type::IPIN, ipin);
                         }
 
-                        if (inodes.size() > 0) {
+                        if (!inodes.empty()) {
                             // There may be multiple physical pins corresponding to the logical
                             // target ipin. We only need to connect to one of them (since the physical pins
                             // are logically equivalent). This also ensures the graphics look reasonable and map
@@ -2963,16 +2962,13 @@ static std::vector<bool> alloc_and_load_perturb_opins(const t_physical_tile_type
                                                       const vtr::Matrix<int>& Fc_out,
                                                       const int max_chan_width,
                                                       const std::vector<t_segment_inf>& segment_inf) {
-    int i, Fc_max, iclass, num_wire_types;
-    int num, max_primes, factor, num_factors;
-    int* prime_factors;
+    int num_wire_types;
     float step_size = 0;
     float n = 0;
     float threshold = 0.07;
 
     std::vector<bool> perturb_opins(segment_inf.size(), false);
 
-    i = Fc_max = iclass = 0;
     if (segment_inf.size() > 1) {
         /* Segments of one length are grouped together in the channel.	*
          *  In the future we can determine if any of these segments will	*
@@ -2987,8 +2983,9 @@ static std::vector<bool> alloc_and_load_perturb_opins(const t_physical_tile_type
         num_wire_types = segment_inf[0].length;
     }
 
-    /* get Fc_max */
-    for (i = 0; i < type->num_pins; ++i) {
+    // get Fc_max
+    int Fc_max = 0;
+    for (int i = 0; i < type->num_pins; ++i) {
         auto pin_type = get_pin_type_from_pin_physical_num(type, i);
         if (Fc_out[i][0] > Fc_max && pin_type == e_pin_type::DRIVER) {
             Fc_max = Fc_out[i][0];
@@ -3005,19 +3002,19 @@ static std::vector<bool> alloc_and_load_perturb_opins(const t_physical_tile_type
      *  will always skip some wires. Thus, we perturb pins if we detect this	*
      *  case.								*/
 
-    /* get an upper bound on the number of prime factors of num_wire_types	*/
-    max_primes = (int)floor(log((float)num_wire_types) / log(2.0));
+    // get an upper bound on the number of prime factors of num_wire_types
+    int max_primes = (int)floor(log((float)num_wire_types) / log(2.0));
     max_primes = std::max(max_primes, 1); //Minimum of 1 to ensure we allocate space for at least one prime_factor
 
-    prime_factors = new int[max_primes];
-    for (i = 0; i < max_primes; i++) {
+    int* prime_factors = new int[max_primes];
+    for (int i = 0; i < max_primes; i++) {
         prime_factors[i] = 0;
     }
 
-    /* Find the prime factors of num_wire_types */
-    num = num_wire_types;
-    factor = 2;
-    num_factors = 0;
+    // Find the prime factors of num_wire_types
+    int num = num_wire_types;
+    int factor = 2;
+    int num_factors = 0;
     while (pow((float)factor, 2) <= num) {
         if (num % factor == 0) {
             num /= factor;
@@ -3036,7 +3033,7 @@ static std::vector<bool> alloc_and_load_perturb_opins(const t_physical_tile_type
     /* Now see if step size is an approximate multiple of one of the factors. A 	*
      *  threshold is used because step size may not be an integer.			*/
     step_size = (float)max_chan_width / Fc_max;
-    for (i = 0; i < num_factors; i++) {
+    for (int i = 0; i < num_factors; i++) {
         if (vtr::nint(step_size) < prime_factors[i]) {
             perturb_opins[0] = false;
             break;

vpr/src/route/rr_graph_generation/rr_graph2.cpp

@@ -128,7 +128,7 @@ static int vpr_to_phy_track(const int itrack,
                             const int chan_num,
                             const int seg_num,
                             const t_chan_seg_details* seg_details,
-                            const enum e_directionality directionality);
+                            const e_directionality directionality);
 
 /**
  * @brief Identifies and labels all mux endpoints at a given channel segment coordinate.
@@ -189,9 +189,9 @@ std::vector<int> get_seg_track_counts(int num_sets,
     // Scale factor so we can divide by any length and still use integers
     double scale = 1;
     int freq_sum = 0;
-    for (size_t i = 0; i < segment_inf.size(); ++i) {
-        scale *= segment_inf[i].length;
-        freq_sum += segment_inf[i].frequency;
+    for (const t_segment_inf& seg_inf : segment_inf) {
+        scale *= seg_inf.length;
+        freq_sum += seg_inf.frequency;
     }
     const double reduce = scale * freq_sum;
 
@@ -1082,10 +1082,10 @@ int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
                         const t_sb_connection_map* sb_conn_map) {
     int to_chan, to_sb;
     std::vector<int> conn_tracks;
-    bool from_is_sblock, is_behind, Fs_clipped;
+    bool Fs_clipped;
     e_side to_side;
 
-    /* check whether a custom switch block will be used */
+    // check whether a custom switch block will be used
     bool custom_switch_block = false;
     if (sb_conn_map != nullptr) {
         custom_switch_block = true;
@@ -1134,9 +1134,9 @@ int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
             continue;
         }
 
-        /* Figure out if we are at a sblock */
-        from_is_sblock = is_sblock(from_chan, from_seg, sb_seg, from_track,
-                                   from_seg_details, directionality);
+        // Figure out if we are at a sblock
+        bool from_is_sblock = is_sblock(from_chan, from_seg, sb_seg, from_track,
+                                        from_seg_details, directionality);
         if (sb_seg == end_sb_seg || sb_seg == start_sb_seg) {
             /* end of wire must be an sblock */
             from_is_sblock = true;
@@ -1173,9 +1173,9 @@ int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
         if (to_seg_details[0].length() == 0)
             continue;
 
-        /* Figure out whether the switch block at the current sb_seg coordinate is *behind*
-         * the target channel segment (with respect to VPR coordinate system) */
-        is_behind = false;
+        // Figure out whether the switch block at the current sb_seg coordinate is *behind*
+        // the target channel segment (with respect to VPR coordinate system)
+        bool is_behind = false;
         if (to_type == from_type) {
             if (sb_seg == start) {
                 is_behind = true;
@@ -1296,12 +1296,10 @@ static int get_bidir_track_to_chan_seg(RRGraphBuilder& rr_graph_builder,
                                        const enum e_directionality directionality,
                                        RRNodeId from_rr_node,
                                        t_rr_edge_info_set& rr_edges_to_create) {
-    unsigned iconn;
-    int to_track, to_switch, num_conn, to_x, to_y, i;
-    bool to_is_sblock;
+    int to_x, to_y;
     short switch_types[2];
 
-    /* x, y coords for get_rr_node lookups */
+    // x, y coords for get_rr_node lookups
     if (e_rr_type::CHANX == to_type) {
         to_x = to_seg;
         to_y = to_chan;
@@ -1311,27 +1309,25 @@ static int get_bidir_track_to_chan_seg(RRGraphBuilder& rr_graph_builder,
         to_y = to_seg;
     }
 
-    /* Go through the list of tracks we can connect to */
-    num_conn = 0;
-    for (iconn = 0; iconn < conn_tracks.size(); ++iconn) {
-        to_track = conn_tracks[iconn];
+    // Go through the list of tracks we can connect to
+    int num_conn = 0;
+    for (int to_track : conn_tracks) {
         RRNodeId to_node = rr_graph_builder.node_lookup().find_node(layer, to_x, to_y, to_type, to_track);
 
         if (!to_node) {
             continue;
         }
 
         /* Get the switches for any edges between the two tracks */
-        to_switch = seg_details[to_track].arch_wire_switch();
+        int to_switch = seg_details[to_track].arch_wire_switch();
 
-        to_is_sblock = is_sblock(to_chan, to_seg, to_sb, to_track, seg_details,
-                                 directionality);
+        bool to_is_sblock = is_sblock(to_chan, to_seg, to_sb, to_track, seg_details, directionality);
         get_switch_type(from_is_sblock, to_is_sblock, from_switch, to_switch,
                         switch_override,
                         switch_types);
 
-        /* There are up to two switch edges allowed from track to track */
-        for (i = 0; i < 2; ++i) {
+        // There are up to two switch edges allowed from track to track
+        for (int i = 0; i < 2; ++i) {
             /* If the switch_type entry is empty, skip it */
             if (UNDEFINED == switch_types[i]) {
                 continue;
@@ -1365,7 +1361,7 @@ static void get_switchblocks_edges(RRGraphBuilder& rr_graph_builder,
 
     // Coordinate to index into the SB map
     SwitchblockLookupKey sb_coord(tile_x, tile_y, layer, from_side, to_side);
-    if (sb_conn_map.count(sb_coord) > 0) {
+    if (sb_conn_map.contains(sb_coord)) {
         // Reference to the connections vector which lists all destination wires for a given source wire
         // at a specific coordinate sb_coord
         const std::vector<t_switchblock_edge>& sb_edges = sb_conn_map.at(sb_coord);
@@ -1549,24 +1545,22 @@ static int get_unidir_track_to_chan_seg(RRGraphBuilder& rr_graph_builder,
 }
 
 bool is_sblock(const int chan, int wire_seg, const int sb_seg, const int track, const t_chan_seg_details* seg_details, const enum e_directionality directionality) {
-    int length, ofs, fac;
-
-    fac = 1;
+    int fac = 1;
     if (UNI_DIRECTIONAL == directionality) {
         fac = 2;
     }
 
-    length = seg_details[track].length();
+    int length = seg_details[track].length();
 
-    /* Make sure they gave us correct start */
+    // Make sure they gave us correct start
     wire_seg = get_seg_start(seg_details, track, chan, wire_seg);
 
-    ofs = sb_seg - wire_seg + 1; /* Offset 0 is behind us, so add 1 */
+    int ofs = sb_seg - wire_seg + 1; // Offset 0 is behind us, so add 1
 
     VTR_ASSERT(ofs >= 0);
     VTR_ASSERT(ofs < (length + 1));
 
-    /* If unidir segment that is going backwards, we need to flip the ofs */
+    // If unidir segment that is going backwards, we need to flip the ofs
     if ((ofs % fac) > 0) {
         ofs = length - ofs;
     }
@@ -1661,28 +1655,21 @@ static int vpr_to_phy_track(const int itrack,
                             const int chan_num,
                             const int seg_num,
                             const t_chan_seg_details* seg_details,
-                            const enum e_directionality directionality) {
-    int group_start, group_size;
-    int vpr_offset_for_first_phy_track;
-    int vpr_offset, phy_offset;
-    int phy_track;
-    int fac;
+                            const e_directionality directionality) {
 
-    /* Assign in pairs if unidir. */
-    fac = 1;
+    // Assign in pairs if unidir.
+    int fac = 1;
     if (UNI_DIRECTIONAL == directionality) {
         fac = 2;
     }
 
-    group_start = seg_details[itrack].group_start();
-    group_size = seg_details[itrack].group_size();
+    int group_start = seg_details[itrack].group_start();
+    int group_size = seg_details[itrack].group_size();
 
-    vpr_offset_for_first_phy_track = (chan_num + seg_num - 1)
-                                     % (group_size / fac);
-    vpr_offset = (itrack - group_start) / fac;
-    phy_offset = (vpr_offset_for_first_phy_track + vpr_offset)
-                 % (group_size / fac);
-    phy_track = group_start + (fac * phy_offset) + (itrack - group_start) % fac;
+    int vpr_offset_for_first_phy_track = (chan_num + seg_num - 1) % (group_size / fac);
+    int vpr_offset = (itrack - group_start) / fac;
+    int phy_offset = (vpr_offset_for_first_phy_track + vpr_offset) % (group_size / fac);
+    int phy_track = group_start + (fac * phy_offset) + (itrack - group_start) % fac;
 
     return phy_track;
 }
@@ -2047,7 +2034,7 @@ static void label_incoming_wires(const int chan_num,
 
     /* Alloc the list of labels for the tracks */
     labels.resize(max_chan_width);
-    std::fill(labels.begin(), labels.end(), UN_SET);
+    std::ranges::fill(labels, UN_SET);
 
     int num_ending = 0;
     int num_passing = 0;
@@ -2134,12 +2121,12 @@ static int should_create_switchblock(const DeviceGrid& grid, int layer_num, int
         x_coord = from_chan_coord;
     }
 
-    auto blk_type = grid.get_physical_type({x_coord, y_coord, layer_num});
+    t_physical_tile_type_ptr blk_type = grid.get_physical_type({x_coord, y_coord, layer_num});
     int width_offset = grid.get_width_offset({x_coord, y_coord, layer_num});
     int height_offset = grid.get_height_offset({x_coord, y_coord, layer_num});
 
     e_sb_type sb_type = blk_type->switchblock_locations[width_offset][height_offset];
-    auto switch_override = blk_type->switchblock_switch_overrides[width_offset][height_offset];
+    int switch_override = blk_type->switchblock_switch_overrides[width_offset][height_offset];
 
     if (sb_type == e_sb_type::FULL) {
         return switch_override;

vpr/src/route/rr_graph_generation/rr_graph_sg.cpp

@@ -167,7 +167,7 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
             const t_bottleneck_link& bottleneck_link = interdie_3d_links[sb_loc0.x][sb_loc0.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);
-                selected_chanz_nodes0.push_back({node_id, bottleneck_link.arch_wire_switch});
+                selected_chanz_nodes0.emplace_back(node_id, bottleneck_link.arch_wire_switch);
             }
         }
 
@@ -176,7 +176,7 @@ void add_edges_opin_chanz_per_side(const RRGraphView& rr_graph,
             const t_bottleneck_link& bottleneck_link = interdie_3d_links[sb_loc1.x][sb_loc1.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);
-                selected_chanz_nodes1.push_back({node_id, bottleneck_link.arch_wire_switch});
+                selected_chanz_nodes1.emplace_back(node_id, bottleneck_link.arch_wire_switch);
             }
         }
 
@@ -239,7 +239,7 @@ void add_edges_opin_chanz_per_block(const RRGraphView& rr_graph,
             const t_bottleneck_link& bottleneck_link = interdie_3d_links[track_num];
             if (bottleneck_link.parallel_segment_index == seg_index && bottleneck_link.gather_loc.layer_num == layer) {
                 RRNodeId node_id = node_lookup.find_node(layer, x, y, e_rr_type::CHANZ, track_num);
-                selected_chanz_nodes.push_back({node_id, bottleneck_link.arch_wire_switch});
+                selected_chanz_nodes.emplace_back(node_id, bottleneck_link.arch_wire_switch);
             }
         }