Flat router test

libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h

@@ -460,11 +460,13 @@ 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 enalbed, the types of the switches inside of the rr_graph are also
+        // added to the XML file. These types are not added the data structure that contain arch switch types. It's remained
+        // 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);
         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 || string_name.compare(0, 15, "Internal Switch") == 0) {
                 found_arch_name = true;
                 break;
             }

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++;
         }
-    }
-
 }
 
 

libs/libvtrcapnproto/map_lookahead.capnp

@@ -15,7 +15,4 @@ struct VprIntraClusterLookahead {
     pinNumSinks @1 :List(Int64);
     pinSinks @2 :List(Int64);
     pinSinkCosts @3 :List(VprMapCostEntry);
-    tileNumSinks @4 :List(Int64);
-    tileSinks @5 :List(Int64);
-    tileMinCosts @6 :List(VprMapCostEntry);
 }