API reorder_rr_graph_node() created in rr_graph_util.cpp

vpr/src/device/rr_graph_builder.cpp

@@ -1,5 +1,8 @@
 #include "vtr_log.h"
 #include "rr_graph_builder.h"
+#include "vtr_time.h"
+#include <queue>
+#include "globals.h"
 
 RRGraphBuilder::RRGraphBuilder(t_rr_graph_storage* node_storage)
     : node_storage_(*node_storage) {
@@ -50,3 +53,75 @@ void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) {
 void RRGraphBuilder::clear() {
     node_lookup_.clear();
 }
+
+void RRGraphBuilder::reorder_rr_graph_nodes(const t_router_opts& router_opts) {
+    auto& device_ctx = g_vpr_ctx.mutable_device();
+    auto& rr_graph = device_ctx.rr_graph;
+    size_t v_num = node_storage_.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");
+
+    vtr::vector<RRNodeId, RRNodeId> src_order(v_num); // new id -> old id
+    size_t cur_idx = 0;
+    for (RRNodeId& n : src_order) { // Initialize to [0, 1, 2 ...]
+        n = RRNodeId(cur_idx++);
+    }
+
+    // This method works well. The intution is that highly connected nodes are enumerated first (together),
+    // and since there will be a lot of nodes with the same degree, they are then ordered based on some
+    // distance from the starting node.
+    if (router_opts.reorder_rr_graph_nodes_algorithm == DEGREE_BFS) {
+        vtr::vector<RRNodeId, size_t> bfs_idx(v_num);
+        vtr::vector<RRNodeId, size_t> degree(v_num);
+        std::queue<RRNodeId> que;
+
+        // Compute both degree (in + out) and an index based on the BFS traversal
+        cur_idx = 0;
+        for (size_t i = 0; i < v_num; ++i) {
+            if (bfs_idx[RRNodeId(i)]) continue;
+            que.push(RRNodeId(i));
+            bfs_idx[RRNodeId(i)] = cur_idx++;
+            while (!que.empty()) {
+                RRNodeId u = que.front();
+                que.pop();
+                degree[u] += node_storage_.num_edges(u);
+                for (RREdgeId edge = rr_graph.node_first_edge(u); edge < rr_graph.node_last_edge(u); edge = RREdgeId(size_t(edge) + 1)) {
+                    RRNodeId v = node_storage_.edge_sink_node(edge);
+                    degree[v]++;
+                    if (bfs_idx[v]) continue;
+                    bfs_idx[v] = cur_idx++;
+                    que.push(v);
+                }
+            }
+        }
+
+        // Sort by degree primarily, and BFS order secondarily
+        sort(src_order.begin(), src_order.end(),
+             [&](auto a, auto b) -> bool {
+                 auto deg_a = degree[a];
+                 auto deg_b = degree[b];
+                 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::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);
+    cur_idx = 0;
+    for (auto u : src_order)
+        dest_order[u] = RRNodeId(cur_idx++);
+
+    node_storage_.reorder(dest_order, src_order);
+
+    node_lookup().reorder(dest_order);
+
+    device_ctx.rr_node_metadata.remap_keys([&](int node) { return size_t(dest_order[RRNodeId(node)]); });
+    device_ctx.rr_edge_metadata.remap_keys([&](std::tuple<int, int, short> edge) {
+        return std::make_tuple(size_t(dest_order[RRNodeId(std::get<0>(edge))]),
+                               size_t(dest_order[RRNodeId(std::get<1>(edge))]),
+                               std::get<2>(edge));
+    });
+}

vpr/src/device/rr_graph_builder.h

@@ -59,6 +59,20 @@ class RRGraphBuilder {
     /** @brief Clear all the underlying data storage */
     void clear();
 
+    // Reorder RRNodeId's using one of these algorithms:
+    //   - DONT_REORDER: The identity reordering (does nothing.)
+    //   - DEGREE_BFS: Order by degree primarily, and BFS traversal order secondarily.
+    //   - RANDOM_SHUFFLE: Shuffle using the specified seed. Great for testing.
+    // The DEGREE_BFS algorithm was selected because it had the best performance of seven
+    // existing algorithms here: https://github.com/SymbiFlow/vtr-rrgraph-reordering-tool
+    // It might be worth further research, as the DEGREE_BFS algorithm is simple and
+    // makes some arbitrary choices, such as the starting node.
+    // Nonetheless, it does improve performance ~7% for the SymbiFlow Xilinx Artix 7 graph.
+    //
+    // NOTE: Re-ordering will invalidate any references to rr_graph nodes, so this
+    //       should generally be called before creating such references.
+    void reorder_rr_graph_nodes(const t_router_opts& router_opts);
+
     /** @brief Set capacity of this node (number of routes that can use it). */
     inline void set_node_capacity(RRNodeId id, short new_capacity) {
         node_storage_.set_node_capacity(id, new_capacity);

vpr/src/route/rr_graph.cpp

@@ -34,6 +34,7 @@
 #include "router_lookahead_map.h"
 #include "rr_graph_clock.h"
 #include "edge_groups.h"
+#include "rr_graph_builder.h"
 
 #include "rr_types.h"
 
@@ -313,6 +314,7 @@ void create_rr_graph(const t_graph_type graph_type,
                      const int num_directs,
                      int* Warnings) {
     const auto& device_ctx = g_vpr_ctx.device();
+    auto& mutable_device_ctx = g_vpr_ctx.mutable_device();
 
     if (!det_routing_arch->read_rr_graph_filename.empty()) {
         if (device_ctx.read_rr_graph_filename != det_routing_arch->read_rr_graph_filename) {
@@ -327,7 +329,7 @@ void create_rr_graph(const t_graph_type graph_type,
                          router_opts.read_rr_edge_metadata,
                          router_opts.do_check_rr_graph);
 
-            reorder_rr_graph_nodes(router_opts);
+            mutable_device_ctx.rr_graph_builder.reorder_rr_graph_nodes(router_opts);
         }
     } else {
         if (channel_widths_unchanged(device_ctx.chan_width, nodes_per_chan) && !device_ctx.rr_nodes.empty()) {
@@ -357,7 +359,7 @@ void create_rr_graph(const t_graph_type graph_type,
                        directs, num_directs,
                        &det_routing_arch->wire_to_rr_ipin_switch,
                        Warnings);
-        reorder_rr_graph_nodes(router_opts);
+        mutable_device_ctx.rr_graph_builder.reorder_rr_graph_nodes(router_opts);
     }
 
     process_non_config_sets();

vpr/src/route/rr_graph_util.cpp

@@ -83,91 +83,6 @@ int seg_index_of_sblock(int from_node, int to_node) {
     }
 }
 
-// Reorder RRNodeId's using one of these algorithms:
-//   - DONT_REORDER: The identity reordering (does nothing.)
-//   - DEGREE_BFS: Order by degree primarily, and BFS traversal order secondarily.
-//   - RANDOM_SHUFFLE: Shuffle using the specified seed. Great for testing.
-// The DEGREE_BFS algorithm was selected because it had the best performance of seven
-// existing algorithms here: https://github.com/SymbiFlow/vtr-rrgraph-reordering-tool
-// It might be worth further research, as the DEGREE_BFS algorithm is simple and
-// makes some arbitrary choices, such as the starting node.
-// Nonetheless, it does improve performance ~7% for the SymbiFlow Xilinx Artix 7 graph.
-//
-// NOTE: Re-ordering will invalidate any references to rr_graph nodes, so this
-//       should generally be called before creating such references.
-void reorder_rr_graph_nodes(const t_router_opts& router_opts) {
-    auto& device_ctx = g_vpr_ctx.mutable_device();
-    auto& graph = device_ctx.rr_nodes;
-    auto& rr_graph = device_ctx.rr_graph;
-    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");
-
-    vtr::vector<RRNodeId, RRNodeId> src_order(v_num); // new id -> old id
-    size_t cur_idx = 0;
-    for (RRNodeId& n : src_order) { // Initialize to [0, 1, 2 ...]
-        n = RRNodeId(cur_idx++);
-    }
-
-    // This method works well. The intution is that highly connected nodes are enumerated first (together),
-    // and since there will be a lot of nodes with the same degree, they are then ordered based on some
-    // distance from the starting node.
-    if (router_opts.reorder_rr_graph_nodes_algorithm == DEGREE_BFS) {
-        vtr::vector<RRNodeId, size_t> bfs_idx(v_num);
-        vtr::vector<RRNodeId, size_t> degree(v_num);
-        std::queue<RRNodeId> que;
-
-        // Compute both degree (in + out) and an index based on the BFS traversal
-        cur_idx = 0;
-        for (size_t i = 0; i < v_num; ++i) {
-            if (bfs_idx[RRNodeId(i)]) continue;
-            que.push(RRNodeId(i));
-            bfs_idx[RRNodeId(i)] = cur_idx++;
-            while (!que.empty()) {
-                RRNodeId u = que.front();
-                que.pop();
-                degree[u] += graph.num_edges(u);
-                for (RREdgeId edge = rr_graph.node_first_edge(u); edge < rr_graph.node_last_edge(u); edge = RREdgeId(size_t(edge) + 1)) {
-                    RRNodeId v = graph.edge_sink_node(edge);
-                    degree[v]++;
-                    if (bfs_idx[v]) continue;
-                    bfs_idx[v] = cur_idx++;
-                    que.push(v);
-                }
-            }
-        }
-
-        // Sort by degree primarily, and BFS order secondarily
-        sort(src_order.begin(), src_order.end(),
-             [&](auto a, auto b) -> bool {
-                 auto deg_a = degree[a];
-                 auto deg_b = degree[b];
-                 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::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);
-    cur_idx = 0;
-    for (auto u : src_order)
-        dest_order[u] = RRNodeId(cur_idx++);
-
-    graph.reorder(dest_order, src_order);
-
-    device_ctx.rr_graph_builder.node_lookup().reorder(dest_order);
-
-    device_ctx.rr_node_metadata.remap_keys([&](int node) { return size_t(dest_order[RRNodeId(node)]); });
-    device_ctx.rr_edge_metadata.remap_keys([&](std::tuple<int, int, short> edge) {
-        return std::make_tuple(size_t(dest_order[RRNodeId(std::get<0>(edge))]),
-                               size_t(dest_order[RRNodeId(std::get<1>(edge))]),
-                               std::get<2>(edge));
-    });
-}
-
 vtr::vector<RRNodeId, std::vector<RREdgeId>> get_fan_in_list() {
     auto& rr_nodes = g_vpr_ctx.device().rr_nodes;
 

vpr/src/route/rr_graph_util.h

@@ -7,7 +7,7 @@ int seg_index_of_cblock(t_rr_type from_rr_type, int to_node);
 
 int seg_index_of_sblock(int from_node, int to_node);
 
-void reorder_rr_graph_nodes(const t_router_opts& router_opts);
+//void reorder_rr_graph_nodes(const t_router_opts& router_opts);
 
 // This function generates and returns a vector indexed by RRNodeId
 // containing a list of fan-in edges for each node.