typos and references

Author: soheilshahrouz

libs/libarchfpga/src/physical_types.h

@@ -1558,8 +1558,8 @@ enum e_Fc_type {
  * seg_index: The index of the segment as stored in the appropriate Segs list*
  *            Upon loading the architecture, we use this field to keep track *
  *            the segment's index in the unified segment_inf vector. This is *
- *            usefull when building the rr_graph for different Y & X channels*
- *            interms of track distribution and segment type.                *
+ *            useful when building the rr_graph for different Y & X channels *
+ *            in terms of track distribution and segment type.                *
  * meta: Table storing extra arbitrary metadata attributes.                  */
 struct t_segment_inf {
     std::string name;

vpr/src/base/vpr_types.h

@@ -1682,7 +1682,7 @@ class t_chan_seg_details {
 
   private:
     //The only unique information about a channel segment is it's start/end
-    //and length.  All other information is shared accross segment types,
+    //and length.  All other information is shared across segment types,
     //so we use a flyweight to the t_seg_details which defines that info.
     //
     //To preserve the illusion of uniqueness we wrap all t_seg_details members

vpr/src/place/timing_place_lookup.cpp

@@ -195,6 +195,7 @@ std::unique_ptr<PlaceDelayModel> compute_place_delay_model(const t_placer_opts&
                                                                           router_opts.read_router_lookahead,
                                                                           segment_inf,
                                                                           is_flat);
+
     RouterDelayProfiler route_profiler(net_list, router_lookahead, is_flat);
 
     int longest_length = get_longest_segment_length(segment_inf);

vpr/src/route/router_delay_profiling.cpp

@@ -243,7 +243,7 @@ vtr::vector<RRNodeId, float> calculate_all_path_delays_from_rr_node(RRNodeId src
     return path_delays_to;
 }
 
-void alloc_routing_structs(t_chan_width chan_width,
+void alloc_routing_structs(const t_chan_width& chan_width,
                            const t_router_opts& router_opts,
                            t_det_routing_arch* det_routing_arch,
                            std::vector<t_segment_inf>& segment_inf,

vpr/src/route/router_delay_profiling.h

@@ -54,7 +54,7 @@ vtr::vector<RRNodeId, float> calculate_all_path_delays_from_rr_node(RRNodeId src
                                                                     const t_router_opts& router_opts,
                                                                     bool is_flat);
 
-void alloc_routing_structs(t_chan_width chan_width,
+void alloc_routing_structs(const t_chan_width& chan_width,
                            const t_router_opts& router_opts,
                            t_det_routing_arch* det_routing_arch,
                            std::vector<t_segment_inf>& segment_inf,

vpr/src/route/router_lookahead.cpp

@@ -7,7 +7,16 @@
 #include "vpr_error.h"
 #include "globals.h"
 
-static int get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node, int* num_segs_ortho_dir_ptr);
+/**
+ * Assuming inode is CHANX or CHANY, this function calculates the number of required wires of the same type as inode
+ * to arrive at target_noe.
+ * @param inode The source node from which the cost to the target node is obtained.
+ * @param target_node The target node to which the cost is obtained.
+ * @return std::pait<int, int> The first element is the number of required wires in the same direction as inode,
+ * while the second element determines the number of wires in the direction orthogonal to inode.
+ */
+static std::pair<int, int> get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node);
+
 static int round_up(float x);
 
 static std::unique_ptr<RouterLookahead> make_router_lookahead_object(const t_det_routing_arch& det_routing_arch,
@@ -31,8 +40,8 @@ static std::unique_ptr<RouterLookahead> make_router_lookahead_object(const t_det
 
 std::unique_ptr<RouterLookahead> make_router_lookahead(const t_det_routing_arch& det_routing_arch,
                                                        e_router_lookahead router_lookahead_type,
-                                                       std::string write_lookahead,
-                                                       std::string read_lookahead,
+                                                       const std::string& write_lookahead,
+                                                       const std::string& read_lookahead,
                                                        const std::vector<t_segment_inf>& segment_inf,
                                                        bool is_flat) {
     std::unique_ptr<RouterLookahead> router_lookahead = make_router_lookahead_object(det_routing_arch,
@@ -53,8 +62,7 @@ std::unique_ptr<RouterLookahead> make_router_lookahead(const t_det_routing_arch&
 }
 
 float ClassicLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target_node, const t_conn_cost_params& params, float R_upstream) const {
-    float delay_cost, cong_cost;
-    std::tie(delay_cost, cong_cost) = get_expected_delay_and_cong(current_node, target_node, params, R_upstream);
+    auto [delay_cost, cong_cost] = get_expected_delay_and_cong(current_node, target_node, params, R_upstream);
 
     return delay_cost + cong_cost;
 }
@@ -66,8 +74,7 @@ std::pair<float, float> ClassicLookahead::get_expected_delay_and_cong(RRNodeId n
     t_rr_type rr_type = rr_graph.node_type(node);
 
     if (rr_type == CHANX || rr_type == CHANY) {
-        int num_segs_ortho_dir = 0;
-        int num_segs_same_dir = get_expected_segs_to_target(node, target_node, &num_segs_ortho_dir);
+        auto [num_segs_same_dir, num_segs_ortho_dir] = get_expected_segs_to_target(node, target_node);
 
         auto cost_index = rr_graph.node_cost_index(node);
         int ortho_cost_index = device_ctx.rr_indexed_data[cost_index].ortho_cost_index;
@@ -112,28 +119,27 @@ static int round_up(float x) {
     return std::ceil(x - 0.001);
 }
 
-static int get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node, int* num_segs_ortho_dir_ptr) {
+static std::pair<int, int> get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node) {
     /* Returns the number of segments the same type as inode that will be needed *
      * to reach target_node (not including inode) in each direction (the same    *
      * direction (horizontal or vertical) as inode and the orthogonal direction).*/
-
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
-    t_rr_type rr_type;
-    int target_x, target_y, num_segs_same_dir, ortho_cost_index;
-    RRIndexedDataId cost_index;
+    int num_segs_ortho_dir;
+    int num_segs_same_dir;
+
     int no_need_to_pass_by_clb;
-    float inv_length, ortho_inv_length, ylow, yhigh, xlow, xhigh;
+    float ylow, yhigh, xlow, xhigh;
 
-    target_x = rr_graph.node_xlow(target_node);
-    target_y = rr_graph.node_ylow(target_node);
+    int target_x = rr_graph.node_xlow(target_node);
+    int target_y = rr_graph.node_ylow(target_node);
 
-    cost_index = rr_graph.node_cost_index(inode);
-    inv_length = device_ctx.rr_indexed_data[cost_index].inv_length;
-    ortho_cost_index = device_ctx.rr_indexed_data[cost_index].ortho_cost_index;
-    ortho_inv_length = device_ctx.rr_indexed_data[RRIndexedDataId(ortho_cost_index)].inv_length;
-    rr_type = rr_graph.node_type(inode);
+    RRIndexedDataId cost_index = rr_graph.node_cost_index(inode);
+    float inv_length = device_ctx.rr_indexed_data[cost_index].inv_length;
+    int ortho_cost_index = device_ctx.rr_indexed_data[cost_index].ortho_cost_index;
+    float ortho_inv_length = device_ctx.rr_indexed_data[RRIndexedDataId(ortho_cost_index)].inv_length;
+    t_rr_type rr_type = rr_graph.node_type(inode);
 
     if (rr_type == CHANX) {
         ylow = rr_graph.node_ylow(inode);
@@ -143,13 +149,13 @@ static int get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node, int
         /* Count vertical (orthogonal to inode) segs first. */
 
         if (ylow > target_y) { /* Coming from a row above target? */
-            *num_segs_ortho_dir_ptr = round_up((ylow - target_y + 1.) * ortho_inv_length);
+            num_segs_ortho_dir = round_up((ylow - target_y + 1.) * ortho_inv_length);
             no_need_to_pass_by_clb = 1;
         } else if (ylow < target_y - 1) { /* Below the CLB bottom? */
-            *num_segs_ortho_dir_ptr = round_up((target_y - ylow) * ortho_inv_length);
+            num_segs_ortho_dir = round_up((target_y - ylow) * ortho_inv_length);
             no_need_to_pass_by_clb = 1;
         } else { /* In a row that passes by target CLB */
-            *num_segs_ortho_dir_ptr = 0;
+            num_segs_ortho_dir = 0;
             no_need_to_pass_by_clb = 0;
         }
 
@@ -170,13 +176,13 @@ static int get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node, int
         /* Count horizontal (orthogonal to inode) segs first. */
 
         if (xlow > target_x) { /* Coming from a column right of target? */
-            *num_segs_ortho_dir_ptr = round_up((xlow - target_x + 1.) * ortho_inv_length);
+            num_segs_ortho_dir = round_up((xlow - target_x + 1.) * ortho_inv_length);
             no_need_to_pass_by_clb = 1;
         } else if (xlow < target_x - 1) { /* Left of and not adjacent to the CLB? */
-            *num_segs_ortho_dir_ptr = round_up((target_x - xlow) * ortho_inv_length);
+            num_segs_ortho_dir = round_up((target_x - xlow) * ortho_inv_length);
             no_need_to_pass_by_clb = 1;
         } else { /* In a column that passes by target CLB */
-            *num_segs_ortho_dir_ptr = 0;
+            num_segs_ortho_dir = 0;
             no_need_to_pass_by_clb = 0;
         }
 
@@ -191,7 +197,7 @@ static int get_expected_segs_to_target(RRNodeId inode, RRNodeId target_node, int
         }
     }
 
-    return (num_segs_same_dir);
+    return {num_segs_same_dir, num_segs_ortho_dir};
 }
 
 void invalidate_router_lookahead_cache() {
@@ -201,8 +207,8 @@ void invalidate_router_lookahead_cache() {
 
 const RouterLookahead* get_cached_router_lookahead(const t_det_routing_arch& det_routing_arch,
                                                    e_router_lookahead router_lookahead_type,
-                                                   std::string write_lookahead,
-                                                   std::string read_lookahead,
+                                                   const std::string& write_lookahead,
+                                                   const std::string& read_lookahead,
                                                    const std::vector<t_segment_inf>& segment_inf,
                                                    bool is_flat) {
     auto& router_ctx = g_vpr_ctx.routing();

vpr/src/route/router_lookahead.h

@@ -92,8 +92,8 @@ class RouterLookahead {
  */
 std::unique_ptr<RouterLookahead> make_router_lookahead(const t_det_routing_arch& det_routing_arch,
                                                        e_router_lookahead router_lookahead_type,
-                                                       std::string write_lookahead,
-                                                       std::string read_lookahead,
+                                                       const std::string& write_lookahead,
+                                                       const std::string& read_lookahead,
                                                        const std::vector<t_segment_inf>& segment_inf,
                                                        bool is_flat);
 
@@ -115,8 +115,8 @@ void invalidate_router_lookahead_cache();
  */
 const RouterLookahead* get_cached_router_lookahead(const t_det_routing_arch& det_routing_arch,
                                                    e_router_lookahead router_lookahead_type,
-                                                   std::string write_lookahead,
-                                                   std::string read_lookahead,
+                                                   const std::string& write_lookahead,
+                                                   const std::string& read_lookahead,
                                                    const std::vector<t_segment_inf>& segment_inf,
                                                    bool is_flat);
 

vpr/src/route/router_lookahead_map.cpp

@@ -17,14 +17,12 @@
  * which are reachable from each physical tile type's SOURCEs/OPINs (f_src_opin_delays). This is used for
  * SRC/OPIN -> CHANX/CHANY estimates.
  *
- * In the case of SRC/OPIN -> SINK estimates the resuls from the two look-ups are added together (and the minimum taken
- * if there are multiple possiblities).
+ * In the case of SRC/OPIN -> SINK estimates the results from the two look-ups are added together (and the minimum taken
+ * if there are multiple possibilities).
  */
 
 #include <cmath>
 #include <vector>
-#include <queue>
-#include <ctime>
 #include "connection_router_interface.h"
 #include "vpr_types.h"
 #include "vpr_error.h"
@@ -50,7 +48,7 @@
 #    include "serdes_utils.h"
 #endif /* VTR_ENABLE_CAPNPROTO */
 
-const int VALID_NEIGHBOR_NUMBER = 3;
+static constexpr int VALID_NEIGHBOR_NUMBER = 3;
 
 /* when a list of delay/congestion entries at a coordinate in Cost_Entry is boiled down to a single
  * representative entry, this enum is passed-in to specify how that representative entry should be
@@ -176,15 +174,12 @@ float MapLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target_nod
 
     VTR_ASSERT_SAFE(rr_graph.node_type(target_node) == t_rr_type::SINK);
 
-    float delay_cost = 0.;
-    float cong_cost = 0.;
-
     if (is_flat_) {
         return get_expected_cost_flat_router(current_node, target_node, params, R_upstream);
     } else {
         if (from_rr_type == CHANX || from_rr_type == CHANY || from_rr_type == SOURCE || from_rr_type == OPIN) {
             // Get the total cost using the combined delay and congestion costs
-            std::tie(delay_cost, cong_cost) = get_expected_delay_and_cong(current_node, target_node, params, R_upstream);
+            auto [delay_cost, cong_cost] = get_expected_delay_and_cong(current_node, target_node, params, R_upstream);
             return delay_cost + cong_cost;
         } else if (from_rr_type == IPIN) { /* Change if you're allowing route-throughs */
             return (device_ctx.rr_indexed_data[RRIndexedDataId(SINK_COST_INDEX)].base_cost);

vpr/src/route/rr_graph.cpp

@@ -628,7 +628,7 @@ static void build_rr_graph(const t_graph_type graph_type,
                            t_chan_width nodes_per_chan,
                            const enum e_switch_block_type sb_type,
                            const int Fs,
-                           const std::vector<t_switchblock_inf> switchblocks,
+                           const std::vector<t_switchblock_inf>& switchblocks,
                            const std::vector<t_segment_inf>& segment_inf,
                            const int global_route_switch,
                            const int wire_to_arch_ipin_switch,
@@ -660,7 +660,7 @@ static void build_intra_cluster_rr_graph(const t_graph_type graph_type,
 void create_rr_graph(const t_graph_type graph_type,
                      const std::vector<t_physical_tile_type>& block_types,
                      const DeviceGrid& grid,
-                     const t_chan_width nodes_per_chan,
+                     const t_chan_width& nodes_per_chan,
                      t_det_routing_arch* det_routing_arch,
                      const std::vector<t_segment_inf>& segment_inf,
                      const t_router_opts& router_opts,
@@ -944,7 +944,7 @@ static void build_rr_graph(const t_graph_type graph_type,
                            t_chan_width nodes_per_chan,
                            const enum e_switch_block_type sb_type,
                            const int Fs,
-                           const std::vector<t_switchblock_inf> switchblocks,
+                           const std::vector<t_switchblock_inf>& switchblocks,
                            const std::vector<t_segment_inf>& segment_inf,
                            const int global_route_switch,
                            const int wire_to_arch_ipin_switch,
@@ -1011,16 +1011,16 @@ static void build_rr_graph(const t_graph_type graph_type,
         seg_details_y = alloc_and_load_global_route_seg_details(global_route_switch, &num_seg_details_y);
 
     } else {
-        /* Setup segments including distrubuting tracks and staggering.
+        /* Setup segments including distributing tracks and staggering.
          * If use_full_seg_groups is specified, max_chan_width may be
          * changed. Warning should be singled to caller if this happens. */
 
-        /* Need to setup segments along x & y axis seperately, due to different 
+        /* Need to setup segments along x & y axes separately, due to different
          * max_channel_widths and segment specifications. */
 
         size_t max_dim = std::max(grid.width(), grid.height()) - 2; //-2 for no perim channels
 
-        /*Get x & y segments seperately*/
+        /*Get x & y segments separately*/
         seg_details_x = alloc_and_load_seg_details(&max_chan_width_x,
                                                    max_dim, segment_inf_x,
                                                    use_full_seg_groups, directionality,
@@ -1086,7 +1086,7 @@ static void build_rr_graph(const t_graph_type graph_type,
         }
     }
 
-    /* get the number of 'sets' for each segment type -- unidirectial architectures have two tracks in a set, bidirectional have one */
+    /* get the number of 'sets' for each segment type -- unidirectional architectures have two tracks in a set, bidirectional have one */
     int total_sets = max_chan_width;
     int total_sets_x = max_chan_width_x;
     int total_sets_y = max_chan_width_y;

vpr/src/route/rr_graph.h

@@ -23,7 +23,7 @@ enum {
 void create_rr_graph(const t_graph_type graph_type,
                      const std::vector<t_physical_tile_type>& block_types,
                      const DeviceGrid& grid,
-                     t_chan_width nodes_per_chan,
+                     const t_chan_width& nodes_per_chan,
                      t_det_routing_arch* det_routing_arch,
                      const std::vector<t_segment_inf>& segment_inf,
                      const t_router_opts& router_opts,