prune initial RTs again

Author: duck2

vpr/src/route/DecompNetlistRouter.h

@@ -70,7 +70,7 @@ class DecompNetlistRouter : public NetlistRouter {
     /** Get a bitset with sinks to route before net decomposition */
     vtr::dynamic_bitset<> get_decomposition_mask(ParentNetId net_id, const PartitionTreeNode& node);
     /** Get a bitset with sinks to route before virtual net decomposition */
-    vtr::dynamic_bitset<> get_vnet_decomposition_mask(const VirtualNet& vnet, const PartitionTreeNode& node);
+    vtr::dynamic_bitset<> get_decomposition_mask_vnet(const VirtualNet& vnet, const PartitionTreeNode& node);
     /** Decompose and route a regular net. Output the resulting vnets to \p left and \p right.
      * \return Success status: true if routing is successful and left and right now contain valid virtual nets: false otherwise. */
     bool decompose_and_route_net(ParentNetId net_id, const PartitionTreeNode& node, VirtualNet& left, VirtualNet& right);

vpr/src/route/DecompNetlistRouter.tpp

@@ -389,8 +389,8 @@ inline std::string describe_vnet(const VirtualNet& vnet) {
 
 template<typename HeapType>
 bool DecompNetlistRouter<HeapType>::decompose_and_route_vnet(VirtualNet& vnet, const PartitionTreeNode& node, VirtualNet& left, VirtualNet& right) {
-    /* Sample enough sinks to provide branch-off points to the virtual nets we create */
-    auto sink_mask = get_vnet_decomposition_mask(vnet, node);
+        /* Sample enough sinks to provide branch-off points to the virtual nets we create */
+    auto sink_mask = get_decomposition_mask_vnet(vnet, node);
 
     /* Route the *parent* net with the given mask: only the sinks we ask for will be routed */
     auto flags = route_net(
@@ -647,7 +647,7 @@ inline bool get_reduction_mask_vnet_with_source(const VirtualNet& vnet, Axis cut
 }
 
 template<typename HeapType>
-vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_vnet_decomposition_mask(const VirtualNet& vnet, const PartitionTreeNode& node) {
+vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_decomposition_mask_vnet(const VirtualNet& vnet, const PartitionTreeNode& node) {
     const auto& route_ctx = g_vpr_ctx.routing();
     const RouteTree& tree = route_ctx.route_trees[vnet.net_id].value();
     int num_sinks = tree.num_sinks();
@@ -659,10 +659,11 @@ vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_vnet_decomposition_mask
      * sinks in the small side and unblock. Add convex hull since we are in a vnet which
      * may not have a source at all */
     if (inside_bb(tree.root().inode, vnet.clipped_bb)) { /* We have source, no need to sample after reduction in most cases */
-        bool is_reduced = get_reduction_mask_vnet_with_source(vnet, node.cutline_axis, node.cutline_pos, out);
+                bool is_reduced = get_reduction_mask_vnet_with_source(vnet, node.cutline_axis, node.cutline_pos, out);
         bool source_on_cutline = is_close_to_cutline(tree.root().inode, node.cutline_axis, node.cutline_pos, 1);
-        if (!is_reduced || source_on_cutline)
+        if (!is_reduced || source_on_cutline){
             convex_hull_downsample(vnet.net_id, vnet.clipped_bb, out);
+        }    
     } else {
         int reduced_sides = get_reduction_mask_vnet_no_source(vnet, node.cutline_axis, node.cutline_pos, out);
         if (reduced_sides < 2) {
@@ -675,9 +676,11 @@ vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_vnet_decomposition_mask
     /* Sample if a sink is too close to the cutline (and unreached).
      * Those sinks are likely to fail routing */
     for (size_t isink : isinks) {
+        RRNodeId rr_sink = route_ctx.net_rr_terminals[vnet.net_id][isink];
+        if (!inside_bb(rr_sink, vnet.clipped_bb))
+            continue;
         if (is_isink_reached.get(isink))
             continue;
-        RRNodeId rr_sink = route_ctx.net_rr_terminals[vnet.net_id][isink];
         if (is_close_to_cutline(rr_sink, node.cutline_axis, node.cutline_pos, 1)) {
             out.set(isink, true);
             continue;

vpr/src/route/connection_router.cpp

@@ -1,4 +1,5 @@
 #include "connection_router.h"
+#include "route_common.h"
 #include "rr_graph.h"
 
 #include "binary_heap.h"
@@ -900,6 +901,9 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
     float backward_path_cost = cost_params.criticality * rt_node.Tdel;
     float R_upstream = rt_node.R_upstream;
 
+    if(!inside_bb(inode, net_bb))
+        return;
+
     // after budgets are loaded, calculate delay cost as described by RCV paper
     /* R. Fung, V. Betz and W. Chow, "Slack Allocation and Routing to Improve FPGA Timing While
      * Repairing Short-Path Violations," in IEEE Transactions on Computer-Aided Design of
@@ -1012,6 +1016,9 @@ t_bb ConnectionRouter<Heap>::add_high_fanout_route_tree_to_heap(
                     continue;
                 RRNodeId rr_node_to_add = rt_node.inode;
 
+                if(!inside_bb(rr_node_to_add, net_bounding_box))
+                    continue;
+
                 if (is_flat_) {
                     if (!relevant_node_to_target(rr_graph_, rr_node_to_add, target_node))
                         continue;
@@ -1028,16 +1035,14 @@ t_bb ConnectionRouter<Heap>::add_high_fanout_route_tree_to_heap(
 
                 /* In case of the parallel router, we may be dealing with a virtual net.
                  * Still push nodes outside the BB to the heap, but don't count them towards nodes_added */
-                if(inside_bb(rr_node_to_add, net_bounding_box)){
-                    if (is_flat_) {
-                        if (rr_graph_->node_type(rr_node_to_add) == CHANY || rr_graph_->node_type(rr_node_to_add) == CHANX) {
-                            chan_nodes_added++;
-                        }
-                    } else {
+                if (is_flat_) {
+                    if (rr_graph_->node_type(rr_node_to_add) == CHANY || rr_graph_->node_type(rr_node_to_add) == CHANX) {
                         chan_nodes_added++;
                     }
-                    nodes_added++;
+                } else {
+                    chan_nodes_added++;
                 }
+                nodes_added++;
             }
 
             constexpr int SINGLE_BIN_MIN_NODES = 2;

vpr/src/route/route_common.cpp

@@ -3,11 +3,14 @@
 #include "atom_netlist_utils.h"
 #include "connection_router_interface.h"
 #include "draw_global.h"
+#include "globals.h"
 #include "place_and_route.h"
 #include "route_common.h"
 #include "route_export.h"
 #include "rr_graph.h"
 
+#include "partition_tree.h"
+
 /*  The numbering relation between the channels and clbs is:				*
  *																	        *
  *  |    IO     | chan_   |   CLB     | chan_   |   CLB     |               *
@@ -237,9 +240,9 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
 
 /** Update pathfinder cost of all nodes rooted at rt_node, including rt_node itself */
 void pathfinder_update_cost_from_route_tree(const RouteTreeNode& root, int add_or_sub) {
-    pathfinder_update_single_node_occupancy(root.inode, add_or_sub);
+        pathfinder_update_single_node_occupancy(root.inode, add_or_sub);
     for (auto& node : root.all_nodes()) {
-        pathfinder_update_single_node_occupancy(node.inode, add_or_sub);
+                pathfinder_update_single_node_occupancy(node.inode, add_or_sub);
     }
 }
 

vpr/src/route/route_common.h

@@ -4,8 +4,6 @@
  * router files and some used globally. */
 
 #include <vector>
-#include "clustered_netlist.h"
-#include "rr_node_fwd.h"
 #include "router_stats.h"
 #include "globals.h"
 

vpr/src/route/sink_sampling.h

@@ -149,16 +149,23 @@ inline void convex_hull_downsample(ParentNetId net_id, const t_bb& net_bb, vtr::
         RRNodeId rr_sink = route_ctx.net_rr_terminals[net_id][i];
         if (!inside_bb(rr_sink, net_bb))
             continue;
-        SinkPoint point{rr_graph.node_xlow(rr_sink), rr_graph.node_ylow(rr_sink), int(i)};
+        Direction dir = rr_graph.node_direction(rr_sink);
+        int x = dir == Direction::DEC ? rr_graph.node_xhigh(rr_sink) : rr_graph.node_xlow(rr_sink);
+        int y = dir == Direction::DEC ? rr_graph.node_yhigh(rr_sink) : rr_graph.node_ylow(rr_sink);
+        SinkPoint point{x, y, int(i)};
         sink_points.push_back(point);
     }
 
     auto hull = sink_sampling::quickhull(sink_points);
 
+    auto& is_isink_reached = tree.get_is_isink_reached();
+
     /* Sample if not source */
     for (auto& point : hull) {
         if (point.isink == 0) /* source */
             continue;
+        if(is_isink_reached.get(point.isink))
+            continue;
         out.set(point.isink, true);
     }
 }