Flat router test

libs/libarchfpga/src/physical_types.h

@@ -1688,7 +1688,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.;
@@ -1701,6 +1705,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.h

@@ -207,9 +207,12 @@ class RRGraphBuilder {
     }
 
     /** @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);
+     * the number of edges present in the graph.
+     * @param remapped If true, it means the switch don't need to be remapped later. Currently, this parameter is true for the switches
+     * that are being added after the rr graph is built. Currently, it is true for the edges of the intra-cluster
+     * resources.*/
+    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);
     }
 }
 

libs/librrgraph/src/base/rr_graph_storage.h

@@ -545,11 +545,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
+     * end needs to be remapped. This remapping is done to change the switch index from 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 flight-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);

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/dealy". 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 {
@@ -828,6 +832,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 {
@@ -919,7 +924,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 {

libs/libvtrcapnproto/intra_cluster_serdes.h

@@ -16,201 +16,64 @@
 #include "vpr_types.h"
 #include "router_lookahead_map_utils.h"
 
-
-void ToIntraClusterLookahead(std::unordered_map<t_physical_tile_type_ptr, util::t_ipin_primitive_sink_delays>& inter_tile_pin_primitive_pin_delay,
-                             std::unordered_map<t_physical_tile_type_ptr, std::unordered_map<int, util::Cost_Entry>>& tile_min_cost,
-                             const std::vector<t_physical_tile_type>& physical_tile_types,
-                             const VprIntraClusterLookahead::Reader& intra_cluster_lookahead_builder);
-
-void FromIntraClusterLookahead(VprIntraClusterLookahead::Builder& intra_cluster_lookahead_builder,
-                               const std::unordered_map<t_physical_tile_type_ptr, util::t_ipin_primitive_sink_delays>& inter_tile_pin_primitive_pin_delay,
-                               const std::unordered_map<t_physical_tile_type_ptr, std::unordered_map<int, util::Cost_Entry>>& tile_min_cost,
-                               const std::vector<t_physical_tile_type>& physical_tile_types);
-// Generic function to convert from Matrix capnproto message to vtr::NdMatrix.
-//
-// Template arguments:
-//  N = Number of matrix dimensions, must be fixed.
-//  CapType = Source capnproto message type that is a single element the
-//            Matrix capnproto message.
-//  CType = Target C++ type that is a single element of vtr::NdMatrix.
-//
-// Arguments:
-//  m_out = Target vtr::NdMatrix.
-//  m_in = Source capnproto message reader.
-//  copy_fun = Function to convert from CapType to CType.
-void ToIntraClusterLookahead(std::unordered_map<t_physical_tile_type_ptr, util::t_ipin_primitive_sink_delays>& inter_tile_pin_primitive_pin_delay,
-                             std::unordered_map<t_physical_tile_type_ptr, std::unordered_map<int, util::Cost_Entry>>& tile_min_cost,
-                             const std::vector<t_physical_tile_type>& physical_tile_types,
-                             const VprIntraClusterLookahead::Reader& intra_cluster_lookahead_builder) {
-
-    inter_tile_pin_primitive_pin_delay.clear();
-    tile_min_cost.clear();
-
-    int num_tile_types = intra_cluster_lookahead_builder.getPhysicalTileNumPins().size();
-    VTR_ASSERT(num_tile_types == (int)physical_tile_types.size());
-
-    std::vector<int> tile_num_pins(num_tile_types);
-    std::vector<int> tile_num_sinks(num_tile_types);
-
-    for (int tile_idx = 0; tile_idx < num_tile_types; tile_idx++) {
-        tile_num_pins[tile_idx] = intra_cluster_lookahead_builder.getPhysicalTileNumPins()[tile_idx];
-        tile_num_sinks[tile_idx] = intra_cluster_lookahead_builder.getTileNumSinks()[tile_idx];
-    }
-
-    int num_seen_sinks = 0;
-    int num_seen_pins = 0;
-    for(int tile_type_idx = 0; tile_type_idx < num_tile_types; tile_type_idx++) {
-        int cur_tile_num_pins = tile_num_pins[tile_type_idx];
-        t_physical_tile_type_ptr physical_type_ptr = &physical_tile_types[tile_type_idx];
-        inter_tile_pin_primitive_pin_delay[physical_type_ptr] = util::t_ipin_primitive_sink_delays(cur_tile_num_pins);
-        for(int pin_num = 0; pin_num < cur_tile_num_pins; pin_num++) {
-            inter_tile_pin_primitive_pin_delay[physical_type_ptr][pin_num].clear();
-            int pin_num_sinks = intra_cluster_lookahead_builder.getPinNumSinks()[num_seen_pins];
-            num_seen_pins++;
-            for(int sink_idx = 0; sink_idx < pin_num_sinks; sink_idx++) {
-                int sink_pin_num = intra_cluster_lookahead_builder.getPinSinks()[num_seen_sinks];
-                auto cost = intra_cluster_lookahead_builder.getPinSinkCosts()[num_seen_sinks];
-                inter_tile_pin_primitive_pin_delay[physical_type_ptr][pin_num].insert(std::make_pair(sink_pin_num,
-                                                                                                     util::Cost_Entry(cost.getDelay(), cost.getCongestion())));
-                num_seen_sinks++;
-            }
-
-
-        }
-    }
-
-    num_seen_sinks = 0;
-    for(int tile_type_idx = 0; tile_type_idx < num_tile_types; tile_type_idx++) {
-        int cur_tile_num_sinks = tile_num_sinks[tile_type_idx];
-        t_physical_tile_type_ptr physical_type_ptr = &physical_tile_types[tile_type_idx];
-        tile_min_cost[physical_type_ptr] = std::unordered_map<int, util::Cost_Entry>();
-        for(int sink_idx = 0; sink_idx < cur_tile_num_sinks; sink_idx++) {
-            int sink_num = intra_cluster_lookahead_builder.getTileSinks()[num_seen_sinks];
-            auto cost = intra_cluster_lookahead_builder.getTileMinCosts()[num_seen_sinks];
-            tile_min_cost[physical_type_ptr].insert(std::make_pair(sink_num,
-                                                                   util::Cost_Entry(cost.getDelay(), cost.getCongestion())));
-            num_seen_sinks++;
-
-        }
+template<typename CapElemType, typename ElemType>
+void toVector(std::vector<ElemType>& vec_out,
+              const typename capnp::List<CapElemType>::Reader& m_in,
+              const std::function<void(std::vector<ElemType>&,
+                                       int,
+                                       const ElemType&)>& copy_fun) {
+    int size = m_in.size();
+    vec_out.resize(size);
+    for(int idx = 0; idx < size; idx++) {
+        copy_fun(vec_out, idx, m_in[idx]);
     }
-
-
 }
 
-void FromIntraClusterLookahead(VprIntraClusterLookahead::Builder& intra_cluster_lookahead_builder,
-                               const std::unordered_map<t_physical_tile_type_ptr, util::t_ipin_primitive_sink_delays>& inter_tile_pin_primitive_pin_delay,
-                               const std::unordered_map<t_physical_tile_type_ptr, std::unordered_map<int, util::Cost_Entry>>& tile_min_cost,
-                               const std::vector<t_physical_tile_type>& physical_tile_types) {
-
-    ::capnp::List<int64_t>::Builder physical_tile_num_pin_arr_builder;
-    ::capnp::List<int64_t>::Builder pin_num_sink_arr_builder;
-    ::capnp::List<int64_t>::Builder pin_sink_arr_builder;
-    ::capnp::List<VprMapCostEntry>::Builder pin_sink_cost_builder;
-    ::capnp::List<int64_t>::Builder tile_num_sinks_builder;
-    ::capnp::List<int64_t>::Builder tile_sinks_builder;
-    ::capnp::List<VprMapCostEntry>::Builder tile_sink_min_cost_builder;
-
-    int num_tile_types = physical_tile_types.size();
-
-    physical_tile_num_pin_arr_builder = intra_cluster_lookahead_builder.initPhysicalTileNumPins(num_tile_types);
-
-    // Count the number of pins for each tile
-    {
-        int total_num_pin = 0;
-        for (const auto& tile_type : physical_tile_types) {
-            const auto tile_pin_primitive_delay = inter_tile_pin_primitive_pin_delay.find(&tile_type);
-            if (tile_pin_primitive_delay == inter_tile_pin_primitive_pin_delay.end()) {
-                physical_tile_num_pin_arr_builder.set(tile_type.index, 0);
-                continue;
-            }
-            int tile_num_pins = tile_pin_primitive_delay->second.size();
-            physical_tile_num_pin_arr_builder.set(tile_type.index, tile_num_pins);
-            total_num_pin += tile_num_pins;
-        }
-
-        pin_num_sink_arr_builder = intra_cluster_lookahead_builder.initPinNumSinks(total_num_pin);
-    }
-
-    // Count the number of sinks for each pin
-    {
-        int pin_num = 0;
-        int total_pin_num_sinks = 0;
-        for (const auto& tile_type : physical_tile_types) {
-            const auto tile_pin_primitive_delay = inter_tile_pin_primitive_pin_delay.find(&tile_type);
-            if (tile_pin_primitive_delay == inter_tile_pin_primitive_pin_delay.end()) {
-                continue;
-            }
-            for (const auto& pin : tile_pin_primitive_delay->second) {
-                int pin_num_sinks = pin.size();
-                pin_num_sink_arr_builder.set(pin_num, pin_num_sinks);
-                pin_num++;
-                total_pin_num_sinks += pin_num_sinks;
-            }
-        }
-
-        pin_sink_arr_builder = intra_cluster_lookahead_builder.initPinSinks(total_pin_num_sinks);
-        pin_sink_cost_builder = intra_cluster_lookahead_builder.initPinSinkCosts(total_pin_num_sinks);
-    }
-
-    // Iterate over sinks of each pin and store the cost of getting to the sink from the respective pin and the sink ptc number
-    {
-        int pin_flat_sink_idx = 0;
-        for (const auto& tile_type : physical_tile_types) {
-            const auto tile_pin_primitive_delay = inter_tile_pin_primitive_pin_delay.find(&tile_type);
-            if (tile_pin_primitive_delay == inter_tile_pin_primitive_pin_delay.end()) {
-                continue;
-            }
-            for (const auto& pin : tile_pin_primitive_delay->second) {
-                for (const auto& sink : pin) {
-                    pin_sink_arr_builder.set(pin_flat_sink_idx, sink.first);
-                    pin_sink_cost_builder[pin_flat_sink_idx].setDelay(sink.second.delay);
-                    pin_sink_cost_builder[pin_flat_sink_idx].setCongestion(sink.second.congestion);
-                    pin_flat_sink_idx++;
-                }
-            }
-        }
+template<typename CapKeyType, typename CapValType, typename KeyType, typename CostType>
+void toUnorderedMap(
+    std::unordered_map<KeyType, CostType>& map_in,
+    const int begin_flat_idx,
+    const int end_flat_idx,
+    const typename capnp::List<CapKeyType>::Reader& m_out_key,
+    const typename capnp::List<CapValType>::Reader& m_out_val,
+    const std::function<void(std::unordered_map<KeyType, CostType>&,
+                             const KeyType&,
+                             const typename CapValType::Reader&)>& copy_fun) {
+
+    for(int flat_idx = begin_flat_idx; flat_idx < end_flat_idx; flat_idx++) {
+        copy_fun(map_in, m_out_key[flat_idx], m_out_val[flat_idx]);
     }
+}
 
+template<typename CapElemType, typename ElemType>
+void fromVector(typename capnp::List<CapElemType>::Builder& m_out,
+                const std::vector<ElemType>& vec_in,
+                const std::function<void(typename capnp::List<CapElemType>::Builder&,
+                                         int,
+                                         const ElemType&)>& copy_fun) {
 
-    // Store the information related to tile_min cost
-
-    tile_num_sinks_builder = intra_cluster_lookahead_builder.initTileNumSinks(num_tile_types);
-
-    // Count the number of sinks for each tile
-    {
-        int tile_total_num_sinks = 0;
-        for (const auto& tile_type : physical_tile_types) {
-            const auto tile_min_cost_entry = tile_min_cost.find(&tile_type);
-            if (tile_min_cost_entry == tile_min_cost.end()) {
-                tile_num_sinks_builder.set(tile_type.index, 0);
-                continue;
-            }
-            int tile_num_sinks = (int)tile_min_cost_entry->second.size();
-            tile_num_sinks_builder.set(tile_type.index, tile_num_sinks);
-            tile_total_num_sinks += tile_num_sinks;
-        }
-
-        tile_sinks_builder = intra_cluster_lookahead_builder.initTileSinks(tile_total_num_sinks);
-        tile_sink_min_cost_builder = intra_cluster_lookahead_builder.initTileMinCosts(tile_total_num_sinks);
+    for(int idx = 0; idx < (int)vec_in.size(); idx++) {
+        copy_fun(m_out, idx, vec_in[idx]);
     }
+}
 
-    // Iterate over sinks of each tile and store the minimum cost to get to that sink and the sink ptc number
-    {
-        int pin_flat_sink_idx = 0;
-        for (const auto& tile_type : physical_tile_types) {
-            const auto tile_min_cost_entry = tile_min_cost.find(&tile_type);
-            if (tile_min_cost_entry == tile_min_cost.end()) {
-                continue;
-            }
-            for (const auto& sink : tile_min_cost_entry->second) {
-                tile_sinks_builder.set(pin_flat_sink_idx, sink.first);
-                tile_sink_min_cost_builder[pin_flat_sink_idx].setDelay(sink.second.delay);
-                tile_sink_min_cost_builder[pin_flat_sink_idx].setCongestion(sink.second.congestion);
-                pin_flat_sink_idx++;
-            }
+template<typename CapKeyType, typename CapValType, typename KeyType, typename CostType>
+void FromUnorderedMap(
+        typename capnp::List<CapKeyType>::Builder& m_out_key,
+        typename capnp::List<CapValType>::Builder& m_out_val,
+        const KeyType out_offset,
+        const std::unordered_map<KeyType, CostType>& map_in,
+        const std::function<void(typename capnp::List<CapKeyType>::Builder&,
+                                 typename capnp::List<CapValType>::Builder&,
+                                 int,
+                                 const KeyType&,
+                                 const CostType&)>& copy_fun) {
+
+        int flat_idx = out_offset;
+        for (const auto& entry : map_in) {
+            copy_fun(m_out_key, m_out_val, flat_idx, entry.first, entry.second);
+            flat_idx++;
         }
-    }
-
 }