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

Author: amin1377

.gitignore

@@ -160,3 +160,4 @@ cmake-build-release
 # Clangd
 #
 compile_commands.json
+.clangd

doc/src/arch/reference.rst

@@ -589,7 +589,6 @@ Grid Layout Example
 
     .. note:: Exactly one of the ``x`` or ``y`` attributes must be specified.
 
-    .. note:: Interposers are experimental and are currently not supported by VPR and using the related tags will not actually result in any changes to the flow.
     Defines an interposer cut for modelling 2.5D interposer-based architectures. An interposer cut will cut all connections at location 'loc' along the axis 'dim' Leaving the two sides completely unconnected.
     To reconnect the two sides, this tag can have multiple <interdie_wire> tags as children to specify the connection between the two sides.
 
@@ -2751,7 +2750,7 @@ The number of any additional wires or muxes created by scatter-gather specificat
     Overview of how scatter-gather patterns work. First, connections from a switchblock location are selected according to the specification.
     These selected connection are then muxed and passed through the scatter-gather node, which is typically a wire segment. The scatter-gather node then fans out or scatters in another switchblock location.
 
-.. note:: Scatter-Gather patterns are only supported for 3D architectures where the scatter-gather links are unidirectional. They are not currently supported in 2D architectures or with bidirectional sg_links.
+.. note:: Scatter-Gather patterns are only supported for uni-directional 3D and uni-directional 2D architectures. Bidirectional sg_links are not currently supported.
 
 When instantiated, a scatter-gather pattern gathers connections from a switchblock and passes the connection through a multiplexer and the scatter-gather node which is typically a wire segment, then scatters or fans out somewhere else in the device. These patterns can be used to define 3D switchblocks. An example is shown below:
 

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_builder.h

@@ -351,6 +351,18 @@ class RRGraphBuilder {
     inline void alloc_and_load_edges(const t_rr_edge_info_set* rr_edges_to_create) {
         node_storage_.alloc_and_load_edges(rr_edges_to_create);
     }
+    
+    /** @brief Removes a given list of RREdgeIds from the RR Graph.
+     * This method does not preserve the order of edges. If you're
+     * calling it after partition_edges has been called, you will
+     * need to call partition_edges again.
+     * This operation is O(#RR Graph edges) and should not be called frequently.
+     *
+     * @param rr_edges_to_remove list of RREdgeIds to be removed
+     */
+    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. */

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -2,11 +2,14 @@
 #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>
+#include <ranges>
 
 void t_rr_graph_storage::reserve_edges(size_t num_edges) {
     edge_src_node_.reserve(num_edges);
@@ -57,6 +60,50 @@ 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) {
+    VTR_ASSERT(!edges_read_);
+
+    size_t starting_edge_count = edge_dest_node_.size();
+
+    // 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 (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)];
+        edge_switch_[erase_idx] = edge_switch_[RREdgeId(edge_list_end)];
+        edge_remapped_[erase_idx] = edge_remapped_[RREdgeId(edge_list_end)];
+
+        // At this point we have no copies of what was at erase_idx and two copies of
+        // what was at the end of the list. If we make the list one element shorter,
+        // we end up with a list that has removed the element at erase_idx.
+        edge_list_end--;
+
+    }
+
+    // We have a new index to the end of the list, call erase on the elements past that index
+    // to update the std::vector and shrink the actual data structures.
+    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()));
+
+    partitioned_ = false;
+}
+
+
 void t_rr_graph_storage::assign_first_edges() {
     VTR_ASSERT(node_first_edge_.empty());
 
@@ -68,39 +115,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());

libs/librrgraph/src/base/rr_graph_storage.h

@@ -400,6 +400,14 @@ class t_rr_graph_storage {
         return vtr::StrongIdRange<RREdgeId>(first_edge(id), last_edge(id));
     }
 
+    /** @brief Returns a range of all edges in the RR Graph.
+     * This method does not depend on the edges being correctly
+     * sorted and can be used before partition_edges is called.
+     */
+    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 +784,16 @@ 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);
 
+    /** @brief Removes a given list of RREdgeIds from the RR Graph.
+     * This method does not preserve the order of edges. If you're
+     * calling it after partition_edges has been called, you will
+     * need to call partition_edges again.
+     * This operation is O(#RR Graph edges) and should not be called frequently.
+     *
+     * @param rr_edges_to_remove list of RREdgeIds to be removed
+     */
+    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
@@ -840,7 +858,7 @@ class t_rr_graph_storage {
         // Generic lambda that allocates a 'vec'-sized new vector with all elements set to default value,
         // then builds the new vector to have rearranged elements from 'vec' and finaly move the new vector
         // to replace vec. Essentially does a permutation on vec based on edge_indices.
-        auto array_rearrage = [&edge_indices] (auto& vec, auto default_value) {
+        auto array_rearrange = [&edge_indices] (auto& vec, auto default_value) {
 
             // Since vec could have any type, we need to figure out it's type to allocate new_vec.
             // The scary std::remove_reference stuff does exactly that. This does nothing other than building a new 'vec' sized vector.
@@ -858,10 +876,10 @@ class t_rr_graph_storage {
             vec = std::move(new_vec);
         };
 
-        array_rearrage(edge_src_node_, RRNodeId::INVALID());
-        array_rearrage(edge_dest_node_, RRNodeId::INVALID());
-        array_rearrage(edge_switch_, LIBRRGRAPH_UNDEFINED_VAL);
-        array_rearrage(edge_remapped_, false);
+        array_rearrange(edge_src_node_, RRNodeId::INVALID());
+        array_rearrange(edge_dest_node_, RRNodeId::INVALID());
+        array_rearrange(edge_switch_, LIBRRGRAPH_UNDEFINED_VAL);
+        array_rearrange(edge_remapped_, false);
     }
 
     /******************

libs/librrgraph/src/base/rr_graph_view.cpp

@@ -129,5 +129,3 @@ bool RRGraphView::validate_in_edges() const {
     }
     return true;
 }
-
-

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,18 +586,29 @@ 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
      * }
+     *
+     * @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)));
     }
 
+    /** @brief Returns a range of all edges in the RR Graph.
+     * This method does not depend on the edges begin correctly
+     * sorted and can be used before partition_edges is called.
+     */
+    inline vtr::StrongIdRange<RREdgeId> all_edges() const {
+        return node_storage_.all_edges();
+    }
+
+
     /**
      * @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/analytical_place/analytical_placement_flow.cpp

@@ -77,7 +77,7 @@ static void print_ap_netlist_stats(const APNetlist& netlist) {
  *  @param flat_placement_info    The flat placement information to be read.
  *  @param ap_netlist             The APNetlist that used to iterate over its blocks.
  *  @param prepacker              The Prepacker to get molecule of blocks in the ap_netlist.
- *  @param p_placement            The partial placement to be updated which is assumend
+ *  @param p_placement            The partial placement to be updated which is assumed
  * to be generated on ap_netlist or have the same blocks.
  */
 static void convert_flat_to_partial_placement(const FlatPlacementInfo& flat_placement_info, const APNetlist& ap_netlist, const Prepacker& prepacker, PartialPlacement& p_placement) {