Add interposer crossing wire cutting

AmirhosseinPoolad · AmirhosseinPoolad · commit bf156bfa14ed · 2025-11-06T17:53:20.000-05:00
diff --git a/libs/librrgraph/src/base/rr_graph_builder.h b/libs/librrgraph/src/base/rr_graph_builder.h
@@ -352,6 +352,10 @@ class RRGraphBuilder {
         node_storage_.alloc_and_load_edges(rr_edges_to_create);
     }
 
+    inline void remove_edges(std::vector<RREdgeId>& rr_edges_to_remove) {
+        node_storage_.remove_edges(rr_edges_to_remove);
+    }
+
     /** @brief Overrides the associated switch for a given edge by
      *         updating the edge to use the passed in switch. */
     inline void override_edge_switch(RREdgeId edge_id, RRSwitchId switch_id) {
diff --git a/libs/librrgraph/src/base/rr_graph_storage.cpp b/libs/librrgraph/src/base/rr_graph_storage.cpp
@@ -2,8 +2,10 @@
 #include "rr_graph_storage.h"
 #include "physical_types.h"
 #include "rr_graph_fwd.h"
+#include "vtr_assert.h"
 #include "vtr_error.h"
 #include "librrgraph_types.h"
+#include "vtr_util.h"
 
 #include <algorithm>
 #include <cstddef>
@@ -57,6 +59,33 @@ void t_rr_graph_storage::alloc_and_load_edges(const t_rr_edge_info_set* rr_edges
     }
 }
 
+void t_rr_graph_storage::remove_edges(std::vector<RREdgeId>& rr_edges_to_remove) {
+    size_t starting_edge_count = edge_dest_node_.size();
+
+    vtr::uniquify(rr_edges_to_remove);
+    
+    size_t edge_list_end = edge_dest_node_.size() - 1;
+    for (auto it = rr_edges_to_remove.rbegin(); it != rr_edges_to_remove.rend(); ++it) {
+        RREdgeId erase_idx = *it;
+
+        edge_dest_node_[erase_idx] = edge_dest_node_[RREdgeId(edge_list_end)];
+        edge_src_node_[erase_idx] = edge_src_node_[RREdgeId(edge_list_end)];
+        edge_switch_[erase_idx] = edge_switch_[RREdgeId(edge_list_end)];
+        edge_remapped_[erase_idx] = edge_remapped_[RREdgeId(edge_list_end)];
+
+        edge_list_end--;
+
+    }
+
+    edge_dest_node_.erase(edge_dest_node_.begin() + edge_list_end + 1, edge_dest_node_.end());
+    edge_src_node_.erase(edge_src_node_.begin() + edge_list_end + 1, edge_src_node_.end());
+    edge_switch_.erase(edge_switch_.begin() + edge_list_end + 1, edge_switch_.end());
+    edge_remapped_.erase(edge_remapped_.begin() + edge_list_end + 1, edge_remapped_.end());
+
+    VTR_ASSERT(edge_dest_node_.size() == (starting_edge_count - rr_edges_to_remove.size()));
+}
+
+
 void t_rr_graph_storage::assign_first_edges() {
     VTR_ASSERT(node_first_edge_.empty());
 
@@ -68,39 +97,42 @@ void t_rr_graph_storage::assign_first_edges() {
         edge_src_node_.end()));
 
     size_t node_id = 0;
-    size_t first_id = 0;
-    size_t second_id = 0;
+    size_t first_edge_id = 0;
+    size_t second_edge_id = 0;
+
     size_t num_edges = edge_src_node_.size();
     VTR_ASSERT(edge_dest_node_.size() == num_edges);
     VTR_ASSERT(edge_switch_.size() == num_edges);
     VTR_ASSERT(edge_remapped_.size() == num_edges);
+
     while (true) {
-        VTR_ASSERT(first_id < num_edges);
-        VTR_ASSERT(second_id < num_edges);
-        size_t current_node_id = size_t(edge_src_node_[RREdgeId(second_id)]);
+        VTR_ASSERT(first_edge_id < num_edges);
+        VTR_ASSERT(second_edge_id < num_edges);
+
+        size_t current_node_id = size_t(edge_src_node_[RREdgeId(second_edge_id)]);
         if (node_id < current_node_id) {
             // All edges belonging to node_id are assigned.
             while (node_id < current_node_id) {
                 // Store any edges belongs to node_id.
                 VTR_ASSERT(node_id < node_first_edge_.size());
-                node_first_edge_[RRNodeId(node_id)] = RREdgeId(first_id);
-                first_id = second_id;
+                node_first_edge_[RRNodeId(node_id)] = RREdgeId(first_edge_id);
+                first_edge_id = second_edge_id;
                 node_id += 1;
             }
 
             VTR_ASSERT(node_id == current_node_id);
-            node_first_edge_[RRNodeId(node_id)] = RREdgeId(second_id);
+            node_first_edge_[RRNodeId(node_id)] = RREdgeId(second_edge_id);
         } else {
-            second_id += 1;
-            if (second_id == num_edges) {
+            second_edge_id += 1;
+            if (second_edge_id == num_edges) {
                 break;
             }
         }
     }
 
     // All remaining nodes have no edges, set as such.
     for (size_t inode = node_id + 1; inode < node_first_edge_.size(); ++inode) {
-        node_first_edge_[RRNodeId(inode)] = RREdgeId(second_id);
+        node_first_edge_[RRNodeId(inode)] = RREdgeId(second_edge_id);
     }
 
     VTR_ASSERT_SAFE(verify_first_edges());
diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h
@@ -400,6 +400,11 @@ class t_rr_graph_storage {
         return vtr::StrongIdRange<RREdgeId>(first_edge(id), last_edge(id));
     }
 
+
+    inline vtr::StrongIdRange<RREdgeId> all_edges() const {
+        return vtr::StrongIdRange<RREdgeId>(RREdgeId(0), RREdgeId(edge_src_node_.size()));
+    }
+
     /** @brief Retrieve the RREdgeId for iedge'th edge in RRNodeId.
      *
      * This method should generally not be used, and instead first_edge and
@@ -776,6 +781,8 @@ class t_rr_graph_storage {
     /** @brief Adds a batch of edges.*/
     void alloc_and_load_edges(const t_rr_edge_info_set* rr_edges_to_create);
 
+    void remove_edges(std::vector<RREdgeId>& rr_edges_to_remove);
+
     /* Edge finalization methods */
 
     /** @brief Counts the number of rr switches needed based on fan in to support mux
diff --git a/libs/librrgraph/src/base/rr_graph_view.cpp b/libs/librrgraph/src/base/rr_graph_view.cpp
@@ -129,5 +129,3 @@ bool RRGraphView::validate_in_edges() const {
     }
     return true;
 }
-
-
diff --git a/libs/librrgraph/src/base/rr_graph_view.h b/libs/librrgraph/src/base/rr_graph_view.h
@@ -65,9 +65,11 @@
 #include "metadata_storage.h"
 #include "rr_node.h"
 #include "physical_types.h"
+#include "rr_node_types.h"
 #include "rr_spatial_lookup.h"
 #include "vtr_geometry.h"
 #include "rr_graph_utils.h"
+#include "vtr_range.h"
 
 class RRGraphView {
     /* -- Constructors -- */
@@ -584,14 +586,19 @@ class RRGraphView {
      * @example
      * RRGraphView rr_graph; // A dummy rr_graph for a short example
      * RRNodeId node; // A dummy node for a short example
-     * for (RREdgeId edge : rr_graph.edges(node)) {
+     * for (t_edge_size edge : rr_graph.edges(node)) {
      *     // Do something with the edge
      * }
      */
     inline edge_idx_range edges(const RRNodeId& id) const {
         return vtr::make_range(edge_idx_iterator(0), edge_idx_iterator(num_edges(id)));
     }
 
+    inline vtr::StrongIdRange<RREdgeId> all_edges() const {
+        return node_storage_.all_edges();
+    }
+
+
     /**
      * @brief Return ID range for outgoing edges.
      */
diff --git a/vpr/src/route/rr_graph_generation/interposer_cut.cpp b/vpr/src/route/rr_graph_generation/interposer_cut.cpp
@@ -0,0 +1,205 @@
+#include <cstddef>
+#include <vector>
+#include <algorithm>
+#include <ranges>
+
+#include "device_grid.h"
+#include "rr_graph_builder.h"
+#include "rr_graph_fwd.h"
+#include "rr_graph_view.h"
+#include "rr_node_types.h"
+#include "rr_spatial_lookup.h"
+#include "vtr_assert.h"
+#include "vtr_log.h"
+
+#include "interposer_cut.h"
+
+static bool should_cut_edge(int src_start_loc, int sink_start_loc, int cut_loc) {
+    int src_delta = src_start_loc - cut_loc;
+    int sink_delta = sink_start_loc - cut_loc;
+
+    // Same sign means that both sink and source are on the same side of this cut
+    if ((src_delta < 0 && sink_delta < 0) || (src_delta >= 0 && sink_delta >= 0)) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+static bool should_cut_node(int src_start_loc, int sink_start_loc, int cut_loc) {
+    int src_delta = src_start_loc - cut_loc;
+    int sink_delta = sink_start_loc - cut_loc;
+
+    // Same sign means that both sink and source are on the same side of this cut
+    if ((src_delta <= 0 && sink_delta <= 0) || (src_delta > 0 && sink_delta > 0)) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+static short node_xstart(const RRGraphView& rr_graph, RRNodeId 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);
+    }
+
+    switch (rr_graph.node_direction(node)) {
+        case Direction::DEC:
+            return rr_graph.node_xhigh(node);
+            break;
+
+        case Direction::INC:
+            return rr_graph.node_xlow(node);
+            break;
+
+        case Direction::NONE:
+            VTR_ASSERT(rr_graph.node_xlow(node) == rr_graph.node_xhigh(node));
+            return (rr_graph.node_xlow(node));
+            break;
+
+        case Direction::BIDIR:
+            VTR_ASSERT_MSG(false, "Bidir node has no starting point");
+            break;
+
+        default:
+            VTR_ASSERT(false);
+            break;
+    }
+}
+
+static short node_ystart(const RRGraphView& rr_graph, RRNodeId 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);
+    }
+
+    switch (rr_graph.node_direction(node)) {
+        case Direction::DEC:
+            return rr_graph.node_yhigh(node);
+            break;
+
+        case Direction::INC:
+            return rr_graph.node_ylow(node);
+            break;
+
+        case Direction::NONE:
+            VTR_ASSERT(rr_graph.node_ylow(node) == rr_graph.node_yhigh(node));
+            return (rr_graph.node_ylow(node));
+            break;
+
+        case Direction::BIDIR:
+            VTR_ASSERT_MSG(false, "Bidir node has no starting point");
+            break;
+
+        default:
+            VTR_ASSERT(false);
+            break;
+    }
+}
+
+std::vector<RREdgeId> mark_interposer_cut_edges_for_removal(const RRGraphView& rr_graph, const DeviceGrid& grid) {
+    std::vector<RREdgeId> edges_to_be_removed;
+
+    // Loop over all RREdgeIds and mark ones that cross a cutline to be removed
+
+    for (RREdgeId edge_id : rr_graph.all_edges()) {
+        RRNodeId src_node = rr_graph.edge_src_node(edge_id);
+        RRNodeId sink_node = rr_graph.edge_sink_node(edge_id);
+
+        if (src_node == RRNodeId(5866) && sink_node == RRNodeId(5604)) {
+            VTR_LOG("HI\n");
+        }
+
+        // TODO: ignoring chanz nodes for now
+        if (rr_graph.node_type(src_node) == e_rr_type::CHANZ || rr_graph.node_type(sink_node) == e_rr_type::CHANZ) {
+            continue;
+        }
+
+        VTR_ASSERT(rr_graph.node_layer_low(src_node) == rr_graph.node_layer_low(sink_node));
+        VTR_ASSERT(rr_graph.node_layer_low(src_node) == rr_graph.node_layer_high(src_node));
+        VTR_ASSERT(rr_graph.node_layer_low(sink_node) == rr_graph.node_layer_high(sink_node));
+
+        int layer = rr_graph.node_layer_low(src_node);
+
+        for (int cut_loc_y : grid.get_horizontal_interposer_cuts()[layer]) {
+            int src_start_loc_y = node_ystart(rr_graph, src_node);
+            int sink_start_loc_y = node_ystart(rr_graph, sink_node);
+
+            if (should_cut_edge(src_start_loc_y, sink_start_loc_y, cut_loc_y)) {
+                edges_to_be_removed.push_back(edge_id);
+            }
+        }
+
+        for (int cut_loc_x : grid.get_vertical_interposer_cuts()[layer]) {
+            int src_start_loc_x = node_xstart(rr_graph, src_node);
+            int sink_start_loc_x = node_xstart(rr_graph, sink_node);
+
+            if (should_cut_edge(src_start_loc_x, sink_start_loc_x, cut_loc_x)) {
+                edges_to_be_removed.push_back(edge_id);
+            }
+        }
+    }
+
+    return edges_to_be_removed;
+}
+
+// TODO: workshop a better name
+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()));
+    
+    RRSpatialLookup& spatial_lookup = rr_graph_builder.node_lookup();
+    size_t num_sg = 0;
+    for (size_t layer = 0; layer < grid.get_num_layers(); layer++) {
+        for (int cut_loc_y : grid.get_horizontal_interposer_cuts()[layer]) {
+            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) {
+                    
+                    bool is_sg_node = std::ranges::binary_search(std::views::keys(sg_node_indices), node, [](RRNodeId l, RRNodeId r) {return size_t(l) < size_t(r);});
+                    if (is_sg_node) {
+                        num_sg++;
+                        continue;
+                    }
+
+
+                    int x_high = rr_graph.node_xhigh(node);
+                    int x_low = rr_graph.node_xlow(node);
+                    VTR_ASSERT(x_high == x_low);
+                    int y_high = rr_graph.node_yhigh(node);
+                    int y_low = rr_graph.node_ylow(node);
+                    int ptc_num = rr_graph.node_ptc_num(node);
+                    
+                    
+                    // No need to cut 1-length wires
+                    if (y_high == y_low) {
+                        continue;
+                    }
+
+                    if (!should_cut_node(y_low, y_high, cut_loc_y)) {
+                        continue;
+                    }
+
+                    if (rr_graph.node_direction(node) == 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);
+
+                        // Do a loop from cut_loc_y to y_high and remove node from spatial lookup
+                        for (int y_loc = cut_loc_y + 1; y_loc <= y_high; y_loc++) {
+                            spatial_lookup.remove_node(node, layer, x_low, y_loc, e_rr_type::CHANY, ptc_num);
+                        }
+                    } else if (rr_graph.node_direction(node) == Direction::DEC) {
+                        // Anything below cut_loc_y shouldn't exist
+                        rr_graph_builder.set_node_coordinates(node, x_low, cut_loc_y + 1, x_high, y_high);
+
+                        // Do a loop from y_low to cut_loc_y and remove node from spatial lookup
+                        for (int y_loc = y_low; y_loc <= cut_loc_y; y_loc++) {
+                            spatial_lookup.remove_node(node, layer, x_low, y_loc, e_rr_type::CHANY, ptc_num);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/vpr/src/route/rr_graph_generation/interposer_cut.h b/vpr/src/route/rr_graph_generation/interposer_cut.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <vector>
+#include "rr_graph_fwd.h"
+#include "rr_graph_view.h"
+#include "device_grid.h"
+
+std::vector<RREdgeId> mark_interposer_cut_edges_for_removal(const RRGraphView& rr_graph, const DeviceGrid& grid);
+
+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);
diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp
diff --git a/vpr/src/route/rr_graph_generation/rr_graph.h b/vpr/src/route/rr_graph_generation/rr_graph.h
diff --git a/vpr/src/route/rr_graph_generation/rr_node_indices.cpp b/vpr/src/route/rr_graph_generation/rr_node_indices.cpp

Original file line number	Diff line number	Diff line change
`@@ -129,5 +129,3 @@ bool RRGraphView::validate_in_edges() const {`
`129`	`129`	`}`
`130`	`130`	`return true;`
`131`	`131`	`}`
`132`		`-`
`133`		`-`