cleanup and add baseline parallel router

Author: duck2

.github/scripts/hostsetup.sh

@@ -69,7 +69,8 @@ apt install -y \
   default-jdk \
   g++-9 \
   gcc-9 \
-  wget
+  wget \
+  libtbb-dev
 
 # installing the latest version of cmake
 apt install -y apt-transport-https ca-certificates gnupg

doc/src/vpr/command_line_usage.rst

@@ -1127,7 +1127,7 @@ VPR uses a negotiated congestion algorithm (based on Pathfinder) to perform rout
 
     * ``delay_normalized_length_frequency`` like ``delay_normalized``, but scaled by routing resource length and scaled inversely by routing resource frequency.
 
-    **Default:** ``delay_normalized_length`` for the timing-driven router and ``demand_only`` for the breadth-first router
+    **Default:** ``delay_normalized_length``
 
 .. option:: --bend_cost <float>
 
@@ -1172,22 +1172,13 @@ VPR uses a negotiated congestion algorithm (based on Pathfinder) to perform rout
 
     This option attempts to verify the minimum by routing at successively lower channel widths until two consecutive routing failures are observed.
 
-.. option:: --router_algorithm {breadth_first | timing_driven}
+.. option:: --router_algorithm {parallel | timing_driven}
 
     Selects which router algorithm to use.
 
     .. warning::
 
-        The ``breadth_first`` router **should NOT be used to compare the run-time/quality** of alternate routing algorithms.
-
-        It is inferrior to the ``timing_driven`` router from a circuit speed (2x - 10x slower) and run-time perspective (takes 10-100x longer on the large benchmarks).
-        The ``breadth_first`` router is deprecated and may be removed in a future release.
-
-    The ``breadth_first`` router :cite:`betz_arch_cad` focuses solely on routing a design successfully, while the ``timing_driven`` router :cite:`betz_arch_cad,murray_air` focuses both on achieving a successful route and achieving good circuit speed.
-
-    The breadth-first router is capable of routing a design using slightly fewer tracks than the timing-driving router (typically 5% if the timing-driven router uses its default parameters.
-    This can be reduced to about 2% if the router parameters are set so the timing-driven router pays more attention to routability and less to area).
-    The designs produced by the timing-driven router are much faster, however, (2x - 10x) and it uses less CPU time to route.
+        The ``parallel`` router is experimental. (TODO: more explanation)
 
     **Default:** ``timing_driven``
 

libs/EXTERNAL/libargparse/argparse_test.cpp

@@ -399,10 +399,10 @@ int main(
             .show_in(argparse::ShowIn::HELP_ONLY);
     route_grp.add_argument(args.router_algorithm, "--router_algorithm")
             .help("Specifies the router algorithm to use.\n"
-                  " * breadth_first: focuses solely on routability\n"
+                  " * parallel: timing_driven with tricks to run on multiple cores (may be worse)\n"
                   " * timing driven: focuses on routability and circuit speed\n")
             .default_value("timing_driven")
-            .choices({"breadth_first", "timing_driven"})
+            .choices({"parallel", "timing_driven"})
             .show_in(argparse::ShowIn::HELP_ONLY);
     route_grp.add_argument(args.min_incremental_reroute_fanout, "--min_incremental_reroute_fanout")
             .help("The net fanout thershold above which nets will be re-routed incrementally.")

libs/librrgraph/src/base/check_rr_graph.cpp

@@ -596,7 +596,7 @@ static void check_rr_edge(const RRGraphView& rr_graph,
                 std::string msg = "Non-configurable BUFFER type switch must have only one driver. ";
                 msg += vtr::string_fmt(" Actual fan-in was %d (expected 1).\n", to_fanin);
                 msg += "  Possible cause is complex block output pins connecting to:\n";
-                msg += "    " + describe_rr_node(rr_graph, grid, rr_indexed_data, to_node, is_flat);
+                msg += "    " + describe_rr_node(rr_graph, grid, rr_indexed_data, RRNodeId(to_node), is_flat);
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE, msg.c_str());
             }
             break;

libs/librrgraph/src/utils/describe_rr_node.cpp

@@ -4,50 +4,49 @@
 #include "physical_types_util.h"
 #include "vtr_util.h"
 
-/* TODO: This function should adapt RRNodeId */
 std::string describe_rr_node(const RRGraphView& rr_graph,
                              const DeviceGrid& grid,
                              const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data,
-                             int inode,
+                             RRNodeId inode,
                              bool is_flat) {
 
     std::string msg = vtr::string_fmt("RR node: %d", inode);
 
-    if (rr_graph.node_type(RRNodeId(inode)) == CHANX || rr_graph.node_type(RRNodeId(inode)) == CHANY) {
-        auto cost_index = rr_graph.node_cost_index(RRNodeId(inode));
+    if (rr_graph.node_type(inode) == CHANX || rr_graph.node_type(inode) == CHANY) {
+        auto cost_index = rr_graph.node_cost_index(inode);
 
         int seg_index = rr_indexed_data[cost_index].seg_index;
-        std::string rr_node_direction_string = rr_graph.node_direction_string(RRNodeId(inode));
+        std::string rr_node_direction_string = rr_graph.node_direction_string(inode);
 
         if (seg_index < (int)rr_graph.num_rr_segments()) {
             msg += vtr::string_fmt(" track: %d longline: %d",
-                                   rr_graph.node_track_num(RRNodeId(inode)),
+                                   rr_graph.node_track_num(inode),
                                    rr_graph.rr_segments(RRSegmentId(seg_index)).longline);
         } else {
             msg += vtr::string_fmt(" track: %d seg_type: ILLEGAL_SEG_INDEX %d",
-                                   rr_graph.node_track_num(RRNodeId(inode)),
+                                   rr_graph.node_track_num(inode),
                                    seg_index);
         }
-    } else if (rr_graph.node_type(RRNodeId(inode)) == IPIN || rr_graph.node_type(RRNodeId(inode)) == OPIN) {
-        auto type = grid.get_physical_type(rr_graph.node_xlow(RRNodeId(inode)),
-                                           rr_graph.node_ylow(RRNodeId(inode)));
+    } else if (rr_graph.node_type(inode) == IPIN || rr_graph.node_type(inode) == OPIN) {
+        auto type = grid.get_physical_type(rr_graph.node_xlow(inode),
+                                           rr_graph.node_ylow(inode));
 
-        std::string pin_name = block_type_pin_index_to_name(type, rr_graph.node_pin_num(RRNodeId(inode)), is_flat);
+        std::string pin_name = block_type_pin_index_to_name(type, rr_graph.node_pin_num(inode), is_flat);
 
         msg += vtr::string_fmt(" pin: %d pin_name: %s",
-                               rr_graph.node_pin_num(RRNodeId(inode)),
+                               rr_graph.node_pin_num(inode),
                                pin_name.c_str());
     } else {
-        VTR_ASSERT(rr_graph.node_type(RRNodeId(inode)) == SOURCE || rr_graph.node_type(RRNodeId(inode)) == SINK);
+        VTR_ASSERT(rr_graph.node_type(inode) == SOURCE || rr_graph.node_type(inode) == SINK);
 
-        msg += vtr::string_fmt(" class: %d", rr_graph.node_class_num(RRNodeId(inode)));
+        msg += vtr::string_fmt(" class: %d", rr_graph.node_class_num(inode));
     }
 
-    msg += vtr::string_fmt(" capacity: %d", rr_graph.node_capacity(RRNodeId(inode)));
-    msg += vtr::string_fmt(" fan-in: %d", rr_graph.node_fan_in(RRNodeId(inode)));
-    msg += vtr::string_fmt(" fan-out: %d", rr_graph.num_edges(RRNodeId(inode)));
+    msg += vtr::string_fmt(" capacity: %d", rr_graph.node_capacity(inode));
+    msg += vtr::string_fmt(" fan-in: %d", rr_graph.node_fan_in(inode));
+    msg += vtr::string_fmt(" fan-out: %d", rr_graph.num_edges(inode));
 
-    msg += " " + rr_graph.node_coordinate_to_string(RRNodeId(inode));
+    msg += " " + rr_graph.node_coordinate_to_string(inode);
 
     return msg;
 }

libs/librrgraph/src/utils/describe_rr_node.h

@@ -9,7 +9,7 @@
 std::string describe_rr_node(const RRGraphView& rr_graph,
                              const DeviceGrid& grid,
                              const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data,
-                             int inode,
+                             RRNodeId inode,
                              bool is_flat);
 
 #endif

libs/libvtrutil/src/vtr_strong_id.h

@@ -4,7 +4,7 @@
  * @file
  * @brief This header provides the StrongId class.
  *
- * It is template which can be used to create strong Id's 
+ * It is template which can be used to create strong Id's
  * which avoid accidental type conversions (generating compiler errors when they occur).
  *
  * Motivation
@@ -146,6 +146,7 @@
 #include <type_traits> //for std::is_integral
 #include <cstddef>     //for std::size_t
 #include <functional>  //for std::hash
+#include <ostream>     //for std::ostream
 
 namespace vtr {
 
@@ -168,6 +169,9 @@ bool operator!=(const StrongId<tag, T, sentinel>& lhs, const StrongId<tag, T, se
 template<typename tag, typename T, T sentinel>
 bool operator<(const StrongId<tag, T, sentinel>& lhs, const StrongId<tag, T, sentinel>& rhs);
 
+template<typename tag, typename T, T sentinel>
+std::ostream& operator<<(std::ostream& out, const StrongId<tag, T, sentinel>& rhs);
+
 ///@brief Class template definition with default template parameters
 template<typename tag, typename T = int, T sentinel = T(-1)>
 class StrongId {
@@ -197,7 +201,7 @@ class StrongId {
     friend std::hash<StrongId<tag, T, sentinel>>;
 
     /**
-     * @brief To enable comparisions between Ids
+     * @brief To enable comparisons between Ids
      *
      * Note that since these are templated functions we provide an empty set of template parameters
      * after the function name (i.e. <>)
@@ -208,6 +212,11 @@ class StrongId {
     ///@brief < operator
     friend bool operator< <>(const StrongId<tag, T, sentinel>& lhs, const StrongId<tag, T, sentinel>& rhs);
 
+    /**
+     * @brief to be able to print them out
+     */
+    friend std::ostream& operator<< <>(std::ostream& out, const StrongId<tag, T, sentinel>& rhs);
+
   private:
     T id_;
 };
@@ -230,6 +239,12 @@ bool operator<(const StrongId<tag, T, sentinel>& lhs, const StrongId<tag, T, sen
     return lhs.id_ < rhs.id_;
 }
 
+///@brief operator << Needed for print-debugging
+template<typename tag, typename T, T sentinel>
+std::ostream& operator<<(std::ostream& out, const StrongId<tag, T, sentinel>& rhs) {
+    out << rhs.id_;
+    return out;
+}
 } //namespace vtr
 
 ///@brief Specialize std::hash for StrongId's (needed for std::unordered_map-like containers)

utils/route_diag/src/main.cpp

@@ -60,8 +60,8 @@ constexpr int INTERRUPTED_EXIT_CODE = 3; //VPR was interrupted by the user (e.g.
 
 static void do_one_route(const Netlist<>& net_list,
                          const t_det_routing_arch& det_routing_arch,
-                         int source_node,
-                         int sink_node,
+                         RRNodeId source_node,
+                         RRNodeId sink_node,
                          const t_router_opts& router_opts,
                          const std::vector<t_segment_inf>& segment_inf,
                          bool is_flat) {
@@ -117,15 +117,16 @@ static void do_one_route(const Netlist<>& net_list,
                                      -1,
                                      false,
                                      std::unordered_map<RRNodeId, int>());
-    std::tie(found_path, cheapest) = router.timing_driven_route_connection_from_route_tree(tree.root(),
+    std::tie(found_path, std::ignore, cheapest) = router.timing_driven_route_connection_from_route_tree(tree.root(),
                                                                                                     sink_node,
                                                                                                     cost_params,
                                                                                                     bounding_box,
                                                                                                     router_stats,
-                                                                                                    conn_params);
+                                                                                                    conn_params,
+                                                                                                    true);
 
     if (found_path) {
-        VTR_ASSERT(cheapest.index == sink_node);
+        VTR_ASSERT(RRNodeId(cheapest.index) == sink_node);
 
         vtr::optional<const RouteTreeNode&> rt_node_of_sink;
         std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&cheapest, OPEN, nullptr, router_opts.flat_routing);
@@ -137,7 +138,7 @@ static void do_one_route(const Netlist<>& net_list,
         tree.print();
         VTR_LOG("\n");
 
-        VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[size_t(tree.root().inode)].occ() <= rr_graph.node_capacity(tree.root().inode), "SOURCE should never be congested");
+        VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[tree.root().inode].occ() <= rr_graph.node_capacity(tree.root().inode), "SOURCE should never be congested");
     } else {
         VTR_LOG("Routing failed");
     }
@@ -148,7 +149,7 @@ static void do_one_route(const Netlist<>& net_list,
 
 static void profile_source(const Netlist<>& net_list,
                            const t_det_routing_arch& det_routing_arch,
-                           int source_rr_node,
+                           RRNodeId source_rr_node,
                            const t_router_opts& router_opts,
                            const std::vector<t_segment_inf>& segment_inf,
                            bool is_flat) {
@@ -185,26 +186,26 @@ static void profile_source(const Netlist<>& net_list,
             for (int sink_ptc : best_sink_ptcs) {
                 VTR_ASSERT(sink_ptc != OPEN);
 
-                int sink_rr_node = size_t(device_ctx.rr_graph.node_lookup().find_node(sink_x, sink_y, SINK, sink_ptc));
+                RRNodeId sink_rr_node = device_ctx.rr_graph.node_lookup().find_node(sink_x, sink_y, SINK, sink_ptc);
 
                 if (directconnect_exists(source_rr_node, sink_rr_node)) {
                     //Skip if we shouldn't measure direct connects and a direct connect exists
                     continue;
                 }
 
-                VTR_ASSERT(sink_rr_node != OPEN);
+                VTR_ASSERT(sink_rr_node);
 
                 {
                     vtr::ScopedStartFinishTimer delay_timer(vtr::string_fmt(
                         "Routing Src: %d Sink: %d", source_rr_node,
                         sink_rr_node));
-                    successfully_routed = profiler.calculate_delay(source_rr_node, sink_rr_node,
+                    successfully_routed = profiler.calculate_delay(RRNodeId(source_rr_node), RRNodeId(sink_rr_node),
                                                         router_opts,
                                                         &delays[sink_x][sink_y]);
                 }
 
                 if (successfully_routed) {
-                    sink_nodes[sink_x][sink_y] = sink_rr_node;
+                    sink_nodes[sink_x][sink_y] = size_t(sink_rr_node);
                     break;
                 }
             }
@@ -331,15 +332,15 @@ int main(int argc, const char **argv) {
         if(route_options.profile_source) {
             profile_source(net_list,
                            vpr_setup.RoutingArch,
-                           route_options.source_rr_node,
+                           RRNodeId(route_options.source_rr_node),
                            vpr_setup.RouterOpts,
                            vpr_setup.Segments,
                            is_flat);
         } else {
             do_one_route(net_list,
                          vpr_setup.RoutingArch,
-                         route_options.source_rr_node,
-                         route_options.sink_rr_node,
+                         RRNodeId(route_options.source_rr_node),
+                         RRNodeId(route_options.sink_rr_node),
                          vpr_setup.RouterOpts,
                          vpr_setup.Segments,
                          is_flat);

vpr/src/base/ShowSetup.cpp

@@ -260,8 +260,8 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
     if (DETAILED == RouterOpts.route_type) {
         VTR_LOG("RouterOpts.router_algorithm: ");
         switch (RouterOpts.router_algorithm) {
-            case BREADTH_FIRST:
-                VTR_LOG("BREADTH_FIRST\n");
+            case PARALLEL:
+                VTR_LOG("PARALLEL\n");
                 break;
             case TIMING_DRIVEN:
                 VTR_LOG("TIMING_DRIVEN\n");
@@ -432,9 +432,6 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
 
         VTR_LOG("RouterOpts.router_algorithm: ");
         switch (RouterOpts.router_algorithm) {
-            case BREADTH_FIRST:
-                VTR_LOG("BREADTH_FIRST\n");
-                break;
             case TIMING_DRIVEN:
                 VTR_LOG("TIMING_DRIVEN\n");
                 break;

vpr/src/base/old_traceback.cpp

@@ -121,8 +121,8 @@ void print_traceback(const t_trace* trace) {
     auto& route_ctx = g_vpr_ctx.routing();
     const t_trace* prev = nullptr;
     while (trace) {
-        int inode = trace->index;
-        VTR_LOG("%d (%s)", inode, rr_node_typename[rr_graph.node_type(RRNodeId(inode))]);
+        RRNodeId inode(trace->index);
+        VTR_LOG("%d (%s)", inode, rr_node_typename[rr_graph.node_type(inode)]);
 
         if (trace->iswitch == OPEN) {
             VTR_LOG(" !"); //End of branch
@@ -132,7 +132,7 @@ void print_traceback(const t_trace* trace) {
             VTR_LOG("*"); //Reached non-configurably
         }
 
-        if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
+        if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(inode)) {
             VTR_LOG(" x"); //Overused
         }
         VTR_LOG("\n");