fix the non-configurable node case

Author: duck2

vpr/src/route/route_timing.cpp

@@ -1516,7 +1516,7 @@ static void setup_routing_resources(int itry,
         vtr::optional<RouteTreeRoot&> rt_root_pruned = prune_route_tree(rt_root2, connections_inf);
 
         // Subtract congestion using the non-pruned original
-        pathfinder_update_cost_from_route_tree(route_ctx.rt_roots[net_id].value(), -1);
+        pathfinder_update_cost_from_route_tree(rt_root.value(), -1);
 
         if (rt_root_pruned) { //Partially pruned
             profiling::route_tree_preserved();
@@ -2094,10 +2094,10 @@ static bool is_better_quality_routing(const vtr::vector<ParentNetId, vtr::option
                                       const WirelengthInfo& wirelength_info,
                                       std::shared_ptr<const SetupHoldTimingInfo> timing_info) {
     if (best_routing.empty()) {
-        return true; //First legal routing
+        return true;  // First legal routing
     }
 
-    //Rank first based on sWNS, followed by other timing metrics
+    // Rank first based on sWNS, followed by other timing metrics
     if (timing_info) {
         if (timing_info->setup_worst_negative_slack() > best_routing_metrics.sWNS) {
             return true;
@@ -2124,31 +2124,31 @@ static bool is_better_quality_routing(const vtr::vector<ParentNetId, vtr::option
         }
     }
 
-    //Finally, wirelength tie breaker
+    // Finally, wirelength tie breaker
     return wirelength_info.used_wirelength() < best_routing_metrics.used_wirelength;
 }
 
 static bool early_reconvergence_exit_heuristic(const t_router_opts& router_opts,
                                                int itry_since_last_convergence,
                                                std::shared_ptr<const SetupHoldTimingInfo> timing_info,
                                                const RoutingMetrics& best_routing_metrics) {
-    //Give-up on reconvergent routing if the CPD improvement after the
-    //first iteration since convergence is small, compared to the best
-    //CPD seen so far
+    // Give-up on reconvergent routing if the CPD improvement after the
+    // first iteration since convergence is small, compared to the best
+    // CPD seen so far
     if (itry_since_last_convergence == 1) {
         float cpd_ratio = timing_info->setup_worst_negative_slack() / best_routing_metrics.sWNS;
 
-        //Give up if we see less than a 1% CPD improvement,
-        //after reducing pres_fac. Typically larger initial
-        //improvements are needed to see an actual improvement
-        //in final legal routing quality.
+        // Give up if we see less than a 1% CPD improvement,
+        // after reducing pres_fac. Typically larger initial
+        // improvements are needed to see an actual improvement
+        // in final legal routing quality.
         if (cpd_ratio >= router_opts.reconvergence_cpd_threshold) {
             VTR_LOG("Giving up routing since additional routing convergences seem unlikely to improve quality (CPD ratio: %g)\n", cpd_ratio);
-            return true; //Potential CPD improvement is small, don't spend run-time trying to improve it
+            return true;  // Potential CPD improvement is small, don't spend run-time trying to improve it
         }
     }
 
-    return false; //Don't give up
+    return false;  // Don't give up
 }
 
 static void generate_route_timing_reports(const t_router_opts& router_opts,
@@ -2168,8 +2168,8 @@ static void generate_route_timing_reports(const t_router_opts& router_opts,
 }
 
 // If a route is ripped up during routing, non-configurable sets are left
-// behind.  As a result, the final routing may have stubs at
-// non-configurable sets.  This function tracks non-configurable set usage,
+// behind. As a result, the final routing may have stubs at
+// non-configurable sets. This function tracks non-configurable set usage,
 // and if the sets are unused, prunes them.
 static void prune_unused_non_configurable_nets(CBRR& connections_inf,
                                                const Netlist<>& net_list,
@@ -2183,28 +2183,26 @@ static void prune_unused_non_configurable_nets(CBRR& connections_inf,
             continue;
         RouteTreeRoot& rt_root = route_ctx.rt_roots[net_id].value();
 
+
         connections_inf.prepare_routing_for_net(net_id);
         connections_inf.clear_force_reroute_for_net();
 
-        std::fill(non_config_node_set_usage.begin(), non_config_node_set_usage.end(), 0);
-
-        // check for edge correctness
-        VTR_ASSERT_SAFE(is_valid_skeleton_tree(rt_root));
+        std::vector<int> usage = get_non_config_node_set_usage(rt_root);
 
-        //Prune the branches of the tree that don't legally lead to sinks
-        prune_route_tree(rt_root, connections_inf, &non_config_node_set_usage);
+        // Prune the branches of the tree that don't legally lead to sinks
+        prune_route_tree(rt_root, connections_inf, &usage);
     }
 }
 
-//Initializes net_delay based on best-case delay estimates from the router lookahead
+// Initializes net_delay based on best-case delay estimates from the router lookahead
 static void init_net_delay_from_lookahead(const RouterLookahead& router_lookahead,
                                           const Netlist<>& net_list,
                                           const vtr::vector<ParentNetId, std::vector<int>>& net_rr_terminals,
                                           NetPinsMatrix<float>& net_delay,
                                           const RRGraphView& rr_graph,
                                           bool is_flat) {
     t_conn_cost_params cost_params;
-    cost_params.criticality = 1.; //Ensures lookahead returns delay value
+    cost_params.criticality = 1.;  // Ensures lookahead returns delay value
 
     for (auto net_id : net_list.nets()) {
         if (net_list.net_is_ignored(net_id)) continue;
@@ -2354,8 +2352,8 @@ vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>> set_net
 }
 
 #ifndef NO_GRAPHICS
-//updates router iteration information and checks for router iteration and net id breakpoints
-//stops after the specified router iteration or net id is encountered
+// updates router iteration information and checks for router iteration and net id breakpoints
+// stops after the specified router iteration or net id is encountered
 void update_router_info_and_check_bp(bp_router_type type, int net_id) {
     t_draw_state* draw_state = get_draw_state_vars();
     if (draw_state->list_of_breakpoints.size() != 0) {

vpr/src/route/route_tree_timing.cpp

@@ -3,6 +3,7 @@
 #include <vector>
 
 #include "rr_graph_fwd.h"
+#include "rr_node_types.h"
 #include "vtr_assert.h"
 #include "vtr_log.h"
 #include "vtr_memory.h"
@@ -116,10 +117,13 @@ update_route_tree(RouteTreeRoot& rt_root, t_heap* hptr, int target_net_pin_index
         update_route_tree_spatial_lookup_recur(start_of_new_subtree_rt_node.value(), *spatial_rt_lookup);
     }
 
-    /* if the new branch is the only child of its parent, this is the first time
-     * we are creating this tree, so include the parent in the new branch return */
-    if(start_of_new_subtree_rt_node.value().parent.value().child_nodes().size() == 1)
-        return {start_of_new_subtree_rt_node.value().parent.value(), sink_rt_node};
+    /* if the new branch is the only child of its parent and the parent is a SOURCE,
+     * it is the first time we are creating this tree, so include the parent in the new branch return
+     * so that it can be included in occupancy calculation.
+     * TODO: probably this should be cleaner */
+    RouteTreeNode& parent = start_of_new_subtree_rt_node.value().parent.value();
+    if(parent.child_nodes().size() == 1 && rr_graph.node_type(parent.inode) == SOURCE)
+        return {parent, sink_rt_node};
 
     return {start_of_new_subtree_rt_node.value(), sink_rt_node};
 }
@@ -182,6 +186,7 @@ add_subtree_to_route_tree(RouteTreeRoot& rt_root, t_heap* hptr, int target_net_p
      * ---
      * Walk through new_branch_iswitches and corresponding new_branch_inodes. */
     for (int i=new_branch_inodes.size()-1; i>=0; i--){
+        /* have to create a tmp_node because add_child copies the node --> reference changes */
         RouteTreeNode tmp_node(new_branch_inodes[i], new_branch_iswitches[i], *last_node_ptr, rt_root);
 
 		e_rr_type node_type = rr_graph.node_type(new_branch_inodes[i]);
@@ -202,9 +207,9 @@ add_subtree_to_route_tree(RouteTreeRoot& rt_root, t_heap* hptr, int target_net_p
         all_visited.insert(new_branch_inodes[i]);
     }
 
-    //Expand (recursively) each of the main-branch nodes adding any
-    //non-configurably connected nodes
-    //Sink is not included, so no need to pass in the node's ipin value.
+    // Expand (recursively) each of the main-branch nodes adding any
+    // non-configurably connected nodes
+    // Sink is not included, so no need to pass in the node's ipin value.
     for (RRNodeId rr_node : main_branch_visited) {
         add_non_configurable_to_route_tree(rr_node_to_rt_node.at(rr_node).value(), false, all_visited, is_flat);
     }
@@ -224,31 +229,34 @@ static void add_non_configurable_to_route_tree(RouteTreeNode& rt_node,
     if(visited.count(rt_node.inode) && reached_by_non_configurable_edge)
         return;
 
+    visited.insert(rt_node.inode);
+
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     VTR_ASSERT(rt_node.root);
     auto& rr_node_to_rt_node = rt_node.root.value().rr_node_to_rt_node;
     const RRNodeId rr_node = rt_node.inode;
 
-    for (int iedge : rr_graph.non_configurable_edges(RRNodeId(rr_node))) {
+    for (int iedge : rr_graph.non_configurable_edges(rr_node)) {
         // Recursive case: expand children
-        VTR_ASSERT(!rr_graph.edge_is_configurable(RRNodeId(rr_node), iedge));
-        RRNodeId to_rr_node = rr_graph.edge_sink_node(RRNodeId(rr_node), iedge);
-        visited.insert(to_rr_node);
+        VTR_ASSERT(!rr_graph.edge_is_configurable(rr_node, iedge));
+        RRNodeId to_rr_node = rr_graph.edge_sink_node(rr_node, iedge);
 
         if(rr_node_to_rt_node.count(to_rr_node))  // TODO: not 100% sure about this
             continue;
 
         RRSwitchId edge_switch = RRSwitchId(rr_graph.edge_switch(RRNodeId(to_rr_node), iedge));
-        RouteTreeNode new_node = RouteTreeNode(to_rr_node, edge_switch, rt_node, rt_node.root);
-        new_node.net_pin_index = OPEN;
+
+        /* have to create a tmp_node because add_child_front copies the node --> reference changes */
+        RouteTreeNode tmp_node = RouteTreeNode(to_rr_node, edge_switch, rt_node, rt_node.root);
+        tmp_node.net_pin_index = OPEN;
         if (rr_graph.node_type(RRNodeId(to_rr_node)) == IPIN && !is_flat) {
-            new_node.re_expand = false;
+            tmp_node.re_expand = false;
         } else {
-            new_node.re_expand = true;
+            tmp_node.re_expand = true;
         }
-        rt_node.add_child_front(new_node);
+        RouteTreeNode& new_node = rt_node.add_child_front(tmp_node);
 
         add_non_configurable_to_route_tree(new_node, true, visited, is_flat);
     }
@@ -438,7 +446,7 @@ void print_route_tree(const RouteTreeNode& rt_node, int depth) {
 
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
-    VTR_LOG("%srt_node: %d (%s) \t ipin: %d \t R: %g \t C: %g \t delay: %g",
+    VTR_LOG("%srt_node: %d (%s) \t ipin: %d \t R: %g \t C: %g \t delay: %g \t",
             indent.c_str(),
             rt_node.inode,
             rr_graph.node_type_string(RRNodeId(rt_node.inode)),
@@ -447,15 +455,16 @@ void print_route_tree(const RouteTreeNode& rt_node, int depth) {
             rt_node.C_downstream,
             rt_node.Tdel);
 
-    if (rt_node.parent_switch != RRSwitchId(OPEN)) {
-        bool parent_edge_configurable = rr_graph.rr_switch_inf(RRSwitchId(rt_node.parent_switch)).configurable();
+    if (rt_node.parent) {
+        VTR_LOG("parent: %d \t parent_switch: %d", rt_node.parent.value().inode, rt_node.parent_switch);
+        bool parent_edge_configurable = rr_graph.rr_switch_inf(rt_node.parent_switch).configurable();
         if (!parent_edge_configurable) {
             VTR_LOG("*");
         }
     }
 
     auto& route_ctx = g_vpr_ctx.routing();
-    if (route_ctx.rr_node_route_inf[size_t(rt_node.inode)].occ() > rr_graph.node_capacity(RRNodeId(rt_node.inode))) {
+    if (route_ctx.rr_node_route_inf[size_t(rt_node.inode)].occ() > rr_graph.node_capacity(rt_node.inode)) {
         VTR_LOG(" x");
     }
 
@@ -721,11 +730,11 @@ t_trace* traceback_from_route_tree(ParentNetId inet, const RouteTreeNode& root,
 static vtr::optional<RouteTreeNode&> prune_route_tree_recurr(RouteTreeNode& node, CBRR& connections_inf, bool force_prune, std::vector<int>* non_config_node_set_usage) {
     // Recursively traverse the route tree rooted at node and remove any congested
     // sub-trees
-
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.routing();
-    bool congested = (route_ctx.rr_node_route_inf[size_t(node.inode)].occ() > rr_graph.node_capacity(RRNodeId(node.inode)));
+    bool congested = (route_ctx.rr_node_route_inf[size_t(node.inode)].occ() > rr_graph.node_capacity(node.inode));
+
     int node_set = -1;
     auto itr = device_ctx.rr_node_to_non_config_node_set.find(size_t(node.inode));
     if (itr != device_ctx.rr_node_to_non_config_node_set.end()) {
@@ -756,7 +765,7 @@ static vtr::optional<RouteTreeNode&> prune_route_tree_recurr(RouteTreeNode& node
         }else{  // Pruned
             // After removing a child node, check if non_config_node_set_usage
             // needs an update.
-            if (non_config_node_set_usage != nullptr && node_set != -1 && rr_graph.rr_switch_inf(RRSwitchId(child.parent_switch)).configurable()) {
+            if (non_config_node_set_usage != nullptr && node_set != -1 && rr_graph.rr_switch_inf(child.parent_switch).configurable()) {
                 (*non_config_node_set_usage)[node_set] -= 1;
                 VTR_ASSERT((*non_config_node_set_usage)[node_set] >= 0);
             }
@@ -771,14 +780,14 @@ static vtr::optional<RouteTreeNode&> prune_route_tree_recurr(RouteTreeNode& node
             //Record sink as reachable
             connections_inf.reached_rt_sink(node.inode);
 
-            return node; //Not pruned
+            return node;  // Not pruned
         } else {
             VTR_ASSERT(force_prune);
 
             //Record as not reached
             connections_inf.toreach_rr_sink(node.net_pin_index);
 
-            return vtr::nullopt; //Pruned
+            return vtr::nullopt;  // Pruned
         }
     } else if (all_children_pruned) {
         //This node has no children
@@ -809,7 +818,7 @@ static vtr::optional<RouteTreeNode&> prune_route_tree_recurr(RouteTreeNode& node
 
         bool reached_non_configurably = false;
         if (node.parent) {
-            reached_non_configurably = !rr_graph.rr_switch_inf(RRSwitchId(node.parent_switch)).configurable();
+            reached_non_configurably = !rr_graph.rr_switch_inf(node.parent_switch).configurable();
 
             if (reached_non_configurably) {
                 // Check if this non-configurable node set is in use.
@@ -910,6 +919,48 @@ vtr::optional<RouteTreeRoot&> prune_route_tree(RouteTreeRoot& rt_root, CBRR& con
         return vtr::nullopt;
 }
 
+/* For each non-configurable node set, count the cases in the route tree where:
+ * 1. the node is a member of a nonconf set (duh)
+ * if not SINK:
+ *   2. and there *is* an outgoing edge (we are not at the end of a stub)
+ *   3. and that outgoing edge is a configurable switch
+ * if SINK:
+ *   2. and the incoming edge is a configurable switch
+ *     (Note: the old code's comments mention that a "non-configurable edge"
+ *      "to" a sink is a usage of the set, but the code used to check if the
+ *      edge "from" the SINK, which shouldn't exist, was "configurable". This
+ *      might be some faulty code carried over.) */
+std::vector<int> get_non_config_node_set_usage(const RouteTreeRoot& rt_root){
+    auto& device_ctx = g_vpr_ctx.device();
+    std::vector<int> usage(device_ctx.rr_non_config_node_sets.size(), 0);
+
+    const auto& rr_to_nonconf = device_ctx.rr_node_to_non_config_node_set;
+
+    for(auto& rt_node: rt_root){
+        auto it = rr_to_nonconf.find(size_t(rt_node.inode));
+        if (it == rr_to_nonconf.end())
+            continue;
+    
+        if(device_ctx.rr_graph.node_type(rt_node.inode) == SINK){
+            if(device_ctx.rr_graph.rr_switch_inf(rt_node.parent_switch).configurable()){
+                usage[it->second] += 1;
+            }
+            continue;
+        }
+
+        if(rt_node.child_nodes().empty())
+            continue;
+
+        for(auto &child: rt_node.child_nodes()){
+            if (device_ctx.rr_graph.rr_switch_inf(child.parent_switch).configurable()) {
+                usage[it->second] += 1;
+            }
+        }
+    }
+
+    return usage;
+}
+
 void pathfinder_update_cost_from_route_tree(const RouteTreeNode& rt_node, int add_or_sub) {
     /* Update pathfinder cost of all nodes rooted at rt_node, including rt_node itself */
     pathfinder_update_single_node_occupancy(size_t(rt_node.inode), add_or_sub);

vpr/src/route/route_tree_timing.h

@@ -57,6 +57,10 @@ vtr::optional<RouteTreeRoot&> prune_route_tree(RouteTreeRoot& rt_root, CBRR& con
 //  non_config_node_set_usage after pruning.
 vtr::optional<RouteTreeRoot&> prune_route_tree(RouteTreeRoot& rt_root, CBRR& connections_inf, std::vector<int>* non_config_node_set_usage);
 
+/* Count configurable edges to non-configurable node sets. (rr_nonconf_node_sets index -> int)
+ * Required when using prune_route_tree to prune non-configurable nodes. */
+std::vector<int> get_non_config_node_set_usage(const RouteTreeRoot& rt_root);
+
 /* Move to other pathfinder functions */
 void pathfinder_update_cost_from_route_tree(const RouteTreeNode& rt_root, int add_or_sub);