Merge branch 'rr_graph_interposer_cut' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into remove_node

Author: amin1377

libs/libarchfpga/src/device_grid.cpp

@@ -89,3 +89,19 @@ void DeviceGrid::count_instances() {
         }
     }
 }
+
+bool DeviceGrid::has_interposer_cuts() const {
+    for (const std::vector<int>& layer_h_cuts : horizontal_interposer_cuts_) {
+        if (!layer_h_cuts.empty()) {
+            return true;
+        }
+    }
+
+    for (const std::vector<int>& layer_v_cuts : vertical_interposer_cuts_) {
+        if (!layer_v_cuts.empty()) {
+            return true;
+        }
+    }
+
+    return false;
+}

libs/libarchfpga/src/device_grid.h

@@ -211,6 +211,11 @@ class DeviceGrid {
         return vertical_interposer_cuts_;
     }
 
+    /// Returns if the grid has any interposer cuts. You should use this function instead of
+    /// checking if get_horizontal/vertical_interposer_cuts is empty, since the return value
+    /// of those functions might look something like this: {{}} which is technically not empty.
+    bool has_interposer_cuts() const;
+
   private:
     /// @brief Counts the number of each tile type on each layer and store it in instance_counts_.
     /// It is called in the constructor.

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -9,6 +9,7 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <ranges>
 
 void t_rr_graph_storage::reserve_edges(size_t num_edges) {
     edge_src_node_.reserve(num_edges);
@@ -67,14 +68,16 @@ void t_rr_graph_storage::remove_edges(std::vector<RREdgeId>& rr_edges_to_remove)
     // Sort and make sure all edge indices are unique
     vtr::uniquify(rr_edges_to_remove);
     VTR_ASSERT_SAFE(std::is_sorted(rr_edges_to_remove.begin(), rr_edges_to_remove.end()));
+
+    // Make sure the edge indices are valid
+    VTR_ASSERT(static_cast<size_t>(rr_edges_to_remove.back()) <= edge_dest_node_.size());
 
     // Index of the last edge
     size_t edge_list_end = edge_dest_node_.size() - 1;
 
     // Iterate backwards through the list of indices we want to remove.
-    for (auto it = rr_edges_to_remove.rbegin(); it != rr_edges_to_remove.rend(); ++it) {
-        RREdgeId erase_idx = *it;
-
+    
+    for (RREdgeId erase_idx : std::ranges::reverse_view(rr_edges_to_remove)) {
         // Copy what's at the end of the list to the index we wanted to remove
         edge_dest_node_[erase_idx] = edge_dest_node_[RREdgeId(edge_list_end)];
         edge_src_node_[erase_idx] = edge_src_node_[RREdgeId(edge_list_end)];

libs/librrgraph/src/base/rr_graph_view.h

@@ -591,7 +591,7 @@ class RRGraphView {
      *
      * @note Iterating on the range returned by this function will not give you an RREdgeId, but instead gives you the index among a node's outgoing edges
      */
-    inline edge_idx_range edges(const RRNodeId& id) const {
+    inline edge_idx_range edges(RRNodeId id) const {
         return vtr::make_range(edge_idx_iterator(0), edge_idx_iterator(num_edges(id)));
     }
 
@@ -607,7 +607,7 @@ class RRGraphView {
     /**
      * @brief Return ID range for outgoing edges.
      */
-    inline edge_idx_range node_out_edges(const RRNodeId& id) const {
+    inline edge_idx_range node_out_edges(RRNodeId id) const {
         return vtr::make_range(edge_idx_iterator(0), edge_idx_iterator(num_edges(id)));
     }
 

vpr/src/route/rr_graph_generation/rr_graph.cpp

@@ -33,6 +33,7 @@
 #include "rr_graph_intra_cluster.h"
 #include "rr_graph_tile_nodes.h"
 #include "rr_graph_3d.h"
+#include "rr_graph_interposer.h"
 #include "rr_graph_timing_params.h"
 #include "check_rr_graph.h"
 #include "echo_files.h"
@@ -47,8 +48,6 @@
 #include "rr_types.h"
 #include "rr_node_indices.h"
 
-#include "interposer_cut.h"
-
 //#define VERBOSE
 //used for getting the exact count of each edge type and printing it to std out.
 
@@ -1671,14 +1670,15 @@ static std::function<void(t_chan_width*)> alloc_and_load_rr_graph(RRGraphBuilder
     }
 
     // If there are any interposer cuts, remove the edges and shorten the wires that cross interposer cut lines.
-    if (!grid.get_horizontal_interposer_cuts().empty() || !grid.get_vertical_interposer_cuts().empty()) {
+    if (grid.has_interposer_cuts()) {
         std::vector<RREdgeId> interposer_edges = mark_interposer_cut_edges_for_removal(rr_graph, grid);
         rr_graph_builder.remove_edges(interposer_edges);
 
         update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(rr_graph, grid, rr_graph_builder, sg_node_indices);
     }
 
-    // Add 2D scatter-gather link edges (the nodes have already been created at this point). These links are mostly used for interposer-crossing connections, but could also be used for other things.
+    // Add 2D scatter-gather link edges (the nodes have already been created at this point).
+    // These links are mostly used for interposer-crossing connections, but could also be used for other things.
     add_and_connect_non_3d_sg_links(rr_graph_builder, sg_links, sg_node_indices, chan_details_x, chan_details_y, num_seg_types_x, rr_edges_to_create);
     uniquify_edges(rr_edges_to_create);
     alloc_and_load_edges(rr_graph_builder, rr_edges_to_create);

vpr/src/route/rr_graph_generation/interposer_cut.cpp renamed to vpr/src/route/rr_graph_generation/rr_graph_interposer.cpp

@@ -1,4 +1,5 @@
 #include <cstddef>
+#include <utility>
 #include <vector>
 #include <algorithm>
 #include <ranges>
@@ -13,11 +14,82 @@
 #include "vpr_error.h"
 #include "vtr_assert.h"
 
-#include "interposer_cut.h"
+#include "rr_graph_interposer.h"
+
+// Static function declarations
+
+/**
+ * @brief Takes location of a source and a sink and determines wether it crosses cut_loc or not.
+ * For example, the interval (1, 4) is cut by 3, while it is not cut by 5 or 0.
+ */
+static bool should_cut(int src_loc, int sink_loc, int cut_loc);
+
+/**
+ * @brief Calculates the starting x point of node based on it's directionality.
+ */
+static short node_xstart(const RRGraphView& rr_graph, RRNodeId node);
+
+/**
+ * @brief Calculates the starting y point of node based on it's directionality.
+ */
+static short node_ystart(const RRGraphView& rr_graph, RRNodeId node);
 
 /**
- * @brief Takes location of a source and a sink and determines wether it crosses cut_loc or not. For example, the interval (1, 4) is cut by 3, while it is not cut by 5 or 0.
+ * @brief Update a CHANY node's bounding box in RRGraph and SpatialLookup entries.
+ * This function assumes that the channel node actually crosses the cut location and
+ * might not function correctly otherwise.
+ *
+ * This is a low level function, you should use cut_channel_node that wraps this up in a nicer API.
  */
+static void cut_chan_y_node(RRNodeId node,
+                            int x_low,
+                            int y_low,
+                            int x_high,
+                            int y_high,
+                            int layer,
+                            int ptc_num,
+                            int cut_loc_y,
+                            Direction node_direction,
+                            RRGraphBuilder& rr_graph_builder,
+                            RRSpatialLookup& spatial_lookup);
+
+/**
+ * @brief Update a CHANX node's bounding box in RRGraph and SpatialLookup entries.
+ * This function assumes that the channel node actually crosses the cut location and
+ * might not function correctly otherwise.
+ *
+ * This is a low level function, you should use cut_channel_node that wraps this up in a nicer API.
+ */
+static void cut_chan_x_node(RRNodeId node,
+                            int x_low,
+                            int y_low,
+                            int x_high,
+                            int y_high,
+                            int layer,
+                            int ptc_num,
+                            int cut_loc_x,
+                            Direction node_direction,
+                            RRGraphBuilder& rr_graph_builder,
+                            RRSpatialLookup& spatial_lookup);
+
+/**
+ * @brief Update a CHANX or CHANY node's bounding box in RRGraph and SpatialLookup entries if it crosses cut_loc
+ * 
+ * @param node Channel segment RR graph node that might cross the interposer cut line
+ * @param cut_loc location of vertical interposer cut line
+ * @param interposer_cut_type Type of the interposer cut line (Horizontal or vertical)
+ * @param sg_node_indices Sorted list of scatter-gather node IDs. We do not want to cut these nodes as they're allowed to cross an interposer cut line.
+ */
+static void cut_channel_node(RRNodeId node,
+                             int cut_loc,
+                             e_interposer_cut_type interposer_cut_type,
+                             const RRGraphView& rr_graph,
+                             RRGraphBuilder& rr_graph_builder,
+                             RRSpatialLookup& spatial_lookup,
+                             const std::vector<std::pair<RRNodeId, int>>& sg_node_indices);
+
+// Function definitions
+
 static bool should_cut(int src_loc, int sink_loc, int cut_loc) {
     int src_delta = src_loc - cut_loc;
     int sink_delta = sink_loc - cut_loc;
@@ -30,26 +102,28 @@ static bool should_cut(int src_loc, int sink_loc, int cut_loc) {
     }
 }
 
-/**
- * @brief Calculates the starting x point of node based on it's directionality.
- */
 static short node_xstart(const RRGraphView& rr_graph, RRNodeId node) {
+    e_rr_type node_type = rr_graph.node_type(node);
+    Direction node_direction = rr_graph.node_direction(node);
+    short node_xlow = rr_graph.node_xlow(node);
+    short node_xhigh = rr_graph.node_xhigh(node);
+
     // Return early for OPIN and IPIN types (Some BIDIR pins would trigger the assertion below)
-    if (rr_graph.node_type(node) == e_rr_type::OPIN || rr_graph.node_type(node) == e_rr_type::IPIN) {
-        VTR_ASSERT(rr_graph.node_xlow(node) == rr_graph.node_xhigh(node));
-        return rr_graph.node_xlow(node);
+    if (is_pin(node_type)) {
+        VTR_ASSERT(node_xlow == node_xhigh);
+        return node_xlow;
     }
 
-    switch (rr_graph.node_direction(node)) {
+    switch (node_direction) {
         case Direction::DEC:
-            return rr_graph.node_xhigh(node);
+            return node_xhigh;
 
         case Direction::INC:
-            return rr_graph.node_xlow(node);
+            return node_xlow;
 
         case Direction::NONE:
-            VTR_ASSERT(rr_graph.node_xlow(node) == rr_graph.node_xhigh(node));
-            return (rr_graph.node_xlow(node));
+            VTR_ASSERT(node_xlow == node_xhigh);
+            return (node_xlow);
 
         case Direction::BIDIR:
             VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Bidir node has no starting point.");
@@ -61,25 +135,27 @@ static short node_xstart(const RRGraphView& rr_graph, RRNodeId node) {
     }
 }
 
-/**
- * @brief Calculates the starting y point of node based on it's directionality.
- */
 static short node_ystart(const RRGraphView& rr_graph, RRNodeId node) {
+    e_rr_type node_type = rr_graph.node_type(node);
+    Direction node_direction = rr_graph.node_direction(node);
+    short node_ylow = rr_graph.node_ylow(node);
+    short node_yhigh = rr_graph.node_yhigh(node);
+
     // Return early for OPIN and IPIN types (Some BIDIR pins would trigger the assertion below)
-    if (rr_graph.node_type(node) == e_rr_type::OPIN || rr_graph.node_type(node) == e_rr_type::IPIN) {
-        return rr_graph.node_ylow(node);
+    if (is_pin(node_type)) {
+        return node_ylow;
     }
 
-    switch (rr_graph.node_direction(node)) {
+    switch (node_direction) {
         case Direction::DEC:
-            return rr_graph.node_yhigh(node);
+            return node_yhigh;
 
         case Direction::INC:
-            return rr_graph.node_ylow(node);
+            return node_ylow;
 
         case Direction::NONE:
-            VTR_ASSERT(rr_graph.node_ylow(node) == rr_graph.node_yhigh(node));
-            return (rr_graph.node_ylow(node));
+            VTR_ASSERT(node_ylow == node_yhigh);
+            return (node_ylow);
 
         case Direction::BIDIR:
             VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Bidir node has no starting point.");
@@ -136,14 +212,17 @@ std::vector<RREdgeId> mark_interposer_cut_edges_for_removal(const RRGraphView& r
     return edges_to_be_removed;
 }
 
-/**
- * @brief Update a CHANY node's bounding box in RRGraph and SpatialLookup entries.
- * This function assumes that the channel node actually crosses the cut location and
- * might not function correctly otherwise.
- *
- * This is a low level function, you should use cut_channel_node that wraps this up in a nicer API.
- */
-static void cut_chan_y_node(RRNodeId node, int x_low, int y_low, int x_high, int y_high, int layer, int ptc_num, int cut_loc_y, Direction node_direction, RRGraphBuilder& rr_graph_builder, RRSpatialLookup& spatial_lookup) {
+static void cut_chan_y_node(RRNodeId node,
+                            int x_low,
+                            int y_low,
+                            int x_high,
+                            int y_high,
+                            int layer,
+                            int ptc_num,
+                            int cut_loc_y,
+                            Direction node_direction,
+                            RRGraphBuilder& rr_graph_builder,
+                            RRSpatialLookup& spatial_lookup) {
     if (node_direction == Direction::INC) {
         // Anything above cut_loc_y shouldn't exist
         rr_graph_builder.set_node_coordinates(node, x_low, y_low, x_high, cut_loc_y);
@@ -165,14 +244,17 @@ static void cut_chan_y_node(RRNodeId node, int x_low, int y_low, int x_high, int
     }
 }
 
-/**
- * @brief Update a CHANX node's bounding box in RRGraph and SpatialLookup entries.
- * This function assumes that the channel node actually crosses the cut location and
- * might not function correctly otherwise.
- *
- * This is a low level function, you should use cut_channel_node that wraps this up in a nicer API.
- */
-static void cut_chan_x_node(RRNodeId node, int x_low, int y_low, int x_high, int y_high, int layer, int ptc_num, int cut_loc_x, Direction node_direction, RRGraphBuilder& rr_graph_builder, RRSpatialLookup& spatial_lookup) {
+static void cut_chan_x_node(RRNodeId node,
+                            int x_low,
+                            int y_low,
+                            int x_high,
+                            int y_high,
+                            int layer,
+                            int ptc_num,
+                            int cut_loc_x,
+                            Direction node_direction,
+                            RRGraphBuilder& rr_graph_builder,
+                            RRSpatialLookup& spatial_lookup) {
     if (node_direction == Direction::INC) {
         // Anything to the right of cut_loc_x shouldn't exist
         rr_graph_builder.set_node_coordinates(node, x_low, y_low, cut_loc_x, y_high);
@@ -194,15 +276,13 @@ static void cut_chan_x_node(RRNodeId node, int x_low, int y_low, int x_high, int
     }
 }
 
-/**
- * @brief Update a CHANX or CHANY node's bounding box in RRGraph and SpatialLookup entries if it crosses cut_loc
- * 
- * @param node Channel segment RR graph node that might cross the interposer cut line
- * @param cut_loc location of vertical interposer cut line
- * @param interposer_cut_type Type of the interposer cut line (Horizontal or vertical)
- * @param sg_node_indices Sorted list of scatter-gather node IDs. We do not want to cut these nodes as they're allowed to cross an interposer cut line.
- */
-static void cut_channel_node(RRNodeId node, int cut_loc, e_interposer_cut_type interposer_cut_type, const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, RRSpatialLookup& spatial_lookup, const std::vector<std::pair<RRNodeId, int>>& sg_node_indices) {
+static void cut_channel_node(RRNodeId node,
+                             int cut_loc,
+                             e_interposer_cut_type interposer_cut_type,
+                             const RRGraphView& rr_graph,
+                             RRGraphBuilder& rr_graph_builder,
+                             RRSpatialLookup& spatial_lookup,
+                             const std::vector<std::pair<RRNodeId, int>>& sg_node_indices) {
     constexpr auto node_indice_compare = [](RRNodeId l, RRNodeId r) noexcept { return size_t(l) < size_t(r); };
     bool is_sg_node = std::ranges::binary_search(std::views::keys(sg_node_indices), node, node_indice_compare);
     if (is_sg_node) {
@@ -239,7 +319,10 @@ static void cut_channel_node(RRNodeId node, int cut_loc, e_interposer_cut_type i
     }
 }
 
-void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(const RRGraphView& rr_graph, const DeviceGrid& grid, RRGraphBuilder& rr_graph_builder, const std::vector<std::pair<RRNodeId, int>>& sg_node_indices) {
+void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(const RRGraphView& rr_graph,
+                                                                             const DeviceGrid& grid,
+                                                                             RRGraphBuilder& rr_graph_builder,
+                                                                             const std::vector<std::pair<RRNodeId, int>>& sg_node_indices) {
 
     VTR_ASSERT(std::is_sorted(sg_node_indices.begin(), sg_node_indices.end()));
 
@@ -249,7 +332,8 @@ void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(con
             for (size_t x_loc = 0; x_loc < grid.width(); x_loc++) {
                 std::vector<RRNodeId> channel_nodes = spatial_lookup.find_channel_nodes(layer, x_loc, cut_loc_y, e_rr_type::CHANY);
                 for (RRNodeId node : channel_nodes) {
-                    cut_channel_node(node, cut_loc_y, e_interposer_cut_type::HORZ, rr_graph, rr_graph_builder, spatial_lookup, sg_node_indices);
+                    cut_channel_node(node, cut_loc_y, e_interposer_cut_type::HORZ,
+                                     rr_graph, rr_graph_builder, spatial_lookup, sg_node_indices);
                 }
             }
         }
@@ -258,7 +342,8 @@ void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(con
             for (size_t y_loc = 0; y_loc < grid.height(); y_loc++) {
                 std::vector<RRNodeId> channel_nodes = spatial_lookup.find_channel_nodes(layer, cut_loc_x, y_loc, e_rr_type::CHANX);
                 for (RRNodeId node : channel_nodes) {
-                    cut_channel_node(node, cut_loc_x, e_interposer_cut_type::VERT, rr_graph, rr_graph_builder, spatial_lookup, sg_node_indices);
+                    cut_channel_node(node, cut_loc_x, e_interposer_cut_type::VERT,
+                                     rr_graph, rr_graph_builder, spatial_lookup, sg_node_indices);
                 }
             }
         }

vpr/src/route/rr_graph_generation/interposer_cut.h renamed to vpr/src/route/rr_graph_generation/rr_graph_interposer.h

@@ -28,4 +28,7 @@ std::vector<RREdgeId> mark_interposer_cut_edges_for_removal(const RRGraphView& r
  * @param rr_graph_builder RRGraphBuilder, to modify the RRGraph.
  * @param sg_node_indices list of scatter-gather node IDs. We do not want to cut these nodes as they're allowed to cross an interposer cut line.
  */
-void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(const RRGraphView& rr_graph, const DeviceGrid& grid, RRGraphBuilder& rr_graph_builder, const std::vector<std::pair<RRNodeId, int>>& sg_node_indices);
+void update_interposer_crossing_nodes_in_spatial_lookup_and_rr_graph_storage(const RRGraphView& rr_graph,
+                                                                             const DeviceGrid& grid,
+                                                                             RRGraphBuilder& rr_graph_builder,
+                                                                             const std::vector<std::pair<RRNodeId, int>>& sg_node_indices);