[Router] Upstream Fine-Grained Parallel Router (FPT'24)

Upstreamed the fine-grained parallel router implementation into the VTR
master. The original branch is https://github.com/verilog-to-routing/vtr-verilog-to-routing/tree/mq-parallel-router.

Modified the MultiQueue (SPAA'24) implementation and integrated it into
the VTR codebase.

Author: ueqri

utils/route_diag/src/main.cpp

@@ -97,7 +97,8 @@ static void do_one_route(const Netlist<>& net_list,
                                                   segment_inf,
                                                   is_flat);
 
-    ConnectionRouter<FourAryHeap> router(
+    // TODO: adding tests for parallel connection router
+    SerialConnectionRouter<FourAryHeap> router(
         device_ctx.grid,
         *router_lookahead,
             device_ctx.rr_graph.rr_nodes(),

vpr/src/base/SetupVPR.cpp

@@ -433,6 +433,12 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->astar_fac = Options.astar_fac;
     RouterOpts->astar_offset = Options.astar_offset;
     RouterOpts->router_profiler_astar_fac = Options.router_profiler_astar_fac;
+    RouterOpts->enable_parallel_connection_router = Options.enable_parallel_connection_router;
+    RouterOpts->post_target_prune_fac = Options.post_target_prune_fac;
+    RouterOpts->post_target_prune_offset = Options.post_target_prune_offset;
+    RouterOpts->multi_queue_num_threads = Options.multi_queue_num_threads;
+    RouterOpts->multi_queue_num_queues = Options.multi_queue_num_queues;
+    RouterOpts->multi_queue_direct_draining = Options.multi_queue_direct_draining;
     RouterOpts->bb_factor = Options.bb_factor;
     RouterOpts->criticality_exp = Options.criticality_exp;
     RouterOpts->max_criticality = Options.max_criticality;

vpr/src/base/ShowSetup.cpp

@@ -376,6 +376,12 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
         VTR_LOG("RouterOpts.astar_fac: %f\n", RouterOpts.astar_fac);
         VTR_LOG("RouterOpts.astar_offset: %f\n", RouterOpts.astar_offset);
         VTR_LOG("RouterOpts.router_profiler_astar_fac: %f\n", RouterOpts.router_profiler_astar_fac);
+        VTR_LOG("RouterOpts.enable_parallel_connection_router: %s\n", RouterOpts.enable_parallel_connection_router ? "true" : "false");
+        VTR_LOG("RouterOpts.post_target_prune_fac: %f\n", RouterOpts.post_target_prune_fac);
+        VTR_LOG("RouterOpts.post_target_prune_offset: %f\n", RouterOpts.post_target_prune_offset);
+        VTR_LOG("RouterOpts.multi_queue_num_threads: %d\n", RouterOpts.multi_queue_num_threads);
+        VTR_LOG("RouterOpts.multi_queue_num_queues: %d\n", RouterOpts.multi_queue_num_queues);
+        VTR_LOG("RouterOpts.multi_queue_direct_draining: %s\n", RouterOpts.multi_queue_direct_draining ? "true" : "false");
         VTR_LOG("RouterOpts.criticality_exp: %f\n", RouterOpts.criticality_exp);
         VTR_LOG("RouterOpts.max_criticality: %f\n", RouterOpts.max_criticality);
         VTR_LOG("RouterOpts.init_wirelength_abort_threshold: %f\n", RouterOpts.init_wirelength_abort_threshold);

vpr/src/base/read_options.cpp

@@ -2549,6 +2549,36 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("1.2")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument<bool, ParseOnOff>(args.enable_parallel_connection_router, "--enable_parallel_connection_router")
+        .help("TODO")
+        .default_value("off")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument(args.post_target_prune_fac, "--post_target_prune_fac")
+        .help("TODO")
+        .default_value("1.2")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument(args.post_target_prune_offset, "--post_target_prune_offset")
+        .help("TODO")
+        .default_value("0.0")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument<int>(args.multi_queue_num_threads, "--multi_queue_num_threads")
+        .help("TODO")
+        .default_value("1")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument<int>(args.multi_queue_num_queues, "--multi_queue_num_queues")
+        .help("TODO")
+        .default_value("2")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_timing_grp.add_argument<bool, ParseOnOff>(args.multi_queue_direct_draining, "--multi_queue_direct_draining")
+        .help("TODO")
+        .default_value("off")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     route_timing_grp.add_argument(args.max_criticality, "--max_criticality")
         .help(
             "Sets the maximum fraction of routing cost derived from delay (vs routability) for any net."

vpr/src/base/read_options.h

@@ -226,6 +226,12 @@ struct t_options {
     argparse::ArgValue<float> astar_fac;
     argparse::ArgValue<float> astar_offset;
     argparse::ArgValue<float> router_profiler_astar_fac;
+    argparse::ArgValue<bool> enable_parallel_connection_router;
+    argparse::ArgValue<float> post_target_prune_fac;
+    argparse::ArgValue<float> post_target_prune_offset;
+    argparse::ArgValue<int> multi_queue_num_threads;
+    argparse::ArgValue<int> multi_queue_num_queues;
+    argparse::ArgValue<bool> multi_queue_direct_draining;
     argparse::ArgValue<float> max_criticality;
     argparse::ArgValue<float> criticality_exp;
     argparse::ArgValue<float> router_init_wirelength_abort_threshold;

vpr/src/base/vpr_types.h

@@ -1191,6 +1191,12 @@ struct t_router_opts {
     float astar_fac;
     float astar_offset;
     float router_profiler_astar_fac;
+    bool enable_parallel_connection_router;
+    float post_target_prune_fac;
+    float post_target_prune_offset;
+    int multi_queue_num_threads;
+    int multi_queue_num_queues;
+    bool multi_queue_direct_draining;
     float max_criticality;
     float criticality_exp;
     float init_wirelength_abort_threshold;

vpr/src/route/DecompNetlistRouter.h

@@ -85,11 +85,11 @@ class DecompNetlistRouter : public NetlistRouter {
     /** A single task to route nets inside a PartitionTree node and add tasks for its child nodes to task group \p g. */
     void route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node);
 
-    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
+    SerialConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
         auto& device_ctx = g_vpr_ctx.device();
         auto& route_ctx = g_vpr_ctx.mutable_routing();
 
-        return ConnectionRouter<HeapType>(
+        return SerialConnectionRouter<HeapType>(
             device_ctx.grid,
             *router_lookahead,
             device_ctx.rr_graph.rr_nodes(),
@@ -101,8 +101,8 @@ class DecompNetlistRouter : public NetlistRouter {
     }
 
     /* Context fields. Most of them will be forwarded to route_net (see route_net.tpp) */
-    /** Per-thread storage for ConnectionRouters. */
-    tbb::enumerable_thread_specific<ConnectionRouter<HeapType>> _routers_th;
+    /** Per-thread storage for SerialConnectionRouter. */
+    tbb::enumerable_thread_specific<SerialConnectionRouter<HeapType>> _routers_th;
     const Netlist<>& _net_list;
     const t_router_opts& _router_opts;
     CBRR& _connections_inf;

vpr/src/route/DecompNetlistRouter.tpp

@@ -204,12 +204,12 @@ void DecompNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group& g
                 route_ctx.route_bb[net_id],
                 false);
             if (!flags.success && !flags.retry_with_full_bb) {
-                /* Disconnected RRG and ConnectionRouter doesn't think growing the BB will work */
+                /* Disconnected RRG and SerialConnectionRouter doesn't think growing the BB will work */
                 _results_th.local().is_routable = false;
                 return;
             }
             if (flags.retry_with_full_bb) {
-                /* ConnectionRouter thinks we should grow the BB. Do that and leave this net unrouted for now */
+                /*SerialConnectionRouter 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 */

vpr/src/route/ParallelNetlistRouter.h

@@ -15,7 +15,7 @@
 #include <tbb/task_group.h>
 
 /** Parallel impl for NetlistRouter.
- * Holds enough context members to glue together ConnectionRouter and net routing functions,
+ * Holds enough context members to glue together SerialConnectionRouter and net routing functions,
  * such as \ref route_net. Keeps the members in thread-local storage where needed,
  * i.e. ConnectionRouters and RouteIterResults-es.
  * See \ref route_net. */
@@ -62,11 +62,11 @@ class ParallelNetlistRouter : public NetlistRouter {
     /** A single task to route nets inside a PartitionTree node and add tasks for its child nodes to task group \p g. */
     void route_partition_tree_node(tbb::task_group& g, PartitionTreeNode& node);
 
-    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
+    SerialConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
         auto& device_ctx = g_vpr_ctx.device();
         auto& route_ctx = g_vpr_ctx.mutable_routing();
 
-        return ConnectionRouter<HeapType>(
+        return SerialConnectionRouter<HeapType>(
             device_ctx.grid,
             *router_lookahead,
             device_ctx.rr_graph.rr_nodes(),
@@ -79,7 +79,7 @@ class ParallelNetlistRouter : public NetlistRouter {
 
     /* Context fields. Most of them will be forwarded to route_net (see route_net.tpp) */
     /** Per-thread storage for ConnectionRouters. */
-    tbb::enumerable_thread_specific<ConnectionRouter<HeapType>> _routers_th;
+    tbb::enumerable_thread_specific<SerialConnectionRouter<HeapType>> _routers_th;
     const Netlist<>& _net_list;
     const t_router_opts& _router_opts;
     CBRR& _connections_inf;

vpr/src/route/ParallelNetlistRouter.tpp

@@ -79,12 +79,12 @@ void ParallelNetlistRouter<HeapType>::route_partition_tree_node(tbb::task_group&
             route_ctx.route_bb[net_id]);
 
         if (!flags.success && !flags.retry_with_full_bb) {
-            /* Disconnected RRG and ConnectionRouter doesn't think growing the BB will work */
+            /* Disconnected RRG and SerialConnectionRouter doesn't think growing the BB will work */
             _results_th.local().is_routable = false;
             return;
         }
         if (flags.retry_with_full_bb) {
-            /* ConnectionRouter thinks we should grow the BB. Do that and leave this net unrouted for now */
+            /* SerialConnectionRouter 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;

vpr/src/route/SerialNetlistRouter.h

@@ -3,6 +3,8 @@
 /** @file Serial case for \ref NetlistRouter: just loop through nets */
 
 #include "netlist_routers.h"
+#include "serial_connection_router.h"
+#include "parallel_connection_router.h"
 
 template<typename HeapType>
 class SerialNetlistRouter : public NetlistRouter {
@@ -20,7 +22,7 @@ class SerialNetlistRouter : public NetlistRouter {
         const RoutingPredictor& routing_predictor,
         const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
         bool is_flat)
-        : _router(_make_router(router_lookahead, is_flat))
+        : _router(_make_router(router_lookahead, router_opts, is_flat))
         , _net_list(net_list)
         , _router_opts(router_opts)
         , _connections_inf(connections_inf)
@@ -32,30 +34,51 @@ class SerialNetlistRouter : public NetlistRouter {
         , _routing_predictor(routing_predictor)
         , _choking_spots(choking_spots)
         , _is_flat(is_flat) {}
-    ~SerialNetlistRouter() {}
+    ~SerialNetlistRouter() {
+      delete _router;
+    }
 
     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);
 
   private:
-    ConnectionRouter<HeapType> _make_router(const RouterLookahead* router_lookahead, bool is_flat) {
+    ConnectionRouterInterface *_make_router(const RouterLookahead* router_lookahead,
+                                            const t_router_opts& router_opts,
+                                            bool is_flat) {
         auto& device_ctx = g_vpr_ctx.device();
         auto& route_ctx = g_vpr_ctx.mutable_routing();
 
-        return ConnectionRouter<HeapType>(
-            device_ctx.grid,
-            *router_lookahead,
-            device_ctx.rr_graph.rr_nodes(),
-            &device_ctx.rr_graph,
-            device_ctx.rr_rc_data,
-            device_ctx.rr_graph.rr_switch(),
-            route_ctx.rr_node_route_inf,
-            is_flat);
+        if (!router_opts.enable_parallel_connection_router) {
+            // Serial Connection Router
+            return new SerialConnectionRouter<HeapType>(
+                device_ctx.grid,
+                *router_lookahead,
+                device_ctx.rr_graph.rr_nodes(),
+                &device_ctx.rr_graph,
+                device_ctx.rr_rc_data,
+                device_ctx.rr_graph.rr_switch(),
+                route_ctx.rr_node_route_inf,
+                is_flat);
+        } else {
+            // Parallel Connection Router
+            return new ParallelConnectionRouter<HeapType>(
+                device_ctx.grid,
+                *router_lookahead,
+                device_ctx.rr_graph.rr_nodes(),
+                &device_ctx.rr_graph,
+                device_ctx.rr_rc_data,
+                device_ctx.rr_graph.rr_switch(),
+                route_ctx.rr_node_route_inf,
+                is_flat,
+                router_opts.multi_queue_num_threads,
+                router_opts.multi_queue_num_queues,
+                router_opts.multi_queue_direct_draining);
+        }
     }
     /* Context fields */
-    ConnectionRouter<HeapType> _router;
+    ConnectionRouterInterface *_router;
     const Netlist<>& _net_list;
     const t_router_opts& _router_opts;
     CBRR& _connections_inf;

vpr/src/route/SerialNetlistRouter.tpp

@@ -22,7 +22,7 @@ inline RouteIterResults SerialNetlistRouter<HeapType>::route_netlist(int itry, f
     for (size_t inet = 0; inet < sorted_nets.size(); inet++) {
         ParentNetId net_id = sorted_nets[inet];
         NetResultFlags flags = route_net(
-            _router,
+            *_router,
             _net_list,
             net_id,
             itry,
@@ -42,7 +42,7 @@ inline RouteIterResults SerialNetlistRouter<HeapType>::route_netlist(int itry, f
             route_ctx.route_bb[net_id]);
 
         if (!flags.success && !flags.retry_with_full_bb) {
-            /* Disconnected RRG and ConnectionRouter doesn't think growing the BB will work */
+            /* Disconnected RRG and SerialConnectionRouter doesn't think growing the BB will work */
             out.is_routable = false;
             return out;
         }
@@ -74,7 +74,7 @@ void SerialNetlistRouter<HeapType>::handle_bb_updated_nets(const std::vector<Par
 
 template<typename HeapType>
 void SerialNetlistRouter<HeapType>::set_rcv_enabled(bool x) {
-    _router.set_rcv_enabled(x);
+    _router->set_rcv_enabled(x);
 }
 
 template<typename HeapType>

vpr/src/route/connection_router_interface.h

@@ -24,6 +24,8 @@ struct t_conn_cost_params {
     float criticality = 1.;
     float astar_fac = 1.2;
     float astar_offset = 0.f;
+    float post_target_prune_fac = 1.2f;
+    float post_target_prune_offset = 0.f;
     float bend_cost = 1.;
     float pres_fac = 1.;
     const t_conn_delay_budget* delay_budget = nullptr;

vpr/src/route/d_ary_heap.h

@@ -21,6 +21,8 @@
 template<unsigned D>
 class DAryHeap : public HeapInterface {
   public:
+    static constexpr unsigned arg_D = D;
+
     using priority_queue = customized_d_ary_priority_queue<D, HeapNode, std::vector<HeapNode>, HeapNodeComparator>;
 
     DAryHeap() {}