Refactor edge storage.

This changes edge storage from an allocation array of struct per node to
struct of array for all edge data.

Several algorithms over edges that were previous per node per edge, but
were actually just iteration over edges are now part of rr_node_storage.

Signed-off-by: Keith Rothman <[email protected]>

Author: litghost

vpr/src/base/vpr_types.h

@@ -1316,4 +1316,6 @@ class RouteStatus {
 
 typedef vtr::vector<ClusterBlockId, std::vector<std::vector<int>>> t_clb_opins_used; //[0..num_blocks-1][0..class-1][0..used_pins-1]
 
+typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
+
 #endif

vpr/src/route/rr_graph.cpp

@@ -67,8 +67,6 @@ struct t_pin_loc {
     e_side side;
 };
 
-typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
-
 /******************* Variables local to this module. ***********************/
 
 /********************* Subroutines local to this module. *******************/
@@ -822,44 +820,11 @@ static void alloc_and_load_rr_switch_inf(const int num_arch_switches, const floa
 static void alloc_rr_switch_inf(t_arch_switch_fanin& arch_switch_fanins) {
     auto& device_ctx = g_vpr_ctx.mutable_device();
 
-    int num_rr_switches = 0;
-    {
-        //Collect the fan-in per switch type for each node in the graph
-        //
-        //Note that since we don't store backward edge info in the RR graph we need to walk
-        //the whole graph to get the per-switch-type fanin info
-        std::vector<vtr::flat_map<int, int>> inward_switch_inf(device_ctx.rr_nodes.size()); //[to_node][arch_switch] -> fanin
-        for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
-            for (auto iedge : device_ctx.rr_nodes[inode].edges()) {
-                int iswitch = device_ctx.rr_nodes[inode].edge_switch(iedge);
-                int to_node = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
-
-                if (inward_switch_inf[to_node].count(iswitch) == 0) {
-                    inward_switch_inf[to_node][iswitch] = 0;
-                }
-                inward_switch_inf[to_node][iswitch]++;
-            }
-        }
-
-        //Record the unique switch type/fanin combinations
-        for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
-            for (auto& switch_fanin : inward_switch_inf[inode]) {
-                int iswitch, fanin;
-                std::tie(iswitch, fanin) = switch_fanin;
-
-                if (device_ctx.arch_switch_inf[iswitch].fixed_Tdel()) {
-                    //If delay is independent of fanin drop the unique fanin info
-                    fanin = UNDEFINED;
-                }
-
-                if (arch_switch_fanins[iswitch].count(fanin) == 0) {        //New fanin for this switch
-                    arch_switch_fanins[iswitch][fanin] = num_rr_switches++; //Assign it a unique index
-                }
-            }
-        }
-    }
-
     /* allocate space for the rr_switch_inf array */
+    size_t num_rr_switches = device_ctx.rr_nodes.count_rr_switches(
+        device_ctx.num_arch_switches,
+        device_ctx.arch_switch_inf,
+        arch_switch_fanins);
     device_ctx.rr_switch_inf.resize(num_rr_switches);
 }
 
@@ -930,27 +895,7 @@ void load_rr_switch_from_arch_switch(int arch_switch_idx,
 static void remap_rr_node_switch_indices(const t_arch_switch_fanin& switch_fanin) {
     auto& device_ctx = g_vpr_ctx.mutable_device();
 
-    for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
-        auto from_node = device_ctx.rr_nodes[inode];
-        int num_edges = from_node.num_edges();
-        for (int iedge = 0; iedge < num_edges; iedge++) {
-            const t_rr_node& to_node = device_ctx.rr_nodes[from_node.edge_sink_node(iedge)];
-            /* get the switch which this edge uses and its fanin */
-            int switch_index = from_node.edge_switch(iedge);
-            int fanin = to_node.fan_in();
-
-            if (switch_fanin[switch_index].count(UNDEFINED) == 1) {
-                fanin = UNDEFINED;
-            }
-
-            auto itr = switch_fanin[switch_index].find(fanin);
-            VTR_ASSERT(itr != switch_fanin[switch_index].end());
-
-            int rr_switch_index = itr->second;
-
-            from_node.set_edge_switch(iedge, rr_switch_index);
-        }
-    }
+    device_ctx.rr_nodes.remap_rr_node_switch_indices(switch_fanin);
 }
 
 static void rr_graph_externals(const std::vector<t_segment_inf>& segment_inf,
@@ -1324,7 +1269,7 @@ static std::function<void(t_chan_width*)> alloc_and_load_rr_graph(t_rr_node_stor
         };
     }
 
-    init_fan_in(L_rr_node, L_rr_node.size());
+    L_rr_node.init_fan_in();
 
     return update_chan_width;
 }
@@ -1481,9 +1426,6 @@ static void build_rr_sinks_sources(const int i,
              * leads to.  If route throughs are allowed, you may want to increase the  *
              * base cost of OPINs and/or SOURCES so they aren't used excessively.      */
 
-            /* Initialize to unconnected */
-            L_rr_node[inode].set_num_edges(0);
-
             L_rr_node[inode].set_cost_index(SINK_COST_INDEX);
             L_rr_node[inode].set_type(SINK);
         }
@@ -1555,24 +1497,6 @@ static void build_rr_sinks_sources(const int i,
     //Create the actual edges
 }
 
-void init_fan_in(t_rr_node_storage& L_rr_node, const int num_rr_nodes) {
-    //Loads fan-ins for all nodes
-
-    //Reset all fan-ins to zero
-    for (int i = 0; i < num_rr_nodes; i++) {
-        L_rr_node[i].set_fan_in(0);
-    }
-
-    //Walk the graph and increment fanin on all downstream nodes
-    for (int i = 0; i < num_rr_nodes; i++) {
-        for (t_edge_size iedge = 0; iedge < L_rr_node[i].num_edges(); iedge++) {
-            int to_node = L_rr_node[i].edge_sink_node(iedge);
-
-            L_rr_node[to_node].set_fan_in(L_rr_node[to_node].fan_in() + 1);
-        }
-    }
-}
-
 /* Allocates/loads edges for nodes belonging to specified channel segment and initializes
  * node properties such as cost, occupancy and capacity */
 static void build_rr_chan(const int x_coord,
@@ -1756,54 +1680,7 @@ void uniquify_edges(t_rr_edge_info_set& rr_edges_to_create) {
 
 void alloc_and_load_edges(t_rr_node_storage& L_rr_node,
                           const t_rr_edge_info_set& rr_edges_to_create) {
-    /* Sets up all the edge related information for rr_node */
-
-    struct compare_from_node {
-        auto operator()(const t_rr_edge_info& lhs, const int from_node) {
-            return lhs.from_node < from_node;
-        }
-        auto operator()(const int from_node, const t_rr_edge_info& rhs) {
-            return from_node < rhs.from_node;
-        }
-    };
-
-    std::set<int> from_nodes;
-    for (auto& edge : rr_edges_to_create) {
-        from_nodes.insert(edge.from_node);
-    }
-
-    VTR_ASSERT_SAFE(std::is_sorted(rr_edges_to_create.begin(), rr_edges_to_create.end()));
-
-    for (int inode : from_nodes) {
-        auto edge_range = std::equal_range(rr_edges_to_create.begin(), rr_edges_to_create.end(), inode, compare_from_node());
-
-        size_t edge_count = std::distance(edge_range.first, edge_range.second);
-
-        if (L_rr_node[inode].num_edges() == 0) {
-            //Create initial edges
-            //
-            //Note that we do this in bulk instead of via add_edge() to reduce
-            //memory fragmentation
-
-            L_rr_node[inode].set_num_edges(edge_count);
-
-            int iedge = 0;
-            for (auto itr = edge_range.first; itr != edge_range.second; ++itr) {
-                VTR_ASSERT(itr->from_node == inode);
-
-                L_rr_node[inode].set_edge_sink_node(iedge, itr->to_node);
-                L_rr_node[inode].set_edge_switch(iedge, itr->switch_type);
-                ++iedge;
-            }
-        } else {
-            //Add new edge incrementally
-            //
-            //This should occur relatively rarely (e.g. a backward bidir edge) so memory fragmentation shouldn't be a big problem
-            for (auto itr = edge_range.first; itr != edge_range.second; ++itr) {
-                L_rr_node[inode].add_edge(itr->to_node, itr->switch_type);
-            }
-        }
-    }
+    L_rr_node.alloc_and_load_edges(&rr_edges_to_create);
 }
 
 /* allocate pin to track map for each segment type individually and then combine into a single
@@ -2545,7 +2422,7 @@ std::string describe_rr_node(int inode) {
 
     std::string msg = vtr::string_fmt("RR node: %d", inode);
 
-    const auto& rr_node = device_ctx.rr_nodes[inode];
+    auto rr_node = device_ctx.rr_nodes[inode];
 
     msg += vtr::string_fmt(" type: %s", rr_node.type_string());
 

vpr/src/route/rr_graph.h

@@ -47,8 +47,6 @@ std::string describe_rr_node(int inode);
 
 class t_rr_node_storage;
 
-void init_fan_in(t_rr_node_storage& L_rr_node, const int num_rr_nodes);
-
 // Sets the spec for the rr_switch based on the arch switch
 void load_rr_switch_from_arch_switch(int arch_switch_idx,
                                      int rr_switch_idx,

vpr/src/route/rr_graph2.cpp

@@ -2582,9 +2582,5 @@ static bool should_apply_switch_override(int switch_override) {
 }
 
 void partition_rr_graph_edges(DeviceContext& device_ctx) {
-    for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
-        device_ctx.rr_nodes[inode].partition_edges();
-
-        VTR_ASSERT_SAFE(device_ctx.rr_nodes[inode].validate());
-    }
+    device_ctx.rr_nodes.partition_edges();
 }

vpr/src/route/rr_graph_reader.cpp

@@ -156,13 +156,17 @@ void load_rr_file(const t_graph_type graph_type,
         next_component = get_single_child(rr_graph, "rr_edges", loc_data);
         process_edges(next_component, loc_data, wire_to_rr_ipin_switch, numSwitches);
 
+        // Edge switch indicies were converted to rr_switch_inf indicies prior
+        // to being written.
+        device_ctx.rr_nodes.mark_edges_as_rr_switch_ids();
+
         //Partition the rr graph edges for efficient access to configurable/non-configurable
         //edge subsets. Must be done after RR switches have been allocated
         partition_rr_graph_edges(device_ctx);
 
         process_rr_node_indices(grid);
 
-        init_fan_in(device_ctx.rr_nodes, device_ctx.rr_nodes.size());
+        device_ctx.rr_nodes.init_fan_in();
 
         //sets the cost index and seg id information
         next_component = get_single_child(rr_graph, "rr_nodes", loc_data);
@@ -364,9 +368,6 @@ void process_nodes(pugi::xml_node parent, const pugiutil::loc_data& loc_data) {
         }
         node.set_rc_index(find_create_rr_rc_data(R, C));
 
-        //clear each node edge
-        node.set_num_edges(0);
-
         //  <metadata>
         //    <meta name='grid_prefix' >CLBLL_L_</meta>
         //  </metadata>
@@ -392,35 +393,15 @@ void process_edges(pugi::xml_node parent, const pugiutil::loc_data& loc_data, in
     auto& device_ctx = g_vpr_ctx.mutable_device();
     pugi::xml_node edges;
 
+    size_t num_edges = 0;
     edges = get_first_child(parent, "edge", loc_data);
-    //count the number of edges and store it in a vector
-    std::vector<size_t> num_edges_for_node;
-    num_edges_for_node.resize(device_ctx.rr_nodes.size(), 0);
-
     while (edges) {
-        size_t source_node = get_attribute(edges, "src_node", loc_data).as_uint();
-        if (source_node >= device_ctx.rr_nodes.size()) {
-            VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                            "source_node %d is larger than rr_nodes.size() %d",
-                            source_node, device_ctx.rr_nodes.size());
-        }
-
-        num_edges_for_node[source_node]++;
+        num_edges += 1;
         edges = edges.next_sibling(edges.name());
     }
 
-    //reset this vector in order to start count for num edges again
-    for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
-        if (num_edges_for_node[inode] > std::numeric_limits<t_edge_size>::max()) {
-            VPR_FATAL_ERROR(VPR_ERROR_OTHER,
-                            "source node %d edge count %d is too high",
-                            inode, num_edges_for_node[inode]);
-        }
-        device_ctx.rr_nodes[inode].set_num_edges(num_edges_for_node[inode]);
-        num_edges_for_node[inode] = 0;
-    }
-
     edges = get_first_child(parent, "edge", loc_data);
+
     /*initialize a vector that keeps track of the number of wire to ipin switches
      * There should be only one wire to ipin switch. In case there are more, make sure to
      * store the most frequent switch */
@@ -434,6 +415,12 @@ void process_edges(pugi::xml_node parent, const pugiutil::loc_data& loc_data, in
         size_t sink_node = get_attribute(edges, "sink_node", loc_data).as_uint();
         int switch_id = get_attribute(edges, "switch_id", loc_data).as_int();
 
+        if (source_node >= device_ctx.rr_nodes.size()) {
+            VPR_FATAL_ERROR(VPR_ERROR_OTHER,
+                            "sink_node %d is larger than rr_nodes.size() %d",
+                            sink_node, device_ctx.rr_nodes.size());
+        }
+
         if (sink_node >= device_ctx.rr_nodes.size()) {
             VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                             "sink_node %d is larger than rr_nodes.size() %d",
@@ -458,8 +445,7 @@ void process_edges(pugi::xml_node parent, const pugiutil::loc_data& loc_data, in
             }
         }
         //set edge in correct rr_node data structure
-        device_ctx.rr_nodes[source_node].set_edge_sink_node(num_edges_for_node[source_node], sink_node);
-        device_ctx.rr_nodes[source_node].set_edge_switch(num_edges_for_node[source_node], switch_id);
+        device_ctx.rr_nodes.emplace_back_edge(RRNodeId(source_node), RRNodeId(sink_node), switch_id);
 
         // Read the metadata for the edge
         auto metadata = get_single_child(edges, "metadata", loc_data, pugiutil::OPTIONAL);
@@ -474,12 +460,10 @@ void process_edges(pugi::xml_node parent, const pugiutil::loc_data& loc_data, in
                 edges_meta = edges_meta.next_sibling(edges_meta.name());
             }
         }
-        num_edges_for_node[source_node]++;
-
         edges = edges.next_sibling(edges.name()); //Next edge
     }
+
     *wire_to_rr_ipin_switch = most_frequent_switch.first;
-    num_edges_for_node.clear();
     count_for_wire_to_ipin_switches.clear();
 }