Merge pull request #3360 from AlexandreSinger/feature-spelling

[Spelling] Fixed Simple Spelling Mistakes in Route Dir

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