Implemented two node reordering algorithms

HackerFoo · HackerFoo · commit fb381c011f3b · 2020-05-05T14:06:55.000-07:00
Signed-off-by: Dusty DeWeese &lt;dustin.deweese@gmail.com&gt;
diff --git a/vpr/src/base/SetupVPR.cpp b/vpr/src/base/SetupVPR.cpp
@@ -343,6 +343,8 @@ 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;
 
     //TODO document these?
     RouterOpts->trim_empty_channels = false; /* DEFAULT */
diff --git a/vpr/src/base/place_and_route.cpp b/vpr/src/base/place_and_route.cpp
@@ -352,16 +352,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) {
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -163,6 +163,37 @@ 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")
+            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_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_node_reorder_algorithm val) {
+        ConvertedValue<std::string> conv_value;
+        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 {"degree_bfs", "random_shuffle"};
+    }
+};
+
 struct RouteBudgetsAlgorithm {
     ConvertedValue<e_routing_budgets_algorithm> from_str(std::string str) {
         ConvertedValue<e_routing_budgets_algorithm> conv_value;
@@ -1735,6 +1766,21 @@ 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_node_reorder_algorithm, ParseNodeReorderAlgorithm>(args.reorder_rr_graph_nodes_algorithm, "--reorder_rr_graph_nodes_algorithm")
+        .help(
+            "Specifies the node reordering algorithm to use.\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"})
+        .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")
+        .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")
diff --git a/vpr/src/base/read_options.h b/vpr/src/base/read_options.h
@@ -140,6 +140,8 @@ struct t_options {
     argparse::ArgValue<int> min_incremental_reroute_fanout;
     argparse::ArgValue<bool> read_rr_edge_metadata;
     argparse::ArgValue<bool> exit_after_first_routing_iteration;
+    argparse::ArgValue<e_node_reorder_algorithm> reorder_rr_graph_nodes_algorithm;
+    argparse::ArgValue<int> reorder_rr_graph_nodes_threshold;
 
     /* Timing-driven router options only */
     argparse::ArgValue<float> astar_fac;
diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp
@@ -866,14 +866,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);
 }
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -910,6 +910,11 @@ enum e_router_algorithm {
     TIMING_DRIVEN,
 };
 
+enum e_node_reorder_algorithm {
+    DEGREE_BFS,
+    RANDOM_SHUFFLE,
+};
+
 enum e_base_cost_type {
     DELAY_NORMALIZED,
     DELAY_NORMALIZED_LENGTH,
@@ -946,6 +951,8 @@ 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;
     bool read_rr_edge_metadata = false;
     bool do_check_rr_graph = true;
     float first_iter_pres_fac;
diff --git a/vpr/src/route/route_common.cpp b/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);
diff --git a/vpr/src/route/router_delay_profiling.cpp b/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();
 
diff --git a/vpr/src/route/rr_graph.cpp b/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();
diff --git a/vpr/src/route/rr_graph.h b/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();
 
diff --git a/vpr/src/route/rr_graph_storage.cpp b/vpr/src/route/rr_graph_storage.cpp
@@ -709,3 +709,68 @@ t_rr_graph_view t_rr_graph_storage::view() const {
         vtr::make_const_array_view_id(edge_dest_node_),
         vtr::make_const_array_view_id(edge_switch_));
 }
+
+void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
+                                 const vtr::vector<RRNodeId, RRNodeId>& inverse_order) {
+    {
+        auto old_node_storage = node_storage_;
+
+        // Reorder nodes
+        for (size_t i = 0; i < node_storage_.size(); i++) {
+            auto n = RRNodeId(i);
+            VTR_ASSERT(n == inverse_order[order[n]]);
+            node_storage_[order[n]] = old_node_storage[n];
+        }
+    }
+    {
+        auto old_node_first_edge = node_first_edge_;
+        auto old_edge_src_node = edge_src_node_;
+        auto old_edge_dest_node = edge_dest_node_;
+        auto old_edge_switch = edge_switch_;
+        RREdgeId cur_edge(0);
+
+        // Reorder edges by source node
+        for (size_t i = 0; i < node_storage_.size(); i++) {
+            node_first_edge_[RRNodeId(i)] = cur_edge;
+            auto n = inverse_order[RRNodeId(i)];
+            for (auto e = old_node_first_edge[n];
+                 e < old_node_first_edge[RRNodeId(size_t(n) + 1)];
+                 e = RREdgeId(size_t(e) + 1)) {
+                edge_src_node_[cur_edge] = order[old_edge_src_node[e]]; // == n?
+                edge_dest_node_[cur_edge] = order[old_edge_dest_node[e]];
+                edge_switch_[cur_edge] = old_edge_switch[e];
+                cur_edge = RREdgeId(size_t(cur_edge) + 1);
+            }
+        }
+    }
+    {
+        auto old_node_ptc = node_ptc_;
+        for (size_t i = 0; i < node_ptc_.size(); i++) {
+            node_ptc_[order[RRNodeId(i)]] = old_node_ptc[RRNodeId(i)];
+        }
+    }
+    {
+        auto old_node_fan_in = node_fan_in_;
+        for (size_t i = 0; i < node_fan_in_.size(); i++) {
+            node_fan_in_[order[RRNodeId(i)]] = old_node_fan_in[RRNodeId(i)];
+        }
+    }
+
+    // Check that edges are still partitioned
+    if (partitioned_) {
+        auto& device_ctx = g_vpr_ctx.device();
+        for (size_t i = 0; i < size(); i++) {
+            RRNodeId n(i);
+            bool configurable_partition = true;
+            for (auto e = first_edge(n);
+                 e < last_edge(n);
+                 e = RREdgeId(size_t(e) + 1)) {
+                if (device_ctx.rr_switch_inf[edge_switch(e)].configurable()) {
+                    VTR_ASSERT(configurable_partition);
+                } else {
+                    configurable_partition = false;
+                }
+            }
+        }
+    }
+}
diff --git a/vpr/src/route/rr_graph_storage.h b/vpr/src/route/rr_graph_storage.h
@@ -433,6 +433,8 @@ class t_rr_graph_storage {
         node_storage_.emplace_back();
         node_ptc_.emplace_back();
     }
+    void reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
+                 const vtr::vector<RRNodeId, RRNodeId>& inverse_order);
 
     /* PTC set methods */
     void set_node_ptc_num(RRNodeId id, short);
diff --git a/vpr/src/route/rr_graph_util.cpp b/vpr/src/route/rr_graph_util.cpp
diff --git a/vpr/src/route/rr_graph_util.h b/vpr/src/route/rr_graph_util.h

Original file line number	Diff line number	Diff line change
`@@ -433,6 +433,8 @@ class t_rr_graph_storage {`
`433`	`433`	`node_storage_.emplace_back();`
`434`	`434`	`node_ptc_.emplace_back();`
`435`	`435`	`}`
	`436`	`+ void reorder(const vtr::vector<RRNodeId, RRNodeId>& order,`
	`437`	`+ const vtr::vector<RRNodeId, RRNodeId>& inverse_order);`
`436`	`438`
`437`	`439`	`/* PTC set methods */`
`438`	`440`	`void set_node_ptc_num(RRNodeId id, short);`