Add the "none" reordering, and fix the seed for random_shuffle

Author: HackerFoo

vpr/src/base/SetupVPR.cpp

@@ -354,6 +354,7 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->read_rr_edge_metadata = Options.read_rr_edge_metadata;
     RouterOpts->reorder_rr_graph_nodes_algorithm = Options.reorder_rr_graph_nodes_algorithm;
     RouterOpts->reorder_rr_graph_nodes_threshold = Options.reorder_rr_graph_nodes_threshold;
+    RouterOpts->reorder_rr_graph_nodes_seed = Options.reorder_rr_graph_nodes_seed;
 
     //TODO document these?
     RouterOpts->trim_empty_channels = false; /* DEFAULT */

vpr/src/base/read_options.cpp

@@ -166,7 +166,9 @@ struct ParseRouterAlgorithm {
 struct ParseNodeReorderAlgorithm {
     ConvertedValue<e_node_reorder_algorithm> from_str(std::string str) {
         ConvertedValue<e_node_reorder_algorithm> conv_value;
-        if (str == "degree_bfs")
+        if (str == "none")
+            conv_value.set_value(DONT_REORDER);
+        else if (str == "degree_bfs")
             conv_value.set_value(DEGREE_BFS);
         else if (str == "random_shuffle")
             conv_value.set_value(RANDOM_SHUFFLE);
@@ -180,7 +182,9 @@ struct ParseNodeReorderAlgorithm {
 
     ConvertedValue<std::string> to_str(e_node_reorder_algorithm val) {
         ConvertedValue<std::string> conv_value;
-        if (val == DEGREE_BFS)
+        if (val == DONT_REORDER)
+            conv_value.set_value("none");
+        else if (val == DEGREE_BFS)
             conv_value.set_value("degree_bfs");
         else {
             VTR_ASSERT(val == RANDOM_SHUFFLE);
@@ -190,7 +194,7 @@ struct ParseNodeReorderAlgorithm {
     }
 
     std::vector<std::string> default_choices() {
-        return {"degree_bfs", "random_shuffle"};
+        return {"none", "degree_bfs", "random_shuffle"};
     }
 };
 
@@ -1899,16 +1903,23 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
     route_grp.add_argument<e_node_reorder_algorithm, ParseNodeReorderAlgorithm>(args.reorder_rr_graph_nodes_algorithm, "--reorder_rr_graph_nodes_algorithm")
         .help(
             "Specifies the node reordering algorithm to use.\n"
+            " * none: don't reorder nodes\n"
             " * degree_bfs: sort by degree and then by BFS\n"
             " * random_shuffle: a random shuffle\n")
-        .default_value("degree_bfs")
-        .choices({"degree_bfs", "random_shuffle"})
+        .default_value("none")
+        .choices({"node", "degree_bfs", "random_shuffle"})
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     route_grp.add_argument(args.reorder_rr_graph_nodes_threshold, "--reorder_rr_graph_nodes_threshold")
         .help(
-            "Reorder rr_graph nodes to optimize memory layout above this number of nodes, or -1 to disable.")
-        .default_value("-1")
+            "Reorder rr_graph nodes to optimize memory layout above this number of nodes.")
+        .default_value("0")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
+    route_grp.add_argument(args.reorder_rr_graph_nodes_seed, "--reorder_rr_graph_nodes_seed")
+        .help(
+            "Pseudo-random number generator seed used for the random_shuffle reordering algorithm")
+        .default_value("1")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     auto& route_timing_grp = parser.add_argument_group("timing-driven routing options");

vpr/src/base/read_options.h

@@ -154,6 +154,7 @@ struct t_options {
     argparse::ArgValue<bool> generate_rr_node_overuse_report;
     argparse::ArgValue<e_node_reorder_algorithm> reorder_rr_graph_nodes_algorithm;
     argparse::ArgValue<int> reorder_rr_graph_nodes_threshold;
+    argparse::ArgValue<int> reorder_rr_graph_nodes_seed;
 
     /* Timing-driven router options only */
     argparse::ArgValue<float> astar_fac;

vpr/src/base/vpr_types.h

@@ -992,6 +992,7 @@ enum e_router_algorithm {
 };
 
 enum e_node_reorder_algorithm {
+    DONT_REORDER,
     DEGREE_BFS,
     RANDOM_SHUFFLE,
 };
@@ -1048,8 +1049,9 @@ enum class e_incr_reroute_delay_ripup {
 constexpr int NO_FIXED_CHANNEL_WIDTH = -1;
 
 struct t_router_opts {
-    e_node_reorder_algorithm reorder_rr_graph_nodes_algorithm = DEGREE_BFS;
-    int reorder_rr_graph_nodes_threshold = -1;
+    e_node_reorder_algorithm reorder_rr_graph_nodes_algorithm = DONT_REORDER;
+    int reorder_rr_graph_nodes_threshold = 0;
+    int reorder_rr_graph_nodes_seed = 1;
     bool read_rr_edge_metadata = false;
     bool do_check_rr_graph = true;
     float first_iter_pres_fac;

vpr/src/route/rr_graph_util.cpp

@@ -86,6 +86,7 @@ void reorder_rr_graph_nodes(const t_router_opts& router_opts) {
     auto& graph = device_ctx.rr_nodes;
     size_t v_num = graph.size();
 
+    if (router_opts.reorder_rr_graph_nodes_algorithm == DONT_REORDER) return;
     if (router_opts.reorder_rr_graph_nodes_threshold < 0 || v_num < (size_t)router_opts.reorder_rr_graph_nodes_threshold) return;
 
     vtr::ScopedStartFinishTimer timer("Reordering rr_graph nodes");
@@ -127,8 +128,7 @@ void reorder_rr_graph_nodes(const t_router_opts& router_opts) {
                  return deg_a > deg_b || (deg_a == deg_b && bfs_idx[a] < bfs_idx[b]);
              });
     } else if (router_opts.reorder_rr_graph_nodes_algorithm == RANDOM_SHUFFLE) {
-        std::random_device rd;
-        std::mt19937 g(rd());
+        std::mt19937 g(router_opts.reorder_rr_graph_nodes_seed);
         std::shuffle(src_order.begin(), src_order.end(), g);
     }
     vtr::vector<RRNodeId, RRNodeId> dest_order(v_num);