[Spelling] Fixed Simple Spelling Mistakes in Route Dir

vpr/src/route/parallel_connection_router.cpp

@@ -17,7 +17,7 @@ static inline bool post_target_prune_node(float new_total_cost,
     // This is a correction factor to the forward cost to make the total
     // cost an under-estimate.
     // TODO: Should investigate creating a heuristic function that is
-    //       gaurenteed to be an under-estimate.
+    //       guaranteed to be an under-estimate.
     // NOTE: Found experimentally that using the original heuristic to order
     //       the nodes in the queue and then post-target pruning based on the
     //       under-estimating heuristic has better runtime.
@@ -80,7 +80,7 @@ static inline bool prune_node(RRNodeId inode,
     if (new_back_cost == best_back_cost) {
 #ifndef NON_DETERMINISTIC_PRUNING
         // With deterministic pruning, cannot always prune on ties.
-        // In the case of a true tie, just prune, no need to explore neightbors
+        // In the case of a true tie, just prune, no need to explore neighbours
         RREdgeId best_prev_edge = route_inf->prev_edge;
         if (new_prev_edge == best_prev_edge)
             return true;
@@ -95,7 +95,7 @@ static inline bool prune_node(RRNodeId inode,
             return false;
         // Finally, if this node is not coming from a preferred edge, prune
         // Deterministic version prefers a given EdgeID, so a unique path is returned since,
-        // in the case of a tie, a determinstic path wins.
+        // in the case of a tie, a deterministic path wins.
         // Is first preferred over second?
         auto is_preferred_edge = [](RREdgeId first, RREdgeId second) {
             return first < second;
@@ -134,10 +134,10 @@ static inline bool should_not_explore_neighbors(RRNodeId inode,
                                                 const t_conn_cost_params& params) {
 #ifndef NON_DETERMINISTIC_PRUNING
     // For deterministic pruning, cannot enforce anything on the total cost since
-    // traversal order is not gaurenteed. However, since total cost is used as a
+    // traversal order is not guaranteed. However, since total cost is used as a
     // "key" to signify that this node is the last node that was pushed, we can
     // just check for equality. There is a chance this may cause some duplicates
-    // for the deterministic case, but thats ok they will be handled.
+    // for the deterministic case, but that's ok they will be handled.
     // TODO: Maybe consider having the non-deterministic version do this too.
     if (new_total_cost != rr_node_route_inf_[inode].path_cost)
         return true;

vpr/src/route/route_budgets.cpp

@@ -333,7 +333,7 @@ float route_budgets::minimax_PERT(std::shared_ptr<SetupHoldTimingInfo> orig_timi
                                   bool keep_in_bounds,
                                   slack_allocated_type slack_type) {
     /*This function uses weights to calculate how much slack to allocate to a connection.
-     * The weights are deteremined by how much delay of the whole path is present in this connection*/
+     * The weights are determined by how much delay of the whole path is present in this connection*/
 
     std::shared_ptr<const tatum::SetupHoldTimingAnalyzer> timing_analyzer = orig_timing_info->setup_hold_analyzer();
     float total_path_delay = 0;
@@ -736,7 +736,7 @@ bool route_budgets::increase_min_budgets_if_struggling(float delay_increment,
                             delay_max_budget[net_id][ipin] += 2 * delay_increment;
                         }
 
-                        // Increase short path criticality as well, this encourages the router to meet the lower delay budgets more aggresively
+                        // Increase short path criticality as well, this encourages the router to meet the lower delay budgets more aggressively
                         if (short_path_crit[net_id][ipin] < MAX_SHORT_PATH_CRIT) short_path_crit[net_id][ipin] *= 2;
                     }
                 }
@@ -762,8 +762,6 @@ void route_budgets::increase_short_crit(ParentNetId net_id, float delay_decs) {
         // VTR_LOG("Increasing short path crit for net %d\n", net_id);
         for (auto pin_id : net_list_.net_sinks(net_id)) {
             int ipin = net_list_.pin_net_index(pin_id);
-            // if (!once) VTR_LOG("Net %d crit %f scrit %f \n", net_id, pin_criticality[pin_id], budgeting_inf.get_crit_short_path(net_id, ipin));
-            // once = true;
             short_path_crit[net_id][ipin] *= delay_decs;
         }
         num_times_congested[net_id] = 0;
@@ -772,8 +770,6 @@ void route_budgets::increase_short_crit(ParentNetId net_id, float delay_decs) {
     // if (num_times_congested[net_id] >= 9) {
     //     for (auto pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
     //         int ipin = cluster_ctx.clb_nlist.pin_net_index(pin_id);
-    //         // if (!once) VTR_LOG("Net %d crit %f scrit %f \n", net_id, pin_criticality[pin_id], budgeting_inf.get_crit_short_path(net_id, ipin));
-    //         // once = true;
     //         delay_min_budget[net_id][ipin] *= 1.5;
     //         keep_budget_in_bounds(delay_min_budget, net_id, pin_id);
     //     }

vpr/src/route/route_common.cpp

@@ -837,7 +837,7 @@ void add_to_mod_list(RRNodeId inode, std::vector<RRNodeId>& modified_rr_node_inf
 // so long as it is from the appropriate SRC).
 //
 // This correctly models 'full' equivalence (e.g. if there is a full crossbar between the outputs), but is too
-// optimistic for 'instance' equivalence (which typcially models the pin equivalence possible by swapping sub-block
+// optimistic for 'instance' equivalence (which typically models the pin equivalence possible by swapping sub-block
 // instances like BLEs). In particular, for the 'instance' equivalence case, some of the 'equivalent' block outputs
 // may be used by internal signals which are routed entirely *within* the block (i.e. the signals which never leave
 // the block). These signals effectively 'use-up' an output pin which should now be unavailable to the router.

vpr/src/route/route_net.tpp

@@ -161,7 +161,7 @@ inline NetResultFlags route_net(ConnectionRouterType& router,
             || route_constraints.get_route_model_by_net_name(net_name) == e_clock_modeling::DEDICATED_NETWORK) {
             std::string clock_network_name = "";
 
-            // If a user-specified routing constratins exists for the curret net get the clock network name
+            // If a user-specified routing constraints exists for the current net get the clock network name
             // from the constraints file, otherwise use the default clock network name
             if (route_constraints.has_routing_constraint(net_name)) {
                 clock_network_name = route_constraints.get_routing_network_name_by_net_name(net_name);

vpr/src/route/route_profiling.cpp

@@ -103,10 +103,10 @@ void time_on_fanout_analysis() {
             entire_net_rerouted, entire_tree_pruned, part_tree_preserved);
     VTR_LOG("%d connections marked for forced reroute, %d forced reroutes performed\n", connections_forced_to_reroute, connections_rerouted_due_to_forcing);
     // using the global time_on_fanout and itry_on_fanout
-    VTR_LOG("fanout low      time (s)        attemps  rebuild tree time (s)   finished sinks   rerouted sinks\n");
+    VTR_LOG("fanout low      time (s)        attempts  rebuild tree time (s)   finished sinks   rerouted sinks\n");
     for (size_t bin = 0; bin < time_on_fanout.size(); ++bin) {
         if (itry_on_fanout[bin]) { // avoid printing the many 0 bins
-            VTR_LOG("%4d      %14.3f   %12d     %14.3f   %12d  %12d\n",
+            VTR_LOG("%4d      %14.3f   %12d      %14.3f   %12d  %12d\n",
                     bin * fanout_per_bin,
                     time_on_fanout[bin],
                     itry_on_fanout[bin],
@@ -124,7 +124,7 @@ void time_on_fanout_analysis() {
 }
 
 void time_on_criticality_analysis() {
-    VTR_LOG("criticality low           time (s)        attemps\n");
+    VTR_LOG("criticality low           time (s)        attempts\n");
     for (size_t bin = 0; bin < time_on_criticality.size(); ++bin) {
         if (itry_on_criticality[bin]) { // avoid printing the many 0 bins
             VTR_LOG("%4f           %14.3f   %12d\n", bin * criticality_per_bin, time_on_criticality[bin], itry_on_criticality[bin]);

vpr/src/route/route_tree.cpp

@@ -291,7 +291,7 @@ RouteTree::update_unbuffered_ancestors_C_downstream(RouteTreeNode& from_node) {
 
     /* Having set the value of C_downstream_addition, we must check whether the parent switch
      * is a buffered or unbuffered switch with the if statement below. If the parent switch is
-     * a buffered switch, then the parent node's downsteam capacitance is increased by the
+     * a buffered switch, then the parent node's downstream capacitance is increased by the
      * value of the parent switch's internal capacitance in the if statement below.
      * Correspondingly, the ancestors' downstream capacitance will be updated by the same
      * value through the while loop. Otherwise, if the parent switch is unbuffered, then

vpr/src/route/route_utils.h

@@ -130,7 +130,7 @@ void prune_unused_non_configurable_nets(CBRR& connections_inf,
 
 /** If flat_routing and router_opt_choke_points are true, there are some choke points inside the cluster which would increase the convergence time of routing.
  * To address this issue, the congestion cost of those choke points needs to decrease. This function identify those choke points for each net,
- * and since the amount of congestion reduction is dependant on the number sinks reachable from that choke point, it also store the number of reachable sinks
+ * and since the amount of congestion reduction is dependent on the number sinks reachable from that choke point, it also store the number of reachable sinks
  * for each choke point.
  * @param net_list
  * @param net_terminal_groups [Net_id][group_id] -> rr_node_id of the pins in the group

vpr/src/route/router_lookahead/router_lookahead_compressed_map.cpp

@@ -245,7 +245,7 @@ static util::Cost_Entry get_nearby_cost_entry_compressed_lookahead(int from_laye
     /* compute the slope from x,y to 0,0 and then move towards 0,0 by one unit to get the coordinates
      * of the cost entry to be copied */
 
-    //VTR_ASSERT(x > 0 || y > 0); //Asertion fails in practise. TODO: debug
+    //VTR_ASSERT(x > 0 || y > 0); //Assertion fails in practise. TODO: debug
 
     float slope;
     if (x == 0) {

vpr/src/route/router_lookahead/router_lookahead_cost_map.cpp

@@ -14,7 +14,7 @@
 #endif
 
 // Lookahead penalties constants
-// Penalities are added for deltas that are outside of a specific segment bounding box region.
+// Penalties are added for deltas that are outside of a specific segment bounding box region.
 // These penalties are calculated based on the distance of the requested delta to a valid closest point of the bounding
 // box.
 

vpr/src/route/router_lookahead/router_lookahead_cost_map.h

@@ -16,7 +16,7 @@
  *
  * Originally, the first dimension was used to differentiate the lookahead between CHANX and CHANY nodes. It turns out
  * that this distinction leads to worse results when using the extended map lookahead, therefore, this dimension of the cost map
- * has been collapsed, therefore this first dimention is virtually unused, but is kept to have the extended map lookahead as close
+ * has been collapsed, therefore this first dimension is virtually unused, but is kept to have the extended map lookahead as close
  * as possible to the original extended map.
  */
 class CostMap {

vpr/src/route/router_lookahead/router_lookahead_extended_map.cpp

@@ -228,8 +228,8 @@ std::pair<float, float> ExtendedMapLookahead::get_expected_delay_and_cong(RRNode
     // The CHAN -> IPIN delay gets re-added to the final calculation as it effectively is a valid delay
     // to reach the destination.
     //
-    // TODO: Capture this delay as a funtion of both the current wire type and the ipin to have a more
-    //       realistic excpected cost returned.
+    // TODO: Capture this delay as a function of both the current wire type and the ipin to have a more
+    //       realistic expected cost returned.
     float site_pin_delay = this->get_chan_ipin_delays(to_node);
     expected_delay += site_pin_delay;
 
@@ -465,7 +465,7 @@ void ExtendedMapLookahead::compute(const std::vector<t_segment_inf>& segment_inf
                 // and the second to find minimum base costs.
                 //
                 // NOTE: Doing two separate dijkstra expansions, each finding a minimum value leads to have an optimistic lookahead,
-                //       given that delay and base costs may not be simultaneously achievemnts.
+                //       given that delay and base costs may not be simultaneously achievements.
                 //       Experiments have shown that the having two separate expansions lead to better results for Series 7 devices, but
                 //       this might not be true for Stratix ones.
                 {
@@ -499,7 +499,7 @@ void ExtendedMapLookahead::compute(const std::vector<t_segment_inf>& segment_inf
         // The mutex locks the common data structures that each worker uses to store the routing
         // expansion data.
         //
-        // This because delay_costs and base_costs are in the worker's scope, so they can be run parallely and
+        // This because delay_costs and base_costs are in the worker's scope, so they can be run in parallel and
         // no data is shared among workers.
         // Instead, all_delay_costs and all_base_costs is a shared object between all the workers, hence the
         // need of a mutex when modifying their entries.

vpr/src/route/router_lookahead/router_lookahead_map.cpp

@@ -629,7 +629,7 @@ static util::Cost_Entry get_nearby_cost_entry(int from_layer_num, int x, int y,
     /* compute the slope from x,y to 0,0 and then move towards 0,0 by one unit to get the coordinates
      * of the cost entry to be copied */
 
-    //VTR_ASSERT(x > 0 || y > 0); //Asertion fails in practise. TODO: debug
+    //VTR_ASSERT(x > 0 || y > 0); //Assertion fails in practise. TODO: debug
 
     float slope;
     if (x == 0) {
@@ -908,7 +908,7 @@ static void min_opin_distance_cost_map(const util::t_src_opin_delays& src_opin_d
 }
 
 //
-// When writing capnp targetted serialization, always allow compilation when
+// When writing capnp targeted serialization, always allow compilation when
 // VTR_ENABLE_CAPNPROTO=OFF.  Generally this means throwing an exception
 // instead.
 //

vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp

@@ -118,7 +118,7 @@ static constexpr int Y_OFFSET = 2;
 // want to have the data on the last delay to get to an IPIN, we do not want to have an unbounded
 // number of hops to get to the IPIN, as this would result in high run-times.
 //
-// E.g.: if the constant value is set to 2, the following expansions are perfomed:
+// E.g.: if the constant value is set to 2, the following expansions are performed:
 //          - CHANX --> CHANX --> exploration interrupted: Maximum expansion level reached
 //          - CHANX --> IPIN --> exploration interrupted: IPIN found, no need to expand further
 static constexpr int MAX_EXPANSION_LEVEL = 1;
@@ -261,7 +261,7 @@ Cost_Entry Expansion_Cost_Entry::get_geomean_entry() const {
 
 /* returns a cost entry that represents the medial of all recorded entries */
 Cost_Entry Expansion_Cost_Entry::get_median_entry() const {
-    /* find median by binning the delays of all entries and then chosing the bin
+    /* find median by binning the delays of all entries and then choosing the bin
      * with the largest number of entries */
 
     // This is code that needs to be revisited. For the time being, if the median entry
@@ -1424,7 +1424,7 @@ static void expand_dijkstra_neighbours(util::PQ_Entry parent_entry,
         util::PQ_Entry child_entry(child_node, switch_ind, parent_entry.delay,
                                    parent_entry.R_upstream, parent_entry.congestion_upstream, false);
 
-        //VTR_ASSERT(child_entry.cost >= 0); //Asertion fails in practise. TODO: debug
+        //VTR_ASSERT(child_entry.cost >= 0); //Assertion fails in practise. TODO: debug
 
         /* skip this child if it has been visited with smaller cost */
         if (node_visited_costs[child_node] >= 0 && node_visited_costs[child_node] < child_entry.cost) {
@@ -1457,7 +1457,7 @@ static std::pair<int, int> get_adjusted_rr_position(const RRNodeId rr) {
 
 static std::pair<int, int> get_adjusted_rr_pin_position(const RRNodeId rr) {
     /*
-     * VPR uses a co-ordinate system where wires above and to the right of a block
+     * VPR uses a coordinate system where wires above and to the right of a block
      * are at the same location as the block:
      *
      *

vpr/src/route/router_lookahead/router_lookahead_map_utils.h

@@ -346,7 +346,7 @@ t_routing_cost_map get_routing_cost_map(int longest_seg_length,
  * @param delta_x
  * @param delta_y
  * @param to_layer_num
- * @param wire_cost_func call back function that would return a cost ot get to a given location from the given segment
+ * @param wire_cost_func call back function that would return a cost to get to a given location from the given segment
  * @return (delay, congestion)
  */
 std::pair<float, float> get_cost_from_src_opin(const std::map<int, util::t_reachable_wire_inf>& src_opin_delay_map,

vpr/src/route/router_lookahead/router_lookahead_report.cpp

@@ -35,7 +35,7 @@ namespace {
 /**
  * @brief Struct to hold overestimation information found while profiling
  *        sample routes. Here, overestimation is defined as the amount the
- *        router lookahead (heuristic_delay) overestimated the actualy delay
+ *        router lookahead (heuristic_delay) overestimated the actually delay
  *        of the path (path_delay).
  */
 struct t_overestimation_info {
@@ -256,7 +256,7 @@ static void profile_lookahead_overestimation(std::ofstream& os,
     os << "Important metrics in the data below include the Mean Squared Error (MSE)\n";
     os << "between the estimated cost of the path and the actual cost of the path, and\n";
     os << "the worst overestimation of the cost of the path. The MSE measures how\n";
-    os << "acccurate the router lookahead is. The more accurate the router lookahead\n";
+    os << "accurate the router lookahead is. The more accurate the router lookahead\n";
     os << "is, the faster the router will be while maintaining good quality. The\n";
     os << "max overestimation is a measure of how admissible the router lookahead is\n";
     os << "as a heuristic in the router. The higher this number is, the worse the\n";

vpr/src/route/router_lookahead/router_lookahead_simple.cpp

@@ -135,7 +135,7 @@ static util::Cost_Entry get_wire_cost_entry(e_rr_type rr_type, int seg_index, in
 }
 
 //
-// When writing capnp targetted serialization, always allow compilation when
+// When writing capnp targeted serialization, always allow compilation when
 // VTR_ENABLE_CAPNPROTO=OFF.  Generally this means throwing an exception
 // instead.
 //

vpr/src/route/rr_graph_generation/build_switchblocks.cpp

@@ -60,7 +60,7 @@
  *
  * The 'wireconn' entries define ordered source/destination sets of wire segments that should be connected with the specified permutation functions. The wireconn entries essentially "re-index" the channel so that a permutation function of 't/2' means that the t'th wire segment in the source wireconn set should connect to the [(t/2)%W]'th wire segment in the destination set where W is the size, or effective channel width, of the destination set (note that permutation functions are implicitly modulo W so that all functions evaluate to a number that indexes into the destination set).
  *
- * <!-- Specify that custom switch blocks will be used. This is backwards compatible with VPR's previous wilton/subset/univeral specification,
+ * <!-- Specify that custom switch blocks will be used. This is backwards compatible with VPR's previous wilton/subset/universal specification,
  * but "custom" is specified instead. -->
  * <switch_block type="custom"/>			<-- backwards-compatible with VPR's previous wilton/subset/universal/full specification
  * ...