Build PartitionTree incrementally, tune net-decomposing router

Author: duck2

vpr/src/route/DecompNetlistRouter.h

@@ -57,6 +57,7 @@ class DecompNetlistRouter : public NetlistRouter {
      * \ref route_net for each net, which will handle other global updates.
      * \return RouteIterResults for this iteration. */
     RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack);
+    void handle_bb_updated_nets(const std::vector<ParentNetId>& nets);
     /** Set RCV enable flag for all routers managed by this netlist router.
      * Net decomposition does not work with RCV, so calling this fn with x=true is a fatal error. */
     void set_rcv_enabled(bool x);
@@ -68,7 +69,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);
@@ -115,6 +116,9 @@ class DecompNetlistRouter : public NetlistRouter {
     float _pres_fac;
     float _worst_neg_slack;
 
+    /** The partition tree */
+    vtr::optional<PartitionTree> _tree;
+
     /** Sinks to be always sampled for decomposition for each net: [0.._net_list.size()-1]
      * (i.e. when routing fails after decomposition for a sink, sample it on next iteration) */
     vtr::vector<ParentNetId, vtr::dynamic_bitset<>> _net_known_samples;

vpr/src/route/DecompNetlistRouter.tpp

@@ -3,6 +3,7 @@
 /** @file Impls for DecompNetlistRouter */
 
 #include "DecompNetlistRouter.h"
+#include "globals.h"
 #include "netlist_routers.h"
 #include "route_net.h"
 #include "sink_sampling.h"
@@ -21,25 +22,43 @@ inline RouteIterResults DecompNetlistRouter<HeapType>::route_netlist(int itry, f
     _pres_fac = pres_fac;
     _worst_neg_slack = worst_neg_slack;
 
+    vtr::Timer t;
+
     /* Organize netlist into a PartitionTree.
      * Nets in a given level of nodes are guaranteed to not have any overlapping bounding boxes, so they can be routed in parallel. */
-    PartitionTree tree(_net_list);
+    if(!_tree){
+        _tree = PartitionTree(_net_list);
+        PartitionTreeDebug::log("Iteration " + std::to_string(itry) + ": built partition tree in " + std::to_string(t.elapsed_sec()) + " s");
+    }
+
+    /* Remove all virtual nets: we will create them for each iteration */
+    _tree->clear_vnets();
 
     /* Put the root node on the task queue, which will add its child nodes when it's finished. Wait until the entire tree gets routed. */
     tbb::task_group g;
-    route_partition_tree_node(g, tree.root());
+    route_partition_tree_node(g, _tree->root());
     g.wait();
+    PartitionTreeDebug::log("Routing all nets took " + std::to_string(t.elapsed_sec()) + " s");
 
     /* Combine results from threads */
     RouteIterResults out;
     for (auto& results : _results_th) {
         out.stats.combine(results.stats);
         out.rerouted_nets.insert(out.rerouted_nets.end(), results.rerouted_nets.begin(), results.rerouted_nets.end());
+        out.bb_updated_nets.insert(out.bb_updated_nets.end(), results.bb_updated_nets.begin(), results.bb_updated_nets.end());
         out.is_routable &= results.is_routable;
     }
+
     return out;
 }
 
+/* TODO: Handle this in route_netlist */
+template<typename HeapType>
+void DecompNetlistRouter<HeapType>::handle_bb_updated_nets(const std::vector<ParentNetId>& nets) {
+    VTR_ASSERT(_tree);
+    _tree->update_nets(nets);
+}
+
 template<typename HeapType>
 void DecompNetlistRouter<HeapType>::set_rcv_enabled(bool x) {
     if (x)
@@ -120,6 +139,9 @@ inline bool should_decompose_vnet(const VirtualNet& vnet, const PartitionTreeNod
 template<typename HeapType>
 void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
+    vtr::Timer t;
+
+    std::vector<ParentNetId> nets(node.nets.begin(), node.nets.end());
 
     /* Sort so that nets with the most sinks are routed first.
      * We want to interleave virtual nets with regular ones, so sort an "index vector"
@@ -129,15 +151,14 @@ void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g
     std::vector<size_t> order(node.nets.size() + node.vnets.size());
     std::iota(order.begin(), order.end(), 0);
     std::stable_sort(order.begin(), order.end(), [&](size_t i, size_t j) -> bool {
-        ParentNetId id1 = i < node.nets.size() ? node.nets[i] : node.vnets[i - node.nets.size()].net_id;
-        ParentNetId id2 = j < node.nets.size() ? node.nets[j] : node.vnets[j - node.nets.size()].net_id;
+        ParentNetId id1 = i < node.nets.size() ? nets[i] : node.vnets[i - nets.size()].net_id;
+        ParentNetId id2 = j < node.nets.size() ? nets[j] : node.vnets[j - nets.size()].net_id;
         return _net_list.net_sinks(id1).size() > _net_list.net_sinks(id2).size();
     });
 
-    vtr::Timer t;
     for (size_t i : order) {
-        if (i < node.nets.size()) { /* Regular net (not decomposed) */
-            ParentNetId net_id = node.nets[i];
+        if (i < nets.size()) { /* Regular net (not decomposed) */
+            ParentNetId net_id = nets[i];
             if (!should_route_net(_net_list, net_id, _connections_inf, _budgeting_inf, _worst_neg_slack, true))
                 continue;
             /* Setup the net (reset or prune) only once here in the flow. Then all calls to route_net turn off auto-setup */
@@ -188,6 +209,7 @@ void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g
             if (flags.retry_with_full_bb) {
                 /* ConnectionRouter thinks we should grow the BB. Do that and leave this net unrouted for now */
                 route_ctx.route_bb[net_id] = full_device_bb();
+                _results_th.local().bb_updated_nets.push_back(net_id);
                 /* Disable decomposition for nets like this: they're already problematic */
                 _is_decomp_disabled[net_id] = true;
                 continue;
@@ -206,7 +228,7 @@ void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g
                     continue;
                 }
             }
-            /* Route the full vnet. Again we don't care about the flags, they should be handled by the regular path */
+            /* Route the full vnet. We don't care about the flags, they should be handled by the regular path */
             auto sink_mask = get_vnet_sink_mask(vnet);
             route_net(
                 _routers_th.local(),
@@ -277,7 +299,7 @@ inline void make_vnet_pair(ParentNetId net_id, const t_bb& bb, Axis cutline_axis
 
 template<typename HeapType>
 bool DecompNetlistRouter<HeapType>::decompose_and_route_net(ParentNetId net_id, const PartitionTreeNode& node, VirtualNet& left, VirtualNet& right) {
-    auto& route_ctx = g_vpr_ctx.routing();
+    auto& route_ctx = g_vpr_ctx.mutable_routing();
     auto& net_bb = route_ctx.route_bb[net_id];
 
     /* Sample enough sinks to provide branch-off points to the virtual nets we create */
@@ -382,7 +404,7 @@ 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);
+    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(
@@ -499,6 +521,7 @@ inline bool get_reduction_mask(ParentNetId net_id, Axis cutline_axis, int cutlin
 template<typename HeapType>
 vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_decomposition_mask(ParentNetId net_id, const PartitionTreeNode& node) {
     const auto& route_ctx = g_vpr_ctx.routing();
+
     const RouteTree& tree = route_ctx.route_trees[net_id].value();
     size_t num_sinks = tree.num_sinks();
 
@@ -512,6 +535,7 @@ vtr::dynamic_bitset<> DecompNetlistRouter<HeapType>::get_decomposition_mask(Pare
     bool is_reduced = get_reduction_mask(net_id, 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)
         convex_hull_downsample(net_id, route_ctx.route_bb[net_id], out);
 
@@ -638,7 +662,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();
@@ -650,10 +674,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) {
@@ -666,9 +691,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/ParallelNetlistRouter.h

@@ -10,6 +10,7 @@
  *
  * [0]: F. Koşar, "A net-decomposing parallel FPGA router", MS thesis, UofT ECE, 2023 */
 #include "netlist_routers.h"
+#include "vtr_optional.h"
 
 #include <tbb/task_group.h>
 
@@ -52,6 +53,7 @@ class ParallelNetlistRouter : public NetlistRouter {
      * \ref route_net for each net, which will handle other global updates.
      * \return RouteIterResults for this iteration. */
     RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack);
+    void handle_bb_updated_nets(const std::vector<ParentNetId>& nets);
     void set_rcv_enabled(bool x);
     void set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info);
 
@@ -95,6 +97,9 @@ class ParallelNetlistRouter : public NetlistRouter {
     int _itry;
     float _pres_fac;
     float _worst_neg_slack;
+
+    /** The partition tree */
+    vtr::optional<PartitionTree> _tree;
 };
 
 #include "ParallelNetlistRouter.tpp"

vpr/src/route/ParallelNetlistRouter.tpp

@@ -2,6 +2,7 @@
 
 /** @file Impls for ParallelNetlistRouter */
 
+#include <string>
 #include "netlist_routers.h"
 #include "route_net.h"
 #include "vtr_time.h"
@@ -20,18 +21,24 @@ inline RouteIterResults ParallelNetlistRouter<HeapType>::route_netlist(int itry,
 
     /* Organize netlist into a PartitionTree.
      * Nets in a given level of nodes are guaranteed to not have any overlapping bounding boxes, so they can be routed in parallel. */
-    PartitionTree tree(_net_list);
+    vtr::Timer t;
+    if(!_tree){
+        _tree = PartitionTree(_net_list);
+        PartitionTreeDebug::log("Iteration " + std::to_string(itry) + ": built partition tree in " + std::to_string(t.elapsed_sec()) + " s");
+    }
 
     /* Put the root node on the task queue, which will add its child nodes when it's finished. Wait until the entire tree gets routed. */
     tbb::task_group g;
-    route_partition_tree_node(g, tree.root());
+    route_partition_tree_node(g, _tree->root());
     g.wait();
+    PartitionTreeDebug::log("Routing all nets took " + std::to_string(t.elapsed_sec()) + " s");
 
     /* Combine results from threads */
     RouteIterResults out;
     for (auto& results : _results_th) {
         out.stats.combine(results.stats);
         out.rerouted_nets.insert(out.rerouted_nets.end(), results.rerouted_nets.begin(), results.rerouted_nets.end());
+        out.bb_updated_nets.insert(out.bb_updated_nets.end(), results.bb_updated_nets.begin(), results.bb_updated_nets.end());
         out.is_routable &= results.is_routable;
     }
     return out;
@@ -41,13 +48,15 @@ template<typename HeapType>
 void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
 
+    std::vector<ParentNetId> nets(node.nets.begin(), node.nets.end());
+
     /* Sort so net with most sinks is routed first. */
-    std::stable_sort(node.nets.begin(), node.nets.end(), [&](ParentNetId id1, ParentNetId id2) -> bool {
+    std::stable_sort(nets.begin(), nets.end(), [&](ParentNetId id1, ParentNetId id2) -> bool {
         return _net_list.net_sinks(id1).size() > _net_list.net_sinks(id2).size();
     });
 
     vtr::Timer t;
-    for (auto net_id : node.nets) {
+    for (auto net_id : nets) {
         auto flags = route_net(
             _routers_th.local(),
             _net_list,
@@ -76,13 +85,18 @@ void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group&
         if (flags.retry_with_full_bb) {
             /* ConnectionRouter thinks we should grow the BB. Do that and leave this net unrouted for now */
             route_ctx.route_bb[net_id] = full_device_bb();
+            _results_th.local().bb_updated_nets.push_back(net_id);
             continue;
         }
         if (flags.was_rerouted) {
             _results_th.local().rerouted_nets.push_back(net_id);
         }
     }
-    PartitionTreeDebug::log("Node with " + std::to_string(node.nets.size()) + " nets routed in " + std::to_string(t.elapsed_sec()) + " s");
+
+    PartitionTreeDebug::log("Node with " + std::to_string(node.nets.size())
+                            + " nets and " + std::to_string(node.vnets.size())
+                            + " virtual nets routed in " + std::to_string(t.elapsed_sec())
+                            + " s");
 
     /* This node is finished: add left & right branches to the task queue */
     if (node.left && node.right) {
@@ -97,6 +111,13 @@ void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group&
     }
 }
 
+/* TODO: Handle this in route_netlist */
+template<typename HeapType>
+void ParallelNetlistRouter<HeapType>::handle_bb_updated_nets(const std::vector<ParentNetId>& nets) {
+    VTR_ASSERT(_tree);
+    _tree->update_nets(nets);
+}
+
 template<typename HeapType>
 void ParallelNetlistRouter<HeapType>::set_rcv_enabled(bool x) {
     for (auto& router : _routers_th) {

vpr/src/route/SerialNetlistRouter.h

@@ -35,6 +35,7 @@ class SerialNetlistRouter : public NetlistRouter {
     ~SerialNetlistRouter() {}
 
     RouteIterResults route_netlist(int itry, float pres_fac, float worst_neg_slack);
+    void handle_bb_updated_nets(const std::vector<ParentNetId>& nets);
     void set_rcv_enabled(bool x);
     void set_timing_info(std::shared_ptr<SetupHoldTimingInfo> timing_info);
 

vpr/src/route/SerialNetlistRouter.tpp

@@ -4,12 +4,15 @@
 
 #include "SerialNetlistRouter.h"
 #include "route_net.h"
+#include "vtr_time.h"
 
 template<typename HeapType>
 inline RouteIterResults SerialNetlistRouter<HeapType>::route_netlist(int itry, float pres_fac, float worst_neg_slack) {
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     RouteIterResults out;
 
+    vtr::Timer t;
+
     /* Sort so net with most sinks is routed first */
     auto sorted_nets = std::vector<ParentNetId>(_net_list.nets().begin(), _net_list.nets().end());
     std::stable_sort(sorted_nets.begin(), sorted_nets.end(), [&](ParentNetId id1, ParentNetId id2) -> bool {
@@ -45,7 +48,7 @@ inline RouteIterResults SerialNetlistRouter<HeapType>::route_netlist(int itry, f
         }
 
         if (flags.retry_with_full_bb) {
-            /* Grow the BB and retry this net right away. */
+            /* Grow the BB and retry this net right away. We don't populate out.bb_updated_nets */
             route_ctx.route_bb[net_id] = full_device_bb();
             inet--;
             continue;
@@ -59,9 +62,15 @@ inline RouteIterResults SerialNetlistRouter<HeapType>::route_netlist(int itry, f
         }
     }
 
+    PartitionTreeDebug::log("Routing all nets took " + std::to_string(t.elapsed_sec()) + " s");
     return out;
 }
 
+/* TODO: Handle this in route_netlist */
+template<typename HeapType>
+void SerialNetlistRouter<HeapType>::handle_bb_updated_nets(const std::vector<ParentNetId>& /* nets */) {
+}
+
 template<typename HeapType>
 void SerialNetlistRouter<HeapType>::set_rcv_enabled(bool x) {
     _router.set_rcv_enabled(x);