[vpr][route] renaming remaining has_choke_points

Author: amin1377

libs/libarchfpga/src/physical_types.h

@@ -1382,7 +1382,7 @@ class t_pb_graph_pin {
     float tco_max = std::numeric_limits<float>::quiet_NaN(); /* For sequential logic elements the maximum clock to output time */
     t_pb_graph_pin* associated_clock_pin = nullptr;          /* For sequentail elements, the associated clock */
 
-    /* This member is used when flat-routing and has_choking_spot are enabled.
+    /* This member is used when flat-routing and router_opt_choke_points are enabled.
      * It is used to identify choke points.
      * This is only valid for IPINs, and it only contain the pins that are reachable to the pin by a forwarding path.
      * It doesn't take into account feed-back connection.

vpr/src/base/ShowSetup.cpp

@@ -255,7 +255,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         VTR_LOG("false\n");
     }
 
-    VTR_LOG("RouterOpts.has_choking_spot: ");
+    VTR_LOG("RouterOpts.router_opt_choke_points: ");
     if (RouterOpts.has_choke_point) {
         VTR_LOG("true\n");
     } else {

vpr/src/route/connection_router.cpp

@@ -775,7 +775,7 @@ void ConnectionRouter<Heap>::evaluate_timing_driven_node_costs(t_heap* to,
         //cost.
         cong_cost = 0.;
     }
-    if (conn_params_->has_choking_spot_ && is_flat_ && rr_graph_->node_type(to_node) == IPIN) {
+    if (conn_params_->router_opt_choke_points_ && is_flat_ && rr_graph_->node_type(to_node) == IPIN) {
         auto find_res = conn_params_->connection_choking_spots_.find(to_node);
         if (find_res != conn_params_->connection_choking_spots_.end()) {
             cong_cost = cong_cost / pow(2, (float)find_res->second);

vpr/src/route/route_net.tpp

@@ -436,8 +436,8 @@ inline NetResultFlags route_sink(ConnectionRouter& router,
     bool sink_critical = (cost_params.criticality > HIGH_FANOUT_CRITICALITY_THRESHOLD);
     bool net_is_clock = route_ctx.is_clock_net[net_id] != 0;
 
-    bool has_choking_spot = ((int)choking_spots[target_pin].size() != 0) && router_opts.has_choke_point;
-    ConnectionParameters conn_params(net_id, target_pin, has_choking_spot, choking_spots[target_pin]);
+    bool router_opt_choke_points = ((int)choking_spots[target_pin].size() != 0) && router_opts.has_choke_point;
+    ConnectionParameters conn_params(net_id, target_pin, router_opt_choke_points, choking_spots[target_pin]);
 
     //We normally route high fanout nets by only adding spatially close-by routing to the heap (reduces run-time).
     //However, if the current sink is 'critical' from a timing perspective, we put the entire route tree back onto

vpr/src/route/route_utils.cpp

@@ -391,15 +391,15 @@ vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> set_net
                                                                                                                   std::vector<std::vector<int>>>& net_terminal_groups,
                                                                                                 const vtr::vector<ParentNetId,
                                                                                                                   std::vector<int>>& net_terminal_group_num,
-                                                                                                bool has_choking_spot,
+                                                                                                bool router_opt_choke_points,
                                                                                                 bool is_flat) {
     vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> choking_spots(net_list.nets().size());
     for (const auto& net_id : net_list.nets()) {
         choking_spots[net_id].resize(net_list.net_pins(net_id).size());
     }
 
     // Return if the architecture doesn't have any potential choke points
-    if (!has_choking_spot) {
+    if (!router_opt_choke_points) {
         return choking_spots;
     }
 

vpr/src/route/route_utils.h

@@ -121,22 +121,22 @@ void print_router_criticality_histogram(const Netlist<>& net_list,
 void prune_unused_non_configurable_nets(CBRR& connections_inf,
                                         const Netlist<>& net_list);
 
-/** If flat_routing and has_choking_spot are true, there are some choke points inside the cluster which would increase the convergence time of routing.
+/** 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
  * for each choke point.
  * @param net_list
  * @param net_terminal_groups [Net_id][group_id] -> rr_node_id of the pins in the group
  * @param net_terminal_group_num [Net_id][pin_id] -> group_id
- * @param has_choking_spot is true if the given architecture has choking spots inside the cluster
+ * @param router_opt_choke_points is true if the given architecture has choking spots inside the cluster
  * @param is_flat is true if flat_routing is enabled
  * @return [Net_id][pin_id] -> [choke_point_rr_node_id, number of sinks reachable by this choke point] */
 vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> set_nets_choking_spots(const Netlist<>& net_list,
                                                                                                 const vtr::vector<ParentNetId,
                                                                                                                   std::vector<std::vector<int>>>& net_terminal_groups,
                                                                                                 const vtr::vector<ParentNetId,
                                                                                                                   std::vector<int>>& net_terminal_group_num,
-                                                                                                bool has_choking_spot,
+                                                                                                bool router_opt_choke_points,
                                                                                                 bool is_flat);
 
 /** Wrapper for create_rr_graph() with extra checks */

vpr/src/route/router_stats.h

@@ -9,11 +9,11 @@
 struct ConnectionParameters {
     ConnectionParameters(ParentNetId net_id,
                          int target_pin_num,
-                         bool has_choking_spot,
+                         bool router_opt_choke_points,
                          const std::unordered_map<RRNodeId, int>& connection_choking_spots)
         : net_id_(net_id)
         , target_pin_num_(target_pin_num)
-        , has_choking_spot_(has_choking_spot)
+        , router_opt_choke_points_(router_opt_choke_points)
         , connection_choking_spots_(connection_choking_spots) {}
 
     // Net id of the connection
@@ -24,7 +24,7 @@ struct ConnectionParameters {
     // Show whether for the given connection, router should expect a choking point
     // If this is true, it would increase the routing time since the router has to
     // take some measures to solve the congestion
-    bool has_choking_spot_;
+    bool router_opt_choke_points_;
 
     const std::unordered_map<RRNodeId, int>& connection_choking_spots_;
 };