paper version

Author: duck2

vpr/src/route/DecompNetlistRouter.h

@@ -59,6 +59,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);
@@ -118,6 +119,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,15 +22,21 @@ 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");
+    }
 
-    vtr::Timer t;
+    /* 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");
 
@@ -38,12 +45,20 @@ inline RouteIterResults DecompNetlistRouter<HeapType>::route_netlist(int itry, f
     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)
@@ -124,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"
@@ -133,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::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 */
@@ -194,6 +211,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;
@@ -212,7 +230,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(),
@@ -284,7 +302,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 */
@@ -508,6 +526,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();
 
@@ -521,6 +540,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);
 

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::sort(node.nets.begin(), node.nets.end(), [&](ParentNetId id1, ParentNetId id2) -> bool {
+    std::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,
@@ -77,13 +86,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) {
@@ -98,6 +112,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::sort(sorted_nets.begin(), sorted_nets.end(), [&](ParentNetId id1, ParentNetId id2) -> bool {
@@ -46,7 +49,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;
@@ -60,9 +63,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);