[WIP] Adding Custom RR Graph Builder to OpenFPGA

.gitignore

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

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "libs/EXTERNAL/yosys-slang"]
 	path = libs/EXTERNAL/yosys-slang
 	url = https://github.com/povik/yosys-slang.git
+[submodule "libs/EXTERNAL/yaml-cpp"]
+	path = libs/EXTERNAL/yaml-cpp
+	url = https://github.com/jbeder/yaml-cpp.git

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/EXTERNAL/CMakeLists.txt

@@ -12,6 +12,7 @@ add_subdirectory(libsdcparse)
 add_subdirectory(libblifparse)
 add_subdirectory(libtatum)
 add_subdirectory(libcatch2)
+add_subdirectory(yaml-cpp)
 #add_subdirectory(parmys)
 
 #Proc numbers

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.cpp

@@ -31,10 +31,6 @@ vtr::vector<RRNodeId, std::vector<RREdgeId>>& RRGraphBuilder::node_in_edge_stora
     return node_in_edges_;
 }
 
-vtr::vector<RRNodeId, std::vector<short>>& RRGraphBuilder::node_ptc_storage() {
-    return node_tilable_track_nums_;
-}
-
 void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) {
     e_rr_type node_type = node_storage_.node_type(node);
     short node_ptc_num = node_storage_.node_ptc_num(node);
@@ -76,7 +72,6 @@ RRNodeId RRGraphBuilder::create_node(int layer, int x, int y, e_rr_type type, in
         node_side = side;
     }
     node_storage_.emplace_back();
-    node_tilable_track_nums_.emplace_back();
     RRNodeId new_node = RRNodeId(node_storage_.size() - 1);
     node_storage_.set_node_layer(new_node, layer, layer);
     node_storage_.set_node_type(new_node, type);
@@ -102,7 +97,6 @@ void RRGraphBuilder::clear() {
     node_lookup_.clear();
     node_storage_.clear();
     node_in_edges_.clear();
-    node_tilable_track_nums_.clear();
     rr_node_metadata_.clear();
     rr_edge_metadata_.clear();
     rr_segments_.clear();
@@ -232,58 +226,20 @@ std::vector<RREdgeId> RRGraphBuilder::node_in_edges(RRNodeId node) const {
 }
 
 void RRGraphBuilder::set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) {
-    VTR_ASSERT(size_t(node) < node_storage_.size());
-    std::vector<std::string> ptc_tokens = vtr::StringToken(ptc_str).split(",");
-    VTR_ASSERT(ptc_tokens.size() >= 1);
-    set_node_ptc_num(node, std::stoi(ptc_tokens[0]));
-    if (ptc_tokens.size() > 1) {
-        VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size());
-        node_tilable_track_nums_[node].resize(ptc_tokens.size());
-        for (size_t iptc = 0; iptc < ptc_tokens.size(); iptc++) {
-          node_tilable_track_nums_[node][iptc] = std::stoi(ptc_tokens[iptc]);
-        }
-    }
+    node_storage_.set_node_ptc_nums(node, ptc_str);
 }
 
 std::string RRGraphBuilder::node_ptc_nums_to_string(RRNodeId node) const {
-    if (node_tilable_track_nums_.empty()) {
-        return std::to_string(size_t(node_storage_.node_ptc_num(node)));
-    }
-    VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size());
-    if (node_tilable_track_nums_[node].empty()) {
-        return std::to_string(size_t(node_storage_.node_ptc_num(node)));
-    }
-    std::string ret;
-    for (size_t iptc = 0; iptc < node_tilable_track_nums_[node].size(); iptc++) {
-        ret += std::to_string(size_t(node_tilable_track_nums_[node][iptc])) + ",";
-    }
-    // Remove the last comma
-    ret.pop_back();
-    return ret;
+    return node_storage_.node_ptc_nums_to_string(node);
 }
 
 bool RRGraphBuilder::node_contain_multiple_ptc(RRNodeId node) const {
-    if (node_tilable_track_nums_.empty()) {
-        return false;
-    }
-    return node_tilable_track_nums_[node].size() > 1;
+    return node_storage_.node_contain_multiple_ptc(node);
 }
 
 void RRGraphBuilder::add_node_track_num(RRNodeId node, vtr::Point<size_t> node_offset, short track_id) {
-    VTR_ASSERT(size_t(node) < node_storage_.size());
-    VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size());
-    VTR_ASSERT_MSG(node_storage_.node_type(node) == e_rr_type::CHANX || node_storage_.node_type(node) == e_rr_type::CHANY, "Track number valid only for CHANX/CHANY RR nodes");
-
-    size_t node_length = std::abs(node_storage_.node_xhigh(node) - node_storage_.node_xlow(node))
-                       + std::abs(node_storage_.node_yhigh(node) - node_storage_.node_ylow(node));
-    if (node_length + 1 != node_tilable_track_nums_[node].size()) {
-        node_tilable_track_nums_[node].resize(node_length + 1);
-    }
-
-    size_t offset = node_offset.x() - node_storage_.node_xlow(node) + node_offset.y() - node_storage_.node_ylow(node);
-    VTR_ASSERT(offset < node_tilable_track_nums_[node].size());
-
-    node_tilable_track_nums_[node][offset] = track_id;
+    size_t node_offset_value = node_offset.x() - node_storage_.node_xlow(node) + node_offset.y() - node_storage_.node_ylow(node);
+    node_storage_.add_node_tilable_track_num(node, node_offset_value, track_id);
 }
 
 void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) {
@@ -309,8 +265,9 @@ void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) {
             // Routing channel nodes may have different ptc num 
             // Find the track ids using the x/y offset  
             if (e_rr_type::CHANX == node_type || e_rr_type::CHANY == node_type) {
-                ptc = (node_type == e_rr_type::CHANX) ? node_tilable_track_nums_[node][x - node_storage_.node_xlow(node)] : 
-                    node_tilable_track_nums_[node][y - node_storage_.node_ylow(node)];
+                const std::vector<short>& track_nums = node_storage_.node_tilable_track_nums(node);
+                ptc = (node_type == e_rr_type::CHANX) ? track_nums[x - node_storage_.node_xlow(node)] : 
+                      track_nums[y - node_storage_.node_ylow(node)];
                 node_lookup_.add_node(node, node_storage_.node_layer_low(node), x, y, node_type, ptc);
             }
         }

libs/librrgraph/src/base/rr_graph_builder.h

@@ -50,9 +50,6 @@ class RRGraphBuilder {
 
     /** @brief Return a writable object fo the incoming edge storage */
     vtr::vector<RRNodeId, std::vector<RREdgeId>>& node_in_edge_storage();
-
-    /** @brief Return a writable object of the node ptc storage (for tileable routing resource graph) */
-    vtr::vector<RRNodeId, std::vector<short>>& node_ptc_storage();
 
     /** @brief Return the size for rr_node_metadata */
     inline size_t rr_node_metadata_size() const {
@@ -351,6 +348,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. */
@@ -395,13 +404,6 @@ class RRGraphBuilder {
         return node_storage_.count_rr_switches(arch_switch_inf, arch_switch_fanins);
     }
 
-    /** @brief Unlock storage; required to modify an routing resource graph after edge is read */
-    inline void unlock_storage() {
-        node_storage_.edges_read_ = false;
-        node_storage_.partitioned_ = false;
-        node_storage_.clear_node_first_edge();
-    }
-
     /** @brief Reserve the lists of nodes, edges, switches etc. to be memory efficient.
      * This function is mainly used to reserve memory space inside RRGraph,
      * when adding a large number of nodes/edge/switches/segments,
@@ -420,11 +422,6 @@ class RRGraphBuilder {
     inline void resize_nodes(size_t size) {
         node_storage_.resize(size);
     }
-    /** @brief This function resize node ptc nums. Only used by RR graph I/O reader and writers. */
-    inline void resize_node_ptc_nums(size_t size) {
-        node_tilable_track_nums_.resize(size);
-    }
-
 
     /** @brief This function resize rr_switch to accomidate size RR Switch. */
     inline void resize_switches(size_t size) {
@@ -527,29 +524,6 @@ class RRGraphBuilder {
      */
     vtr::vector<RRNodeId, std::vector<RREdgeId>> node_in_edges_;
 
-    /** 
-     * @brief Extra ptc number for each routing resource node. 
-     * @note This is required by tileable routing resource graphs. The first index is the node id, and
-     * the second index is is the relative distance from the starting point of the node.
-     * @details 
-     * In a tileable routing architecture, routing tracks, e.g., CHANX and CHANY, follow a staggered organization.
-     * Hence, a routing track may appear in different routing channels, representing different ptc/track id.
-     * Here is an illustrative example of a X-direction routing track (CHANX) in INC direction, which is organized in staggered way.
-     *    
-     *  Coord(x,y) (1,0)   (2,0)   (3,0)     (4,0)       Another track (node)
-     *  ptc=0     ------>                              ------>
-     *                   \                            /
-     *  ptc=1             ------>                    /
-     *                           \                  /
-     *  ptc=2                     ------>          / 
-     *                                   \        /
-     *  ptc=3                             ------->
-     *           ^                               ^
-     *           |                               |
-     *     starting point                   ending point
-     */
-    vtr::vector<RRNodeId, std::vector<short>> node_tilable_track_nums_;
-
     /** @warning The Metadata should stay as an independent data structure from the rest of the internal data,
      *  e.g., node_lookup! */
     /* Metadata is an extra data on rr-nodes and edges, respectively, that is not used by vpr