Add edge_groups.{cpp,h}, pass context into set_device_context()

Author: HackerFoo

vpr/src/route/edge_groups.cpp

@@ -0,0 +1,107 @@
+#include "edge_groups.h"
+
+#include <stack>
+
+// Adds non-configurable (undirected) edge to be grouped.
+//
+// Returns true if this is a new edge.
+bool EdgeGroups::add_non_config_edge(int from_node, int to_node) {
+    return graph_[from_node].edges.insert(to_node).second && graph_[to_node].edges.insert(from_node).second;
+}
+
+// After add_non_config_edge has been called for all edges, create_sets
+// will form groups of nodes that are connected via non-configurable
+// edges.
+void EdgeGroups::create_sets() {
+    rr_non_config_node_sets_map_.clear();
+
+    // https://en.wikipedia.org/wiki/Component_(graph_theory)#Algorithms
+    std::vector<size_t> group_size;
+    for (auto& node : graph_) {
+        if (node.second.set == OPEN) {
+            node.second.set = group_size.size();
+            group_size.push_back(add_connected_group(node.second));
+        }
+    }
+
+    // Sanity check the node sets.
+    for (const auto& node : graph_) {
+        VTR_ASSERT(node.second.set != OPEN);
+        for (const auto& e : node.second.edges) {
+            int set = graph_[e].set;
+            VTR_ASSERT(set == node.second.set);
+        }
+    }
+
+    // Create compact set of sets.
+    rr_non_config_node_sets_map_.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]);
+    }
+    for (const auto& node : graph_) {
+        rr_non_config_node_sets_map_[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_) {
+        std::set<t_node_edge> edge_set;
+        std::set<int> node_set(nodes.begin(), nodes.end());
+
+        for (const auto& src : node_set) {
+            for (const auto& dest : graph_[src].edges) {
+                edge_set.emplace(t_node_edge(src, dest));
+            }
+        }
+
+        sets.node_sets.emplace(std::move(node_set));
+        sets.edge_sets.emplace(std::move(edge_set));
+    }
+
+    return 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_) {
+        rr_non_config_node_sets.emplace_back(std::move(item));
+    }
+
+    std::unordered_map<int, int> rr_node_to_non_config_node_set;
+    for (size_t set = 0; set < rr_non_config_node_sets.size(); ++set) {
+        for (const auto inode : rr_non_config_node_sets[set]) {
+            rr_node_to_non_config_node_set.insert(
+                std::make_pair(inode, set));
+        }
+    }
+
+    device_ctx.rr_non_config_node_sets = std::move(rr_non_config_node_sets);
+    device_ctx.rr_node_to_non_config_node_set = std::move(rr_node_to_non_config_node_set);
+}
+
+// Perform a DFS traversal marking everything reachable with the same set id
+size_t EdgeGroups::add_connected_group(const node_data& node) {
+    // stack contains nodes with edges to mark with node.set
+    // The set for each node must be set before pushing it onto the stack
+    std::stack<const node_data*> stack;
+    stack.push(&node);
+    size_t n = 1;
+    while (!stack.empty()) {
+        auto top = stack.top();
+        stack.pop();
+        for (auto e : top->edges) {
+            auto& next = graph_[e];
+            if (next.set != node.set) {
+                VTR_ASSERT(next.set == OPEN);
+                n++;
+                next.set = node.set;
+                stack.push(&next);
+            }
+        }
+    }
+    return n;
+}

vpr/src/route/edge_groups.h

@@ -0,0 +1,50 @@
+#ifndef EDGE_GROUPS_H
+#define EDGE_GROUPS_H
+
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+#include <cstddef>
+
+#include "vpr_types.h"
+#include "vpr_context.h"
+
+// Class for building a group of connected edges.
+class EdgeGroups {
+  public:
+    EdgeGroups() {}
+
+    // Adds non-configurable (undirected) edge to be grouped.
+    //
+    // Returns true if this is a new edge.
+    bool add_non_config_edge(int from_node, int to_node);
+
+    // After add_non_config_edge has been called for all edges, create_sets
+    // will form groups of nodes that are connected via non-configurable
+    // edges.
+    void create_sets();
+
+    // 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 output_sets();
+
+    // Set device context structures for non-configurable node sets.
+    void set_device_context(DeviceContext& device_ctx);
+
+  private:
+    struct node_data {
+        std::unordered_set<int> edges;
+        int set = OPEN;
+    };
+
+    // Perform a DFS traversal marking everything reachable with the same set id
+    size_t add_connected_group(const node_data& node);
+
+    // 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_;
+};
+
+#endif

vpr/src/route/rr_graph.cpp

@@ -4,7 +4,6 @@
 #include <ctime>
 #include <algorithm>
 #include <vector>
-#include <stack>
 #include "vtr_assert.h"
 
 #include "vtr_util.h"
@@ -34,6 +33,7 @@
 #include "rr_graph_reader.h"
 #include "router_lookahead_map.h"
 #include "rr_graph_clock.h"
+#include "edge_groups.h"
 
 #include "rr_types.h"
 
@@ -2956,111 +2956,6 @@ static int pick_best_direct_connect_target_rr_node(const t_rr_graph_storage& rr_
     return best_rr;
 }
 
-// Adds non-configurable (undirected) edge to be grouped.
-//
-// Returns true if this is a new edge.
-bool EdgeGroups::add_non_config_edge(int from_node, int to_node) {
-    return graph_[from_node].edges.insert(to_node).second && graph_[to_node].edges.insert(from_node).second;
-}
-
-// After add_non_config_edge has been called for all edges, create_sets
-// will form groups of nodes that are connected via non-configurable
-// edges.
-void EdgeGroups::create_sets() {
-    rr_non_config_node_sets_map_.clear();
-
-    // https://en.wikipedia.org/wiki/Component_(graph_theory)#Algorithms
-    std::vector<size_t> group_size;
-    for (auto& node : graph_) {
-        if (node.second.set == OPEN) {
-            node.second.set = group_size.size();
-            group_size.push_back(add_connected_group(node.second));
-        }
-    }
-
-    // Sanity check the node sets.
-    for (const auto& node : graph_) {
-        VTR_ASSERT(node.second.set != OPEN);
-        for (const auto& e : node.second.edges) {
-            int set = graph_[e].set;
-            VTR_ASSERT(set == node.second.set);
-        }
-    }
-
-    // Create compact set of sets.
-    rr_non_config_node_sets_map_.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]);
-    }
-    for (const auto& node : graph_) {
-        rr_non_config_node_sets_map_[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_) {
-        std::set<t_node_edge> edge_set;
-        std::set<int> node_set(nodes.begin(), nodes.end());
-
-        for (const auto& src : node_set) {
-            for (const auto& dest : graph_[src].edges) {
-                edge_set.emplace(t_node_edge(src, dest));
-            }
-        }
-
-        sets.node_sets.emplace(std::move(node_set));
-        sets.edge_sets.emplace(std::move(edge_set));
-    }
-
-    return sets;
-}
-
-// Set device context structures for non-configurable node sets.
-void EdgeGroups::set_device_context() {
-    std::vector<std::vector<int>> rr_non_config_node_sets;
-    for (const auto& item : rr_non_config_node_sets_map_) {
-        rr_non_config_node_sets.emplace_back(std::move(item));
-    }
-
-    std::unordered_map<int, int> rr_node_to_non_config_node_set;
-    for (size_t set = 0; set < rr_non_config_node_sets.size(); ++set) {
-        for (const auto inode : rr_non_config_node_sets[set]) {
-            rr_node_to_non_config_node_set.insert(
-                std::make_pair(inode, set));
-        }
-    }
-
-    auto& device_ctx = g_vpr_ctx.mutable_device();
-    device_ctx.rr_non_config_node_sets = std::move(rr_non_config_node_sets);
-    device_ctx.rr_node_to_non_config_node_set = std::move(rr_node_to_non_config_node_set);
-}
-
-// Perform a DFS traversal marking everything reachable with the same set id
-size_t EdgeGroups::add_connected_group(const node_data& node) {
-    // stack contains nodes with edges to mark with node.set
-    // The set for each node must be set before pushing it onto the stack
-    std::stack<const node_data*> stack;
-    stack.push(&node);
-    size_t n = 1;
-    while (!stack.empty()) {
-        auto top = stack.top();
-        stack.pop();
-        for (auto e : top->edges) {
-            auto& next = graph_[e];
-            if (next.set != node.set) {
-                VTR_ASSERT(next.set == OPEN);
-                n++;
-                next.set = node.set;
-                stack.push(&next);
-            }
-        }
-    }
-    return n;
-}
-
 //Collects the sets of connected non-configurable edges in the RR graph
 static void create_edge_groups(EdgeGroups* groups) {
     auto& device_ctx = g_vpr_ctx.device();
@@ -3084,7 +2979,8 @@ t_non_configurable_rr_sets identify_non_configurable_rr_sets() {
 }
 
 static void process_non_config_sets() {
+    auto& device_ctx = g_vpr_ctx.mutable_device();
     EdgeGroups groups;
     create_edge_groups(&groups);
-    groups.set_device_context();
+    groups.set_device_context(device_ctx);
 }

vpr/src/route/rr_graph.h

@@ -55,44 +55,6 @@ void load_rr_switch_from_arch_switch(int arch_switch_idx,
                                      const float R_minW_nmos,
                                      const float R_minW_pmos);
 
-// Class for building a group of connected edges.
-class EdgeGroups {
-  public:
-    EdgeGroups() {}
-
-    // Adds non-configurable (undirected) edge to be grouped.
-    //
-    // Returns true if this is a new edge.
-    bool add_non_config_edge(int from_node, int to_node);
-
-    // After add_non_config_edge has been called for all edges, create_sets
-    // will form groups of nodes that are connected via non-configurable
-    // edges.
-    void create_sets();
-
-    // 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 output_sets();
-
-    // Set device context structures for non-configurable node sets.
-    void set_device_context();
-
-  private:
-    struct node_data {
-        std::unordered_set<int> edges;
-        int set = OPEN;
-    };
-
-    // Perform a DFS traversal marking everything reachable with the same set id
-    size_t add_connected_group(const node_data& node);
-
-    // 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_;
-};
-
 t_non_configurable_rr_sets identify_non_configurable_rr_sets();
 
 #endif

vpr/test/test_edge_groups.cpp

@@ -7,7 +7,7 @@
 
 #include "catch.hpp"
 
-#include "rr_graph.h"
+#include "edge_groups.h"
 
 namespace {