Merge pull request #1271 from HackerFoo/node_reordering_flag

Add flags to reorder RR graph nodes

Author: HackerFoo

vpr/src/base/SetupVPR.cpp

@@ -352,6 +352,9 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->fixed_channel_width = Options.RouteChanWidth;
     RouterOpts->min_channel_width_hint = Options.min_route_chan_width_hint;
     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/place_and_route.cpp

@@ -353,16 +353,17 @@ int binary_search_place_and_route(const t_placer_opts& placer_opts_ref,
                     device_ctx.num_arch_switches,
                     det_routing_arch,
                     segment_inf,
-                    router_opts.base_cost_type,
-                    router_opts.trim_empty_channels,
-                    router_opts.trim_obs_channels,
-                    router_opts.clock_modeling,
+                    router_opts,
                     arch->Directs, arch->num_directs,
-                    &warnings,
-                    router_opts.read_rr_edge_metadata,
-                    router_opts.do_check_rr_graph);
+                    &warnings);
 
     init_draw_coords(final);
+
+    /* Allocate and load additional rr_graph information needed only by the router. */
+    alloc_and_load_rr_node_route_structs();
+
+    init_route_structs(router_opts.bb_factor);
+
     restore_routing(best_routing, route_ctx.clb_opins_used_locally, saved_clb_opins_used_locally);
 
     if (Fc_clipped) {

vpr/src/base/read_options.cpp

@@ -163,6 +163,41 @@ struct ParseRouterAlgorithm {
     }
 };
 
+struct ParseNodeReorderAlgorithm {
+    ConvertedValue<e_rr_node_reorder_algorithm> from_str(std::string str) {
+        ConvertedValue<e_rr_node_reorder_algorithm> conv_value;
+        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);
+        else {
+            std::stringstream msg;
+            msg << "Invalid conversion from '" << str << "' to e_rr_node_reorder_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
+            conv_value.set_error(msg.str());
+        }
+        return conv_value;
+    }
+
+    ConvertedValue<std::string> to_str(e_rr_node_reorder_algorithm val) {
+        ConvertedValue<std::string> conv_value;
+        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);
+            conv_value.set_value("random_shuffle");
+        }
+        return conv_value;
+    }
+
+    std::vector<std::string> default_choices() {
+        return {"none", "degree_bfs", "random_shuffle"};
+    }
+};
+
 struct RouteBudgetsAlgorithm {
     ConvertedValue<e_routing_budgets_algorithm> from_str(std::string str) {
         ConvertedValue<e_routing_budgets_algorithm> conv_value;
@@ -1897,6 +1932,28 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("off")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_grp.add_argument<e_rr_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("none")
+        .choices({"none", "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.")
+        .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");
 
     route_timing_grp.add_argument(args.astar_fac, "--astar_fac")

vpr/src/base/read_options.h

@@ -150,6 +150,9 @@ struct t_options {
     argparse::ArgValue<e_check_route_option> check_route;
     argparse::ArgValue<size_t> max_logged_overused_rr_nodes;
     argparse::ArgValue<bool> generate_rr_node_overuse_report;
+    argparse::ArgValue<e_rr_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_api.cpp

@@ -888,14 +888,9 @@ void vpr_create_rr_graph(t_vpr_setup& vpr_setup, const t_arch& arch, int chan_wi
                     device_ctx.num_arch_switches,
                     det_routing_arch,
                     vpr_setup.Segments,
-                    router_opts.base_cost_type,
-                    router_opts.trim_empty_channels,
-                    router_opts.trim_obs_channels,
-                    router_opts.clock_modeling,
+                    router_opts,
                     arch.Directs, arch.num_directs,
-                    &warnings,
-                    router_opts.read_rr_edge_metadata,
-                    router_opts.do_check_rr_graph);
+                    &warnings);
     //Initialize drawing, now that we have an RR graph
     init_draw_coords(chan_width_fac);
 }

vpr/src/base/vpr_types.h

@@ -994,6 +994,13 @@ enum e_router_algorithm {
     TIMING_DRIVEN,
 };
 
+// Node reordering algorithms for rr_nodes
+enum e_rr_node_reorder_algorithm {
+    DONT_REORDER,
+    DEGREE_BFS,
+    RANDOM_SHUFFLE,
+};
+
 enum e_base_cost_type {
     DELAY_NORMALIZED,
     DELAY_NORMALIZED_LENGTH,
@@ -1105,6 +1112,11 @@ struct t_router_opts {
 
     size_t max_logged_overused_rr_nodes;
     bool generate_rr_node_overuse_report;
+
+    // Options related to rr_node reordering, for testing and possible cache optimization
+    e_rr_node_reorder_algorithm reorder_rr_graph_nodes_algorithm = DONT_REORDER;
+    int reorder_rr_graph_nodes_threshold = 0;
+    int reorder_rr_graph_nodes_seed = 1;
 };
 
 struct t_analysis_opts {

vpr/src/route/edge_groups.cpp

@@ -13,7 +13,7 @@ bool EdgeGroups::add_non_config_edge(int from_node, int to_node) {
 // will form groups of nodes that are connected via non-configurable
 // edges.
 void EdgeGroups::create_sets() {
-    rr_non_config_node_sets_map_.clear();
+    rr_non_config_node_sets_.clear();
 
     // https://en.wikipedia.org/wiki/Component_(graph_theory)#Algorithms
     std::vector<size_t> group_size;
@@ -34,20 +34,20 @@ void EdgeGroups::create_sets() {
     }
 
     // Create compact set of sets.
-    rr_non_config_node_sets_map_.resize(group_size.size());
+    rr_non_config_node_sets_.resize(group_size.size());
     for (size_t i = 0; i < group_size.size(); i++) {
-        rr_non_config_node_sets_map_[i].reserve(group_size[i]);
+        rr_non_config_node_sets_[i].reserve(group_size[i]);
     }
     for (const auto& node : graph_) {
-        rr_non_config_node_sets_map_[node.second.set].push_back(node.first);
+        rr_non_config_node_sets_[node.second.set].push_back(node.first);
     }
 }
 
 // Create t_non_configurable_rr_sets from set data.
 // NOTE: The stored graph is undirected, so this may generate reverse edges that don't exist.
 t_non_configurable_rr_sets EdgeGroups::output_sets() {
     t_non_configurable_rr_sets sets;
-    for (const auto& nodes : rr_non_config_node_sets_map_) {
+    for (const auto& nodes : rr_non_config_node_sets_) {
         std::set<t_node_edge> edge_set;
         std::set<int> node_set(nodes.begin(), nodes.end());
 
@@ -67,7 +67,7 @@ t_non_configurable_rr_sets EdgeGroups::output_sets() {
 // Set device context structures for non-configurable node sets.
 void EdgeGroups::set_device_context(DeviceContext& device_ctx) {
     std::vector<std::vector<int>> rr_non_config_node_sets;
-    for (const auto& item : rr_non_config_node_sets_map_) {
+    for (const auto& item : rr_non_config_node_sets_) {
         rr_non_config_node_sets.emplace_back(std::move(item));
     }
 

vpr/src/route/edge_groups.h

@@ -9,7 +9,16 @@
 #include "vpr_types.h"
 #include "vpr_context.h"
 
-// Class for building a group of connected edges.
+// Class for identifying the components of a graph as sets of nodes.
+// Each node is reachable from any other node in the same set, and
+// unreachable from nodes in any other set.
+// Note that edges are undirected.
+//
+// This is used by the router to group nodes connected by
+// non-configurable edges, because a connection to one node
+// must connect them all.
+//
+// https://en.wikipedia.org/wiki/Component_(graph_theory)
 class EdgeGroups {
   public:
     EdgeGroups() {}
@@ -33,8 +42,8 @@ class EdgeGroups {
 
   private:
     struct node_data {
-        std::unordered_set<int> edges;
-        int set = OPEN;
+        std::unordered_set<int> edges; // Set of indices into graph_
+        int set = OPEN;                // Index into rr_non_config_node_sets_
     };
 
     // Perform a DFS traversal marking everything reachable with the same set id
@@ -43,8 +52,9 @@ class EdgeGroups {
     // Set of non-configurable edges.
     std::unordered_map<int, node_data> graph_;
 
-    // Compact set of node sets. Map key is arbitrary.
-    std::vector<std::vector<int>> rr_non_config_node_sets_map_;
+    // Connected components, representing nodes connected by non-configurable edges.
+    // Order is arbitrary.
+    std::vector<std::vector<int>> rr_non_config_node_sets_;
 };
 
 #endif

vpr/src/route/route_common.cpp

@@ -227,14 +227,9 @@ void try_graph(int width_fac, const t_router_opts& router_opts, t_det_routing_ar
                     device_ctx.num_arch_switches,
                     det_routing_arch,
                     segment_inf,
-                    router_opts.base_cost_type,
-                    router_opts.trim_empty_channels,
-                    router_opts.trim_obs_channels,
-                    router_opts.clock_modeling,
+                    router_opts,
                     directs, num_directs,
-                    &warning_count,
-                    router_opts.read_rr_edge_metadata,
-                    router_opts.do_check_rr_graph);
+                    &warning_count);
 }
 
 bool try_route(int width_fac,
@@ -279,14 +274,9 @@ bool try_route(int width_fac,
                     device_ctx.num_arch_switches,
                     det_routing_arch,
                     segment_inf,
-                    router_opts.base_cost_type,
-                    router_opts.trim_empty_channels,
-                    router_opts.trim_obs_channels,
-                    router_opts.clock_modeling,
+                    router_opts,
                     directs, num_directs,
-                    &warning_count,
-                    router_opts.read_rr_edge_metadata,
-                    router_opts.do_check_rr_graph);
+                    &warning_count);
 
     //Initialize drawing, now that we have an RR graph
     init_draw_coords(width_fac);

vpr/src/route/router_delay_profiling.cpp

@@ -221,14 +221,9 @@ void alloc_routing_structs(t_chan_width chan_width,
                     device_ctx.num_arch_switches,
                     det_routing_arch,
                     segment_inf,
-                    router_opts.base_cost_type,
-                    router_opts.trim_empty_channels,
-                    router_opts.trim_obs_channels,
-                    router_opts.clock_modeling,
+                    router_opts,
                     directs, num_directs,
-                    &warnings,
-                    router_opts.read_rr_edge_metadata,
-                    router_opts.do_check_rr_graph);
+                    &warnings);
 
     alloc_and_load_rr_node_route_structs();
 

vpr/src/route/rr_graph.cpp

@@ -317,15 +317,10 @@ void create_rr_graph(const t_graph_type graph_type,
                      const int num_arch_switches,
                      t_det_routing_arch* det_routing_arch,
                      const std::vector<t_segment_inf>& segment_inf,
-                     const enum e_base_cost_type base_cost_type,
-                     const bool trim_empty_channels,
-                     const bool trim_obs_channels,
-                     const enum e_clock_modeling clock_modeling,
+                     const t_router_opts& router_opts,
                      const t_direct_inf* directs,
                      const int num_directs,
-                     int* Warnings,
-                     bool read_rr_edge_metadata,
-                     bool do_check_rr_graph) {
+                     int* Warnings) {
     const auto& device_ctx = g_vpr_ctx.device();
 
     if (!det_routing_arch->read_rr_graph_filename.empty()) {
@@ -335,11 +330,12 @@ void create_rr_graph(const t_graph_type graph_type,
             load_rr_file(graph_type,
                          grid,
                          segment_inf,
-                         base_cost_type,
+                         router_opts.base_cost_type,
                          &det_routing_arch->wire_to_rr_ipin_switch,
                          det_routing_arch->read_rr_graph_filename.c_str(),
-                         read_rr_edge_metadata,
-                         do_check_rr_graph);
+                         router_opts.read_rr_edge_metadata,
+                         router_opts.do_check_rr_graph);
+            reorder_rr_graph_nodes(router_opts);
         }
     } else {
         if (channel_widths_unchanged(device_ctx.chan_width, nodes_per_chan) && !device_ctx.rr_nodes.empty()) {
@@ -364,13 +360,14 @@ void create_rr_graph(const t_graph_type graph_type,
                        det_routing_arch->delayless_switch,
                        det_routing_arch->R_minW_nmos,
                        det_routing_arch->R_minW_pmos,
-                       base_cost_type,
-                       clock_modeling,
-                       trim_empty_channels,
-                       trim_obs_channels,
+                       router_opts.base_cost_type,
+                       router_opts.clock_modeling,
+                       router_opts.trim_empty_channels,
+                       router_opts.trim_obs_channels,
                        directs, num_directs,
                        &det_routing_arch->wire_to_rr_ipin_switch,
                        Warnings);
+        reorder_rr_graph_nodes(router_opts);
     }
 
     process_non_config_sets();

vpr/src/route/rr_graph.h

@@ -33,15 +33,10 @@ void create_rr_graph(const t_graph_type graph_type,
                      const int num_arch_switches,
                      t_det_routing_arch* det_routing_arch,
                      const std::vector<t_segment_inf>& segment_inf,
-                     const enum e_base_cost_type base_cost_type,
-                     const bool trim_empty_channels,
-                     const bool trim_obs_channels,
-                     const enum e_clock_modeling clock_modeling,
+                     const t_router_opts& router_opts,
                      const t_direct_inf* directs,
                      const int num_directs,
-                     int* Warnings,
-                     bool read_rr_edge_metadata,
-                     bool do_check_rr_graph);
+                     int* Warnings);
 
 void free_rr_graph();