Override edge attributes in RR graph

libs/libarchfpga/src/physical_types.h

@@ -1587,16 +1587,31 @@ enum class SegResType {
     NUM_RES_TYPES
 };
 
-constexpr std::array<const char*, static_cast<size_t>(SegResType::NUM_RES_TYPES)> RES_TYPE_STRING = {{"GCLK", "GENERAL"}}; //String versions of segment resource types
+/// String versions of segment resource types
+constexpr std::array<const char*, static_cast<size_t>(SegResType::NUM_RES_TYPES)> RES_TYPE_STRING{"GCLK", "GENERAL"};
 
+/// Defines the type of switch block used in FPGA routing.
 enum e_switch_block_type {
+    /// If the type is SUBSET, I use a Xilinx-like switch block where track i in one channel always
+    /// connects to track i in other channels.
     SUBSET,
+
+    /// If type is WILTON, I use a switch block where track i
+    /// does not always connect to track i in other channels.
+    /// See Steve Wilton, PhD Thesis, University of Toronto, 1996.
     WILTON,
+
+    /// The UNIVERSAL switch block is from Y. W. Chang et al, TODAES, Jan. 1996, pp. 80 - 101.
     UNIVERSAL,
+
+    /// The FULL switch block type allows for complete connectivity between tracks.
     FULL,
+
+    /// A CUSTOM switch block has also been added which allows a user to describe custom permutation functions and connection patterns.
+    /// See comment at top of SRC/route/build_switchblocks.c
     CUSTOM
 };
-typedef enum e_switch_block_type t_switch_block_type;
+
 enum e_Fc_type {
     ABSOLUTE,
     FRACTIONAL

libs/librrgraph/src/base/rr_graph_builder.h

@@ -239,7 +239,7 @@ class RRGraphBuilder {
 
     /** @brief Reserve the lists of edges to be memory efficient.
      * This function is mainly used to reserve memory space inside RRGraph,
-     * when adding a large number of edges in order to avoid memory fragements */
+     * when adding a large number of edges in order to avoid memory fragments */
     inline void reserve_edges(size_t num_edges) {
         node_storage_.reserve_edges(num_edges);
     }
@@ -264,6 +264,10 @@ class RRGraphBuilder {
         node_storage_.alloc_and_load_edges(rr_edges_to_create);
     }
 
+    inline void override_edge_switch(RREdgeId edge_id, RRSwitchId switch_id) {
+        node_storage_.override_edge_switch(edge_id, switch_id);
+    }
+
     /** @brief set_node_cost_index gets the index of cost data in the list of cost_indexed_data data structure
      * It contains the routing cost for different nodes in the RRGraph
      * when used in evaluate different routing paths
@@ -304,7 +308,7 @@ class RRGraphBuilder {
     /** @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,
-     * in order to avoid memory fragements */
+     * in order to avoid memory fragments */
     inline void reserve_nodes(size_t size) {
         node_storage_.reserve(size);
     }

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -536,10 +536,9 @@ void t_rr_graph_storage::partition_edges(const vtr::vector<RRSwitchId, t_rr_swit
     //    by assign_first_edges()
     //  - Edges within a source node have the configurable edges before the
     //    non-configurable edges.
-    std::stable_sort(
-        edge_sort_iterator(this, 0),
-        edge_sort_iterator(this, edge_src_node_.size()),
-        edge_compare_src_node_and_configurable_first(rr_switches));
+    std::stable_sort(edge_sort_iterator(this, 0),
+                     edge_sort_iterator(this, edge_src_node_.size()),
+                     edge_compare_src_node_and_configurable_first(rr_switches));
 
     partitioned_ = true;
 
@@ -548,6 +547,12 @@ void t_rr_graph_storage::partition_edges(const vtr::vector<RRSwitchId, t_rr_swit
     VTR_ASSERT_SAFE(validate(rr_switches));
 }
 
+void t_rr_graph_storage::override_edge_switch(RREdgeId edge_id, RRSwitchId switch_id) {
+    VTR_ASSERT_DEBUG(partitioned_);
+    VTR_ASSERT_DEBUG(remapped_edges_);
+    edge_switch_[edge_id] = (short)((size_t)switch_id);
+}
+
 t_edge_size t_rr_graph_storage::num_configurable_edges(RRNodeId id, const vtr::vector<RRSwitchId, t_rr_switch_inf>& rr_switches) const {
     VTR_ASSERT(!node_first_edge_.empty() && remapped_edges_);
 

libs/librrgraph/src/base/rr_graph_storage.h

@@ -448,7 +448,7 @@ class t_rr_graph_storage {
      *
      * The following methods implement an interface that appears to be
      * equivalent to the interface exposed by std::vector<t_rr_node>.
-     * This was done for backwards compability. See t_rr_node for more details.
+     * This was done for backwards compatibility. See t_rr_node for more details.
      *
      * Proxy methods:
      *
@@ -483,8 +483,8 @@ class t_rr_graph_storage {
      ***************************/
 
     /** @brief
-     * Makes room in storage for RRNodeId in amoritized O(1) fashion.
-     * This results in an allocation pattern similiar to what would happen
+     * Makes room in storage for RRNodeId in amortized O(1) fashion.
+     * This results in an allocation pattern similar to what would happen
      * if push_back(x) / emplace_back() were used if underlying storage
      * was not pre-allocated.
      */
@@ -616,8 +616,8 @@ class t_rr_graph_storage {
     void set_node_direction(RRNodeId, Direction new_direction);
 
     /** @brief
-     * Add a side to the node abbributes
-     * This is the function to use when you just add a new side WITHOUT reseting side attributes
+     * Add a side to the node attributes
+     * This is the function to use when you just add a new side WITHOUT resetting side attributes
      */
     void add_node_side(RRNodeId, e_side new_side);
 
@@ -707,9 +707,8 @@ class t_rr_graph_storage {
      *
      * init_fan_in does not need to be invoked before this method.
      */
-     size_t count_rr_switches(
-        const std::vector<t_arch_switch_inf>& arch_switch_inf,
-        t_arch_switch_fanin& arch_switch_fanins);
+     size_t count_rr_switches(const std::vector<t_arch_switch_inf>& arch_switch_inf,
+                             t_arch_switch_fanin& arch_switch_fanins);
 
     /** @brief Maps arch_switch_inf indicies to rr_switch_inf indicies.
      *
@@ -731,6 +730,8 @@ class t_rr_graph_storage {
      */
     void partition_edges(const vtr::vector<RRSwitchId, t_rr_switch_inf>& rr_switches);
 
+    void override_edge_switch(RREdgeId edge_id, RRSwitchId switch_id);
+
     /** @brief Validate that edge data is partitioned correctly.*/
     bool validate_node(RRNodeId node_id, const vtr::vector<RRSwitchId, t_rr_switch_inf>& rr_switches) const;
     bool validate(const vtr::vector<RRSwitchId, t_rr_switch_inf>& rr_switches) const;

libs/librrgraph/src/base/rr_graph_view.h

@@ -413,6 +413,10 @@ class RRGraphView {
         return node_storage_.edge_switch(id, iedge);
     }
 
+    inline short edge_switch(RREdgeId id) const {
+        return node_storage_.edge_switch(id);
+    }
+
     /** @brief Return the source node for the specified edge. 
     */
     inline RRNodeId edge_src_node(const RREdgeId edge_id) const {

libs/librrgraph/src/io/rr_graph_reader.cpp

@@ -19,6 +19,7 @@
 #include "rr_graph_uxsdcxx.h"
 
 #include <fstream>
+#include <unordered_set>
 
 #include "vtr_time.h"
 #include "pugixml.hpp"
@@ -29,6 +30,23 @@
 #    include "mmap_file.h"
 #endif
 
+/**
+ * @brief Parses a line from the RR edge attribute override file.
+ *
+ * @details Expected formats:
+ *          edge_id Tdel [R] [Cin] [Cout] [Cinternal]
+ *          (source_node_id, sink_node_id) Tdel [R] [Cin] [Cout] [Cinternal]
+ *          Attributes in [brackets] are optional.
+ *
+ * @param line The line to parse.
+ * @param overridden_values Parsed override values.
+ * @param rr_graph The RR graph for edge lookup using source-sink nodes.
+ * @return The RR edge whose attributes are to be overridden.
+ */
+static RREdgeId process_rr_edge_override(const std::string& line,
+                                         std::vector<float>& overridden_values,
+                                         const RRGraphView& rr_graph);
+
 /************************ Subroutine definitions ****************************/
 /* loads the given RR_graph file into the appropriate data structures
  * as specified by read_rr_graph_name. Set up correct routing data
@@ -38,6 +56,7 @@
  * parameters are a workaround to passing the data structures of DeviceContext. 
  * Needs a solution to reduce the number of parameters passed in.*/
 
+
 void load_rr_file(RRGraphBuilder* rr_graph_builder,
                   RRGraphView* rr_graph,
                   const std::vector<t_physical_tile_type>& physical_tile_types,
@@ -53,7 +72,7 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
                   int* wire_to_rr_ipin_switch,
                   int* wire_to_rr_ipin_switch_between_dice,
                   const char* read_rr_graph_name,
-                  std::string* read_rr_graph_filename,
+                  std::string* loaded_rr_graph_filename,
                   bool read_edge_metadata,
                   bool do_check_rr_graph,
                   bool echo_enabled,
@@ -74,7 +93,7 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
         wire_to_rr_ipin_switch_between_dice,
         do_check_rr_graph,
         read_rr_graph_name,
-        read_rr_graph_filename,
+        loaded_rr_graph_filename,
         read_edge_metadata,
         echo_enabled,
         echo_file_name,
@@ -115,3 +134,140 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
             read_rr_graph_name);
     }
 }
+
+static RREdgeId process_rr_edge_override(const std::string& line,
+                                         std::vector<float>& overridden_values,
+                                         const RRGraphView& rr_graph) {
+    std::istringstream iss(line);
+    char ch;
+    RREdgeId edge_id;
+
+    if (std::isdigit(line[0])) {
+        // Line starts with an integer
+        int first;
+        iss >> first;
+        edge_id = (RREdgeId)first;
+    } else if (line[0] == '(') {
+        // Line starts with (first, second)
+        int first, second;
+        iss >> ch >> first >> ch >> second >> ch;
+
+        RRNodeId src_node_id = RRNodeId(first);
+        RRNodeId sink_node_id = RRNodeId(second);
+
+        for (RREdgeId outgoing_edge_id : rr_graph.rr_nodes().edge_range(src_node_id)) {
+            if (rr_graph.rr_nodes().edge_sink_node(outgoing_edge_id) == sink_node_id) {
+                edge_id = outgoing_edge_id;
+                break;
+            }
+        }
+
+        if (!edge_id.is_valid()) {
+            VTR_LOG_ERROR("Couldn't find an edge connecting node %d to node %d\n", src_node_id, sink_node_id);
+        }
+
+    } else {
+        VTR_LOG_ERROR("Invalid line format:  %s\n", line.c_str());
+    }
+
+    float value;
+    while (iss >> value) {
+        overridden_values.push_back(value);
+    }
+
+    return edge_id;
+}
+
+struct t_rr_switch_inf_hash {
+    std::size_t operator()(const t_rr_switch_inf& s) const {
+        std::size_t seed = 0;
+
+        // Helper function for hashing
+        auto hash_combine = [&seed](auto&& val) {
+            seed ^= std::hash<std::decay_t<decltype(val)>>{}(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        };
+
+        // Combine all relevant fields
+        hash_combine(s.R);
+        hash_combine(s.Cin);
+        hash_combine(s.Cout);
+        hash_combine(s.Cinternal);
+        hash_combine(s.Tdel);
+        hash_combine(s.mux_trans_size);
+        hash_combine(s.buf_size);
+        hash_combine(static_cast<int>(s.power_buffer_type));
+        hash_combine(s.power_buffer_size);
+        hash_combine(s.intra_tile);
+        hash_combine(static_cast<int>(s.type()));
+
+        return seed;
+    }
+};
+
+struct t_rr_switch_inf_equal {
+    bool operator()(const t_rr_switch_inf& lhs, const t_rr_switch_inf& rhs) const {
+        return lhs.R == rhs.R &&
+               lhs.Cin == rhs.Cin &&
+               lhs.Cout == rhs.Cout &&
+               lhs.Cinternal == rhs.Cinternal &&
+               lhs.Tdel == rhs.Tdel &&
+               lhs.mux_trans_size == rhs.mux_trans_size &&
+               lhs.buf_size == rhs.buf_size &&
+               lhs.power_buffer_type == rhs.power_buffer_type &&
+               lhs.power_buffer_size == rhs.power_buffer_size &&
+               lhs.intra_tile == rhs.intra_tile &&
+               lhs.type() == rhs.type();
+    }
+};
+
+void load_rr_edge_overrides(std::string_view filename,
+                            RRGraphBuilder& rr_graph_builder,
+                            const RRGraphView& rr_graph) {
+    std::ifstream file(filename.data());
+    if (!file) {
+        VTR_LOG_ERROR("Failed to open the RR edge override file: %s\n", filename.data());
+    }
+
+    std::unordered_map<t_rr_switch_inf, RRSwitchId, t_rr_switch_inf_hash, t_rr_switch_inf_equal> unique_switch_info;
+    for (const auto& [rr_sw_idx, sw] : rr_graph.rr_switch().pairs()) {
+        unique_switch_info.insert({sw, rr_sw_idx});
+    }
+
+    std::string line;
+    std::vector<float> overridden_values;
+    bool firstLine = true;
+
+    while (std::getline(file, line)) {
+        if (firstLine) {
+            if (line.empty() || line[0] != '#') {
+                VTR_LOG_ERROR("Error: First line must start with #\n");
+            }
+            firstLine = false;
+            continue;  // Ignore first line
+        }
+
+
+        if (!line.empty()) {
+            overridden_values.clear();
+            RREdgeId edge_id = process_rr_edge_override(line, overridden_values, rr_graph);
+            RRSwitchId curr_switch_id = (RRSwitchId)rr_graph.edge_switch(edge_id);
+            t_rr_switch_inf switch_override_info = rr_graph.rr_switch_inf(curr_switch_id);
+
+            switch_override_info.Tdel = (overridden_values.size() >= 1) ? overridden_values[0] : switch_override_info.Tdel;
+            switch_override_info.R = (overridden_values.size() >= 2) ? overridden_values[1] : switch_override_info.R;
+            switch_override_info.Cin = (overridden_values.size() >= 3) ? overridden_values[2] : switch_override_info.Cin;
+            switch_override_info.Cout = (overridden_values.size() >= 4) ? overridden_values[3] : switch_override_info.Cout;
+            switch_override_info.Cinternal = (overridden_values.size() >= 5) ? overridden_values[4] : switch_override_info.Cinternal;
+
+            RRSwitchId new_switch_id;
+            auto it = unique_switch_info.find(switch_override_info);
+            if (it == unique_switch_info.end()) {
+                new_switch_id = rr_graph_builder.add_rr_switch(switch_override_info);
+                unique_switch_info.insert({switch_override_info, new_switch_id});
+            } else {
+                new_switch_id = it->second;
+            }
+            rr_graph_builder.override_edge_switch(edge_id, new_switch_id);
+        }
+    }
+}

libs/librrgraph/src/io/rr_graph_reader.h

@@ -28,11 +28,15 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
                   int* wire_to_rr_ipin_switch,
                   int* wire_to_rr_ipin_switch_between_dice,
                   const char* read_rr_graph_name,
-                  std::string* read_rr_graph_filename,
+                  std::string* loaded_rr_graph_filename,
                   bool read_edge_metadata,
                   bool do_check_rr_graph,
                   bool echo_enabled,
                   const char* echo_file_name,
                   bool is_flat);
 
+void load_rr_edge_overrides(std::string_view filename,
+                            RRGraphBuilder& rr_graph_builder,
+                            const RRGraphView& rr_graph);
+
 #endif /* RR_GRAPH_READER_H */