[Spelling] Fixed Simple Spelling Mistakes in Route Dir

This is the last of the simple spelling mistakes in the VPR directory.
The rest are variable name changes which are not hard, but should be
isolated into their own commits.

NOTE: The rr_graph.cpp and rr_graph2.cpp files were left behind to
prevent issues with currently open PRs.

Author: AlexandreSinger

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 neighbors
         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 {