update rr_switch_offset_inf when rr_switch is updated based on fanin data

Author: soheilshahrouz

libs/librrgraph/src/base/rr_graph_builder.h

@@ -336,7 +336,7 @@ class RRGraphBuilder {
         this->rr_switch_inf_.reserve(num_switches);
     }
     inline void reserve_switch_offse_info(size_t num_offsets) {
-        this->rr_switch_offset_inf_.resize(num_offsets);
+        this->rr_switch_offset_inf_.reserve(num_offsets);
     }
     /** @brief This function resize node storage to accomidate size RR nodes. */
     inline void resize_nodes(size_t size) {

libs/librrgraph/src/base/rr_graph_storage.cpp

@@ -873,6 +873,7 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
         auto old_edge_src_node = edge_src_node_;
         auto old_edge_dest_node = edge_dest_node_;
         auto old_edge_switch = edge_switch_;
+        auto old_edge_switch_offset_inf_ = edge_switch_offset_inf_;
         auto old_edge_remapped = edge_remapped_;
         RREdgeId cur_edge(0);
 
@@ -886,6 +887,7 @@ void t_rr_graph_storage::reorder(const vtr::vector<RRNodeId, RRNodeId>& order,
                 edge_src_node_[cur_edge] = order[old_edge_src_node[e]]; // == n?
                 edge_dest_node_[cur_edge] = order[old_edge_dest_node[e]];
                 edge_switch_[cur_edge] = old_edge_switch[e];
+                edge_switch_offset_inf_[cur_edge] = old_edge_switch_offset_inf_[e];
                 edge_remapped_[cur_edge] = old_edge_remapped[e];
                 cur_edge = RREdgeId(size_t(cur_edge) + 1);
             }

libs/librrgraph/src/base/rr_graph_view.h

@@ -419,12 +419,20 @@ class RRGraphView {
         return node_storage_.edge_switch(id, iedge);
     }
 
-    inline float edge_delay(RRNodeId id, t_edge_size iedge) const {
-        RREdgeId edge_id = node_storage_.edge_id(id, iedge);
+    inline short edge_switch(RREdgeId edge_id) const {
+        return node_storage_.edge_switch(edge_id);
+    }
+
+    inline float edge_delay(RREdgeId edge_id) const {
         RRSwitchOffsetInfoId switch_offset_inf_id = node_storage_.edge_switch_offset_inf(edge_id);
         return rr_switch_offset_inf_[switch_offset_inf_id].Tdel;
     }
 
+    inline float edge_delay(RRNodeId id, t_edge_size iedge) const {
+        RREdgeId edge_id = node_storage_.edge_id(id, iedge);
+        return edge_delay(edge_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_uxsdcxx_serializer.h

@@ -630,7 +630,7 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
         rr_switch_offset_inf_->reserve(rr_switch_inf_->size());
         std::ranges::transform(*rr_switch_inf_,
                                std::back_inserter(*rr_switch_offset_inf_),
-                               [](const t_rr_switch_inf& rr_sw) -> t_rr_switch_offset_inf {
+                               [](const t_rr_switch_inf& rr_sw) noexcept -> t_rr_switch_offset_inf  {
                                    return t_rr_switch_offset_inf{rr_sw};
                                });
     }

libs/librrgraph/src/io/rr_graph_writer.cpp

@@ -57,6 +57,7 @@ void write_rr_graph(RRGraphBuilder* rr_graph_builder,
         rr_graph_builder,
         rr_graph_view,
         &rr_graph_builder->rr_switch(),
+        &rr_graph_builder->rr_switch_offset_inf(),
         rr_indexed_data,
         rr_rc_data,
         arch_switch_inf,

vpr/src/route/router_lookahead_map.cpp

@@ -734,7 +734,8 @@ static void compute_tile_lookahead(std::unordered_map<int, util::t_ipin_primitiv
                          g_vpr_ctx.device().rr_indexed_data,
                          g_vpr_ctx.device().rr_rc_data,
                          rr_graph_builder.rr_segments(),
-                         rr_graph_builder.rr_switch()};
+                         rr_graph_builder.rr_switch(),
+                         rr_graph_builder.rr_switch_offset_inf()};
 
     util::t_ipin_primitive_sink_delays pin_delays = util::compute_intra_tile_dijkstra(rr_graph,
                                                                                       physical_tile,

vpr/src/route/rr_graph.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <utility>
 #include <vector>
+#include <fstream>
 #include "vtr_assert.h"
 
 #include "vtr_util.h"
@@ -890,6 +891,29 @@ void create_rr_graph(const t_graph_type graph_type,
                        echo_file_name,
                        is_flat);
     }
+    {
+        std::ofstream file1("switch_delay.txt");
+        std::ofstream file2("exact_delay.txt");
+
+        if (!file1.is_open() || !file2.is_open()) {
+            std::cerr << "Error opening files!" << std::endl;
+            return;
+        }
+
+        for (const RRNodeId driver_node : device_ctx.rr_graph.nodes()) {
+            for (const RREdgeId edge_id : device_ctx.rr_graph.edge_range(driver_node)) {
+                int i_switch = device_ctx.rr_graph.edge_switch(edge_id);
+                float edge_switch_delay = device_ctx.rr_graph.rr_switch_inf(RRSwitchId(i_switch)).Tdel;
+                float edge_exact_delay = device_ctx.rr_graph.edge_delay(edge_id);
+
+                file1 << size_t(edge_id) << " " << edge_switch_delay << "\n";
+                file2 << size_t(edge_id) << " " << edge_exact_delay << "\n";
+            }
+        }
+
+        file1.close();
+        file2.close();
+    }
 }
 
 static void add_intra_cluster_edges_rr_graph(RRGraphBuilder& rr_graph_builder,
@@ -1860,29 +1884,33 @@ void load_rr_switch_from_arch_switch(RRGraphBuilder& rr_graph_builder,
                                      int fanin,
                                      const float R_minW_nmos,
                                      const float R_minW_pmos) {
-    /* figure out, by looking at the arch switch's Tdel map, what the delay of the new
-     * rr switch should be */
-    double rr_switch_Tdel = arch_sw_inf.at(arch_switch_idx).Tdel(fanin);
+    const t_arch_switch_inf& arch_switch = arch_sw_inf.at(arch_switch_idx);
+    t_rr_switch_inf& rr_switch_to_be_updated = rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)];
+    t_rr_switch_offset_inf& rr_switch_offset_to_be_updated = rr_graph_builder.rr_switch_offset_inf()[RRSwitchOffsetInfoId (rr_switch_idx)];
 
     /* copy over the arch switch to rr_switch_inf[rr_switch_idx], but with the changed Tdel value */
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].set_type(arch_sw_inf.at(arch_switch_idx).type());
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].R = arch_sw_inf.at(arch_switch_idx).R;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].Cin = arch_sw_inf.at(arch_switch_idx).Cin;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].Cinternal = arch_sw_inf.at(arch_switch_idx).Cinternal;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].Cout = arch_sw_inf.at(arch_switch_idx).Cout;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].Tdel = rr_switch_Tdel;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].mux_trans_size = arch_sw_inf.at(arch_switch_idx).mux_trans_size;
-    if (arch_sw_inf.at(arch_switch_idx).buf_size_type == BufferSize::AUTO) {
+    rr_switch_to_be_updated.set_type(arch_switch.type());
+    rr_switch_to_be_updated.R = arch_switch.R;
+    rr_switch_to_be_updated.Cin = arch_switch.Cin;
+    rr_switch_to_be_updated.Cinternal = arch_switch.Cinternal;
+    rr_switch_to_be_updated.Cout = arch_switch.Cout;
+    /* figure out, by looking at the arch switch's Tdel map, what the delay of the new
+     * rr switch should be */
+    rr_switch_to_be_updated.Tdel = arch_switch.Tdel(fanin);
+    rr_switch_to_be_updated.mux_trans_size = arch_switch.mux_trans_size;
+    if (arch_switch.buf_size_type == BufferSize::AUTO) {
         //Size based on resistance
-        rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].buf_size = trans_per_buf(arch_sw_inf.at(arch_switch_idx).R, R_minW_nmos, R_minW_pmos);
+        rr_switch_to_be_updated.buf_size = trans_per_buf(arch_switch.R, R_minW_nmos, R_minW_pmos);
     } else {
-        VTR_ASSERT(arch_sw_inf.at(arch_switch_idx).buf_size_type == BufferSize::ABSOLUTE);
+        VTR_ASSERT(arch_switch.buf_size_type == BufferSize::ABSOLUTE);
         //Use the specified size
-        rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].buf_size = arch_sw_inf.at(arch_switch_idx).buf_size;
+        rr_switch_to_be_updated.buf_size = arch_switch.buf_size;
     }
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].name = arch_sw_inf.at(arch_switch_idx).name;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].power_buffer_type = arch_sw_inf.at(arch_switch_idx).power_buffer_type;
-    rr_graph_builder.rr_switch()[RRSwitchId(rr_switch_idx)].power_buffer_size = arch_sw_inf.at(arch_switch_idx).power_buffer_size;
+    rr_switch_to_be_updated.name = arch_switch.name;
+    rr_switch_to_be_updated.power_buffer_type = arch_switch.power_buffer_type;
+    rr_switch_to_be_updated.power_buffer_size = arch_switch.power_buffer_size;
+
+    rr_switch_offset_to_be_updated.Tdel = rr_switch_to_be_updated.Tdel;
 }
 
 /* switch indices of each rr_node original point into the global device_ctx.arch_switch_inf array.