Merge pull request #2496 from verilog-to-routing/noc_turn_model_routing

NoC Turn Model Routing Algorithms

Author: vaughnbetz

libs/EXTERNAL/libargparse/src/argparse.cpp

@@ -1,10 +1,10 @@
 #include <algorithm>
-#include <array>
 #include <list>
 #include <cassert>
 #include <string>
 #include <set>
 #include <limits>
+#include <utility>
 
 #include "argparse.hpp"
 #include "argparse_util.hpp"
@@ -16,16 +16,16 @@ namespace argparse {
      * ArgumentParser
      */
 
-    ArgumentParser::ArgumentParser(std::string prog_name, std::string description_str, std::ostream& os)
-        : description_(description_str)
+    ArgumentParser::ArgumentParser(const std::string& prog_name, std::string description_str, std::ostream& os)
+        : description_(std::move(description_str))
         , formatter_(new DefaultFormatter())
         , os_(os)
         {
         prog(prog_name);
         argument_groups_.push_back(ArgumentGroup("arguments"));
     }
 
-    ArgumentParser& ArgumentParser::prog(std::string prog_name, bool basename_only) {
+    ArgumentParser& ArgumentParser::prog(const std::string& prog_name, bool basename_only) {
         if (basename_only) {
             prog_ = basename(prog_name);
         } else {
@@ -35,17 +35,17 @@ namespace argparse {
     }
 
     ArgumentParser& ArgumentParser::version(std::string version_str) {
-        version_ = version_str;
+        version_ = std::move(version_str);
         return *this;
     }
 
     ArgumentParser& ArgumentParser::epilog(std::string epilog_str) {
-        epilog_ = epilog_str;
+        epilog_ = std::move(epilog_str);
         return *this;
     }
 
     ArgumentGroup& ArgumentParser::add_argument_group(std::string description_str) {
-        argument_groups_.push_back(ArgumentGroup(description_str));
+        argument_groups_.push_back(ArgumentGroup(std::move(description_str)));
         return argument_groups_[argument_groups_.size() - 1];
     }
 
@@ -72,7 +72,7 @@ namespace argparse {
     void ArgumentParser::parse_args_throw(int argc, const char* const* argv) {
         std::vector<std::string> arg_strs;
         for (int i = 1; i < argc; ++i) {
-            arg_strs.push_back(argv[i]);
+            arg_strs.emplace_back(argv[i]);
         }
 
         parse_args_throw(arg_strs);
@@ -241,7 +241,7 @@ namespace argparse {
                     } else if (arg->nargs() == '+' || arg->nargs() == '*') {
                         if (arg->nargs() == '+') {
                             assert(nargs_read >= 1);
-                            assert(values.size() >= 1);
+                            assert(!values.empty());
                         }
 
                         for (const auto& value : values) {
@@ -410,11 +410,11 @@ namespace argparse {
      * ArgumentGroup
      */
     ArgumentGroup::ArgumentGroup(std::string name_str)
-        : name_(name_str)
+        : name_(std::move(name_str))
         {}
 
     ArgumentGroup& ArgumentGroup::epilog(std::string str) {
-        epilog_ = str;
+        epilog_ = std::move(str);
         return *this;
     }
     std::string ArgumentGroup::name() const { return name_; }
@@ -425,10 +425,10 @@ namespace argparse {
      * Argument
      */
     Argument::Argument(std::string long_opt, std::string short_opt)
-        : long_opt_(long_opt)
-        , short_opt_(short_opt) {
+        : long_opt_(std::move(long_opt))
+        , short_opt_(std::move(short_opt)) {
 
-        if (long_opt_.size() < 1) {
+        if (long_opt_.empty()) {
             throw ArgParseError("Argument must be at least one character long");
         }
 
@@ -445,7 +445,7 @@ namespace argparse {
     }
 
     Argument& Argument::help(std::string help_str) {
-        help_ = help_str;
+        help_ = std::move(help_str);
         return *this;
     }
 
@@ -476,12 +476,12 @@ namespace argparse {
     }
 
     Argument& Argument::metavar(std::string metavar_str) {
-        metavar_ = metavar_str;
+        metavar_ = std::move(metavar_str);
         return *this;
     }
 
     Argument& Argument::choices(std::vector<std::string> choice_values) {
-        choices_ = choice_values;
+        choices_ = std::move(choice_values);
         return *this;
     }
 
@@ -536,7 +536,7 @@ namespace argparse {
     }
 
     Argument& Argument::group_name(std::string grp) {
-        group_name_ = grp;
+        group_name_ = std::move(grp);
         return *this;
     }
 

libs/EXTERNAL/libargparse/src/argparse.hpp

@@ -34,10 +34,10 @@ namespace argparse {
     class ArgumentParser {
         public:
             //Initializes an argument parser
-            ArgumentParser(std::string prog_name, std::string description_str=std::string(), std::ostream& os=std::cout);
+            ArgumentParser(const std::string& prog_name, std::string description_str=std::string(), std::ostream& os=std::cout);
 
             //Overrides the program name
-            ArgumentParser& prog(std::string prog, bool basename_only=true);
+            ArgumentParser& prog(const std::string& prog, bool basename_only=true);
 
             //Sets the program version
             ArgumentParser& version(std::string version);

libs/libvtrutil/src/vtr_util.cpp

@@ -125,7 +125,7 @@ std::string string_fmt(const char* fmt, ...) {
 
 ///@brief Returns a std::string formatted using a printf-style format string taking an explicit va_list
 std::string vstring_fmt(const char* fmt, va_list args) {
-    // We need to copy the args so we don't change them before the true formating
+    // We need to copy the args so we don't change them before the true formatting
     va_list va_args_copy;
     va_copy(va_args_copy, args);
 

vpr/src/base/SetupVPR.cpp

@@ -735,13 +735,12 @@ static void SetupNocOpts(const t_options& Options, t_noc_opts* NocOpts) {
     NocOpts->noc_flows_file = Options.noc_flows_file;
     NocOpts->noc_routing_algorithm = Options.noc_routing_algorithm;
     NocOpts->noc_placement_weighting = Options.noc_placement_weighting;
+    NocOpts->noc_aggregate_bandwidth_weighting = Options.noc_agg_bandwidth_weighting;
     NocOpts->noc_latency_constraints_weighting = Options.noc_latency_constraints_weighting;
     NocOpts->noc_latency_weighting = Options.noc_latency_weighting;
     NocOpts->noc_congestion_weighting = Options.noc_congestion_weighting;
     NocOpts->noc_swap_percentage = Options.noc_swap_percentage;
     NocOpts->noc_placement_file_name = Options.noc_placement_file_name;
-
-    return;
 }
 
 static void find_ipin_cblock_switch_index(const t_arch& Arch, int& wire_to_arch_ipin_switch, int& wire_to_arch_ipin_switch_between_dice) {

vpr/src/base/ShowSetup.cpp

@@ -608,7 +608,7 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
         }
 
         VTR_LOG("PlacerOpts.constraints_file: ");
-        if (PlacerOpts.constraints_file == "") {
+        if (PlacerOpts.constraints_file.empty()) {
             VTR_LOG("No constraints file given\n");
         } else {
             VTR_LOG("Using constraints file '%s'\n", PlacerOpts.constraints_file.c_str());
@@ -795,6 +795,7 @@ static void ShowNocOpts(const t_noc_opts& NocOpts) {
     VTR_LOG("NocOpts.noc_flows_file: %s\n", NocOpts.noc_flows_file.c_str());
     VTR_LOG("NocOpts.noc_routing_algorithm: %s\n", NocOpts.noc_routing_algorithm.c_str());
     VTR_LOG("NocOpts.noc_placement_weighting: %f\n", NocOpts.noc_placement_weighting);
+    VTR_LOG("NocOpts.noc_aggregate_bandwidth_weighting: %f\n", NocOpts.noc_aggregate_bandwidth_weighting);
     VTR_LOG("NocOpts.noc_latency_constraints_weighting: %f\n", NocOpts.noc_latency_constraints_weighting);
     VTR_LOG("NocOpts.noc_latency_weighting: %f\n", NocOpts.noc_latency_weighting);
     VTR_LOG("NocOpts.noc_congestion_weighting: %f\n", NocOpts.noc_congestion_weighting);

vpr/src/base/read_options.cpp

@@ -5,7 +5,6 @@
 
 #include "argparse.hpp"
 
-#include "vtr_memory.h"
 #include "vtr_log.h"
 #include "vtr_util.h"
 #include "vtr_path.h"
@@ -14,7 +13,7 @@
 using argparse::ConvertedValue;
 using argparse::Provenance;
 
-///@brief Read and process VPR's command-line aruments
+///@brief Read and process VPR's command-line arguments
 t_options read_options(int argc, const char** argv) {
     t_options args = t_options(); //Explicitly initialize for zero initialization
 
@@ -1259,7 +1258,7 @@ struct ParsePostSynthNetlistUnconnOutputHandling {
     }
 };
 
-argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& args) {
+argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_options& args) {
     std::string description =
         "Implements the specified circuit onto the target FPGA architecture"
         " by performing packing/placement/routing, and analyzes the result.\n"
@@ -2807,10 +2806,15 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .help(
             "Controls the algorithm used by the NoC to route packets.\n"
             "* xy_routing: Uses the direction oriented routing algorithm. This is recommended to be used with mesh NoC topologies.\n"
-            "* bfs_routing: Uses the breadth first search algorithm. The objective is to find a route that uses a minimum number of links.\n"
-            "This can be used with any NoC topology\n")
+            "* bfs_routing: Uses the breadth first search algorithm. The objective is to find a route that uses a minimum number of links."
+            " This algorithm is not guaranteed to generate deadlock-free traffic flow routes, but can be used with any NoC topology\n"
+            "* west_first_routing: Uses the west-first routing algorithm. This is recommended to be used with mesh NoC topologies.\n"
+            "* north_last_routing: Uses the north-last routing algorithm. This is recommended to be used with mesh NoC topologies.\n"
+            "* negative_first_routing: Uses the negative-first routing algorithm. This is recommended to be used with mesh NoC topologies.\n"
+            "* odd_even_routing: Uses the odd-even routing algorithm. This is recommended to be used with mesh NoC topologies.\n")
         .default_value("bfs_routing")
-        .choices({"xy_routing", "bfs_routing"})
+        .choices({"xy_routing", "bfs_routing", "west_first_routing", "north_last_routing", "negative_first_routing",
+                  "odd_even_routing"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     noc_grp.add_argument<double>(args.noc_placement_weighting, "--noc_placement_weighting")
@@ -2822,6 +2826,16 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("5.0")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    noc_grp.add_argument<double>(args.noc_agg_bandwidth_weighting, "--noc_aggregate_bandwidth_weighting")
+        .help(
+            "Controls the importance of minimizing the NoC aggregate bandwidth.\n"
+            "This value can be >=0, where 0 would mean the aggregate bandwidth has no relevance to placement.\n"
+            "Other positive numbers specify the importance of minimizing the NoC aggregate bandwidth to other NoC-related cost terms.\n"
+            "Weighting factors for NoC-related cost terms are normalized internally. Therefore, their absolute values are not important, and"
+            "only their relative ratios determine the importance of each cost term.")
+        .default_value("0.38")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     noc_grp.add_argument<double>(args.noc_latency_constraints_weighting, "--noc_latency_constraints_weighting")
         .help(
             "Controls the importance of meeting all the NoC traffic flow latency constraints.\n"
@@ -2849,7 +2863,7 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
             "Other positive numbers specify the importance of minimizing congestion to other NoC-related cost terms.\n"
             "Weighting factors for NoC-related cost terms are normalized internally. Therefore, their absolute values are not important, and"
             "only their relative ratios determine the importance of each cost term.")
-        .default_value("0.00")
+        .default_value("0.25")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     noc_grp.add_argument<double>(args.noc_swap_percentage, "--noc_swap_percentage")

vpr/src/base/read_options.h

@@ -153,6 +153,7 @@ struct t_options {
     argparse::ArgValue<std::string> noc_flows_file;
     argparse::ArgValue<std::string> noc_routing_algorithm;
     argparse::ArgValue<double> noc_placement_weighting;
+    argparse::ArgValue<double> noc_agg_bandwidth_weighting;
     argparse::ArgValue<double> noc_latency_constraints_weighting;
     argparse::ArgValue<double> noc_latency_weighting;
     argparse::ArgValue<double> noc_congestion_weighting;
@@ -241,7 +242,7 @@ struct t_options {
     argparse::ArgValue<std::string> write_timing_summary;
 };
 
-argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& args);
+argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_options& args);
 t_options read_options(int argc, const char** argv);
 void set_conditional_defaults(t_options& args);
 bool verify_args(const t_options& args);

vpr/src/noc/bfs_routing.cpp

@@ -1,10 +1,15 @@
-#
+
+#include <queue>
 
 #include "bfs_routing.h"
 
-BFSRouting::~BFSRouting() {}
+BFSRouting::~BFSRouting() = default;
 
-void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model) {
+void BFSRouting::route_flow(NocRouterId src_router_id,
+                            NocRouterId sink_router_id,
+                            NocTrafficFlowId /*traffic_flow_id*/,
+                            std::vector<NocLinkId>& flow_route,
+                            const NocStorage& noc_model) {
     const NocRouter& src_router = noc_model.get_single_noc_router(src_router_id);
     const NocRouter& sink_router = noc_model.get_single_noc_router(sink_router_id);
 
@@ -15,7 +20,7 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
      * Keeps track of which routers have been reached already
      * while traversing the NoC. This variable will help prevent 
      * the algorithm from getting stuck visiting routers that
-     * jave already been visited.
+     * have already been visited.
      * 
      */
     std::unordered_set<NocRouterId> visited_routers;
@@ -46,7 +51,7 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
     }
 
     // Explore the NoC from the starting router and try to find a path to the destination router
-    // We finish searching when there are no more routers to process or we found the destination router
+    // We finish searching when there are no more routers to process, or we found the destination router
     while (!routers_to_process.empty() && !found_sink_router) {
         // get the next router to process
         NocRouterId processing_router = routers_to_process.front();
@@ -88,13 +93,17 @@ void BFSRouting::route_flow(NocRouterId src_router_id, NocRouterId sink_router_i
         generate_route(sink_router_id, flow_route, noc_model, router_parent_link);
     } else {
         // a path was not found so throw an error to the user
-        VPR_FATAL_ERROR(VPR_ERROR_OTHER, "No route could be found from starting router with id:'%d' and the destination router with id:'%d' using the breadth-first search routing algorithm.", src_router.get_router_user_id(), sink_router.get_router_user_id());
+        VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                        "No route could be found from starting router with id:'%d' and the destination router with id:'%d' using the breadth-first search routing algorithm.",
+                        src_router.get_router_user_id(),
+                        sink_router.get_router_user_id());
     }
-
-    return;
 }
 
-void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLinkId>& flow_route, const NocStorage& noc_model, const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link) {
+void BFSRouting::generate_route(NocRouterId start_router_id,
+                                std::vector<NocLinkId>& flow_route,
+                                const NocStorage& noc_model,
+                                const std::unordered_map<NocRouterId, NocLinkId>& router_parent_link) {
     // The intermediate router being visited while tracing the path back from the destination router to the starting router in the flow.
     // Initially this is set to the router at the end of the path (destination router)
     NocRouterId curr_intermediate_router = start_router_id;
@@ -104,11 +113,11 @@ void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLink
     auto route_beginning = flow_route.begin();
 
     // get the parent link of the start router
-    std::unordered_map<NocRouterId, NocLinkId>::const_iterator curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
+    auto curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
 
-    // keep tracking baackwards from each router in the path until a router doesn't have a parent link (this means we reached the starting router in the flow)
+    // keep tracking backwards from each router in the path until a router doesn't have a parent link (this means we reached the starting router in the flow)
     while (curr_intermediate_router_parent_link != router_parent_link.end()) {
-        // add the parent link to the path. Since we are tracing backwards we need to store the links in fron of the last link.
+        // add the parent link to the path. Since we are tracing backwards we need to store the links in front of the last link.
         flow_route.emplace(route_beginning, curr_intermediate_router_parent_link->second);
 
         // update the reference to the beginning of the route
@@ -119,6 +128,4 @@ void BFSRouting::generate_route(NocRouterId start_router_id, std::vector<NocLink
         // now get the parent of the router we moved to
         curr_intermediate_router_parent_link = router_parent_link.find(curr_intermediate_router);
     }
-
-    return;
 }