Merge pull request #2324 from verilog-to-routing/flat_router_test

Flat router test

Author: amin1377

libs/libarchfpga/src/physical_types.h

@@ -1713,7 +1713,11 @@ struct t_arch_switch_inf {
  * mux_trans_size:  The area of each transistor in the segment's driving mux *
  *                  measured in minimum width transistor units               *
  * buf_size:  The area of the buffer. If set to zero, area should be         *
- *            calculated from R                                              */
+ *            calculated from R
+ * intra_tile: Indicate whether this rr_switch is a switch type used inside  *
+ *             clusters. These switch types are not specified in the         *
+ *             architecture description file and are added when flat router  *
+ *             is enabled                                                    */
 struct t_rr_switch_inf {
     float R = 0.;
     float Cin = 0.;
@@ -1726,6 +1730,8 @@ struct t_rr_switch_inf {
     e_power_buffer_type power_buffer_type = POWER_BUFFER_TYPE_UNDEFINED;
     float power_buffer_size = 0.;
 
+    bool intra_tile = false;
+
   public:
     //Returns the type of switch
     SwitchType type() const;

libs/librrgraph/src/base/rr_edge.h

@@ -3,9 +3,8 @@
 
 #include "rr_graph_fwd.h"
 
-/* TODO: MUST change the node id to RRNodeId before refactoring is finished! */
 struct t_rr_edge_info {
-    t_rr_edge_info(RRNodeId from, RRNodeId to, short type, bool is_remapped = false) noexcept
+    t_rr_edge_info(RRNodeId from, RRNodeId to, short type, bool is_remapped) noexcept
         : from_node(from)
         , to_node(to)
         , switch_type(type)

libs/librrgraph/src/base/rr_graph_builder.cpp

@@ -60,6 +60,14 @@ void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) {
     }
 }
 
+void RRGraphBuilder::init_edge_remap(bool val) {
+    node_storage_.init_edge_remap(val);
+}
+
+void RRGraphBuilder::clear_temp_storage() {
+    node_storage_.clear_temp_storage();
+}
+
 void RRGraphBuilder::clear() {
     node_lookup_.clear();
     node_storage_.clear();

libs/librrgraph/src/base/rr_graph_builder.h

@@ -129,6 +129,10 @@ class RRGraphBuilder {
      */
     void add_node_to_all_locs(RRNodeId node);
 
+    void init_edge_remap(bool val);
+
+    void clear_temp_storage();
+
     /** @brief Clear all the underlying data storage */
     void clear();
     /** @brief reorder all the nodes
@@ -216,10 +220,14 @@ class RRGraphBuilder {
         node_storage_.reserve_edges(num_edges);
     }
 
-    /** @brief emplace_back_edge; It add one edge. This method is efficient if reserve_edges was called with
-     * the number of edges present in the graph. */
-    inline void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch) {
-        node_storage_.emplace_back_edge(src, dest, edge_switch);
+    /** @brief emplace_back_edge It adds one edge. This method is efficient if reserve_edges was called with
+     * the number of edges present in the graph.
+     * @param remapped If true, it means the switch id (edge_switch) corresponds to rr switch id. Thus, when the remapped function is called to
+     * remap the arch switch id to rr switch id, the edge switch id of this edge shouldn't be changed. For example, when the intra-cluster graph
+     * is built and the rr-graph related to global resources are read from a file, this parameter is true since the intra-cluster switches are
+     * also listed in rr-graph file. So, we use that list to use the rr switch id instead of passing arch switch id for intra-cluster edges.*/
+    inline void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped) {
+        node_storage_.emplace_back_edge(src, dest, edge_switch, remapped);
     }
     /** @brief Append 1 more RR node to the RR graph. */
     inline void emplace_back() {

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -11,13 +11,13 @@ void t_rr_graph_storage::reserve_edges(size_t num_edges) {
     edge_remapped_.reserve(num_edges);
 }
 
-void t_rr_graph_storage::emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch) {
+void t_rr_graph_storage::emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped) {
     // Cannot mutate edges once edges have been read!
     VTR_ASSERT(!edges_read_);
     edge_src_node_.emplace_back(src);
     edge_dest_node_.emplace_back(dest);
     edge_switch_.emplace_back(edge_switch);
-    edge_remapped_.emplace_back(false);
+    edge_remapped_.emplace_back(remapped);
 }
 
 // Typical node to edge ratio.  This allows a preallocation guess for the edges
@@ -48,7 +48,8 @@ void t_rr_graph_storage::alloc_and_load_edges(const t_rr_edge_info_set* rr_edges
         emplace_back_edge(
             new_edge.from_node,
             new_edge.to_node,
-            new_edge.switch_type);
+            new_edge.switch_type,
+            new_edge.remapped);
     }
 }
 
@@ -398,17 +399,10 @@ void t_rr_graph_storage::init_fan_in() {
     //Reset all fan-ins to zero
     edges_read_ = true;
     node_fan_in_.resize(node_storage_.size(), 0);
-    // This array is used to avoid initializing fan-in of the nodes which are already seen.
-    // This would reduce the run-time of flat rr graph generation since this function is called twice.
-    seen_edge_.resize(edge_dest_node_.size(), false);
     node_fan_in_.shrink_to_fit();
-    seen_edge_.shrink_to_fit();
     //Walk the graph and increment fanin on all downstream nodes
     for(const auto& edge_id : edge_dest_node_.keys()) {
-        if(!seen_edge_[edge_id]) {
-            node_fan_in_[edge_dest_node_[edge_id]] += 1;
-            seen_edge_[edge_id] = true;
-        }
+        node_fan_in_[edge_dest_node_[edge_id]] += 1;
     }
 }
 
@@ -829,7 +823,6 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
         auto old_edge_dest_node = edge_dest_node_;
         auto old_edge_switch = edge_switch_;
         auto old_edge_remapped = edge_remapped_;
-        auto old_seen_edge = seen_edge_;
         RREdgeId cur_edge(0);
 
         // Reorder edges by source node
@@ -843,7 +836,6 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
                 edge_dest_node_[cur_edge] = order[old_edge_dest_node[e]];
                 edge_switch_[cur_edge] = old_edge_switch[e];
                 edge_remapped_[cur_edge] = old_edge_remapped[e];
-                seen_edge_[cur_edge] = old_seen_edge[e];
                 cur_edge = RREdgeId(size_t(cur_edge) + 1);
             }
         }

libs/librrgraph/src/base/rr_graph_storage.h

@@ -442,7 +442,6 @@ class t_rr_graph_storage {
         node_first_edge_.clear();
         node_fan_in_.clear();
         node_layer_.clear();
-        seen_edge_.clear();
         edge_src_node_.clear();
         edge_dest_node_.clear();
         edge_switch_.clear();
@@ -452,6 +451,18 @@ class t_rr_graph_storage {
         remapped_edges_ = false;
     }
 
+    // Clear the data structures that are mainly used during RR graph construction.
+    // After RR Graph is build, we no longer need these data structures.
+    void clear_temp_storage() {
+        edge_remapped_.clear();
+    }
+
+    // Clear edge_remap data structure, and then initialize it with the given value
+    void init_edge_remap(bool val) {
+        edge_remapped_.clear();
+        edge_remapped_.resize(edge_switch_.size(), val);
+    }
+
     // Shrink memory usage of the RR graph storage.
     //
     // Note that this will temporarily increase the amount of storage required
@@ -462,7 +473,6 @@ class t_rr_graph_storage {
         node_first_edge_.shrink_to_fit();
         node_fan_in_.shrink_to_fit();
         node_layer_.shrink_to_fit();
-        seen_edge_.shrink_to_fit();
         edge_src_node_.shrink_to_fit();
         edge_dest_node_.shrink_to_fit();
         edge_switch_.shrink_to_fit();
@@ -561,11 +571,18 @@ class t_rr_graph_storage {
     // Reserve at least num_edges in the edge backing arrays.
     void reserve_edges(size_t num_edges);
 
-    // Add one edge.  This method is efficient if reserve_edges was called with
-    // the number of edges present in the graph.  This method is still
-    // amortized O(1), like std::vector::emplace_back, but both runtime and
-    // peak memory usage will be higher if reallocation is required.
-    void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch);
+    /***
+     * @brief Add one edge.  This method is efficient if reserve_edges was called with
+     * the number of edges present in the graph.  This method is still
+     * amortized O(1), like std::vector::emplace_back, but both runtime and
+     * peak memory usage will be higher if reallocation is required.
+     * @param remapped This is used later in remap_rr_node_switch_indices to check whether an
+     * edge needs its switch ID remapped from the arch_sw_idx to rr_sw_idx.
+     * The difference between these two ids is because some switch delays depend on the fan-in
+     * of the node. Also, the information about switches is fly-weighted and are accessible with IDs. Thus,
+     * the number of rr switch types can be higher than the number of arch switch types.
+     */
+    void emplace_back_edge(RRNodeId src, RRNodeId dest, short edge_switch, bool remapped);
 
     // Adds a batch of edges.
     void alloc_and_load_edges(const t_rr_edge_info_set* rr_edges_to_create);
@@ -696,10 +713,24 @@ class t_rr_graph_storage {
     vtr::vector<RREdgeId, RRNodeId> edge_src_node_;
     vtr::vector<RREdgeId, RRNodeId> edge_dest_node_;
     vtr::vector<RREdgeId, short> edge_switch_;
+    /**
+     * The delay of certain switches specified in the architecture file depends on the number of inputs of the edge's sink node (pins or tracks).
+     * For example, in the case of a MUX switch, the delay increases as the number of inputs increases.
+     * During the construction of the RR Graph, switch IDs are assigned to the edges according to the order specified in the architecture file.
+     * These switch IDs are later used to retrieve information such as delay for each edge.
+     * This allows for effective fly-weighting of edge information.
+     *
+     * After building the RR Graph, we iterate over the nodes once more to store their fan-in.
+     * If a switch's characteristics depend on the fan-in of a node, a new switch ID is generated and assigned to the corresponding edge.
+     * This process is known as remapping.
+     * In this vector, we store information about which edges have undergone remapping.
+     * It is necessary to store this information, especially when flat-router is enabled.
+     * Remapping occurs when constructing global resources after placement and when adding intra-cluster resources after placement.
+     * Without storing this information, during subsequent remappings, it would be unclear whether the stored switch ID
+     * corresponds to the architecture ID or the RR Graph switch ID for an edge.
+    */
     vtr::vector<RREdgeId, bool> edge_remapped_;
 
-    vtr::vector<RREdgeId, bool> seen_edge_;
-
     /***************
      * State flags *
      ***************/

libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h

@@ -460,19 +460,23 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
         //
         // If the switch name is not present in the architecture, generate an
         // error.
+        // If the graph is written when flat-routing is enabled, the types of the switches inside of the rr_graph are also
+        // added to the XML file. These types are not added to the data structure that contain arch switch types. They are added to all_sw_inf under device context.
+        // It remains as a future work to remove the arch_switch_types and use all_sw info under device_ctx instead.
         bool found_arch_name = false;
         std::string string_name = std::string(name);
+        // The string name has the format of "Internal Switch/delay". So, I have to use compare to specify the portion I want to be compared.
+        bool is_internal_sw = string_name.compare(0, 15, "Internal Switch") == 0;
         for (const auto& arch_sw_inf: arch_switch_inf_) {
-            if (string_name == arch_sw_inf.name) {
-                string_name = arch_sw_inf.name;
+            if (string_name == arch_sw_inf.name || is_internal_sw) {
                 found_arch_name = true;
                 break;
             }
         }
         if (!found_arch_name) {
             report_error("Switch name '%s' not found in architecture\n", string_name.c_str());
         }
-
+        sw->intra_tile = is_internal_sw;
         sw->name = string_name;
     }
     inline const char* get_switch_name(const t_rr_switch_inf*& sw) final {
@@ -832,6 +836,7 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
     inline void finish_rr_nodes_node(int& /*inode*/) final {
     }
     inline size_t num_rr_nodes_node(void*& /*ctx*/) final {
+
         return rr_nodes_->size();
     }
     inline const t_rr_node get_rr_nodes_node(int n, void*& /*ctx*/) final {
@@ -923,7 +928,8 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
             bind.set_ignore();
         }
 
-        rr_graph_builder_->emplace_back_edge(RRNodeId(src_node), RRNodeId(sink_node), switch_id);
+        // The edge ids in the rr graph file are rr edge id not architecture edge id
+        rr_graph_builder_->emplace_back_edge(RRNodeId(src_node), RRNodeId(sink_node), switch_id, true);
         return bind;
     }
     inline void finish_rr_edges_edge(MetadataBind& bind) final {