call edge_delay() instead of accessing switch delay

soheilshahrouz · soheilshahrouz · commit dd1df5c5457e · 2025-02-03T13:42:10.000-05:00
diff --git a/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.cpp b/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.cpp
@@ -70,8 +70,6 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
                                     enum e_base_cost_type base_cost_type,
                                     const bool echo_enabled,
                                     const char* echo_file_name) {
-    int length, i, index;
-
     (void)segment_inf;
     int total_num_segment = segment_inf_x.size() + segment_inf_y.size();
     /*CHAX & CHANY segment lsit sizes may differ. but if we're using uniform channels, they
@@ -85,7 +83,7 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
      * * other than base_cost are invalid. Mark invalid fields as OPEN for safety. */
 
     constexpr float nan = std::numeric_limits<float>::quiet_NaN();
-    for (i = SOURCE_COST_INDEX; i <= IPIN_COST_INDEX; i++) {
+    for (int i = SOURCE_COST_INDEX; i <= IPIN_COST_INDEX; i++) {
         rr_indexed_data[RRIndexedDataId(i)].ortho_cost_index = OPEN;
         rr_indexed_data[RRIndexedDataId(i)].seg_index = OPEN;
         rr_indexed_data[RRIndexedDataId(i)].inv_length = nan;
@@ -116,10 +114,11 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
     /* X-directed segments*/
 
     for (size_t iseg = 0; iseg < segment_inf_x.size(); ++iseg) {
-        index = iseg + CHANX_COST_INDEX_START;
+        int index = iseg + CHANX_COST_INDEX_START;
 
         rr_indexed_data[RRIndexedDataId(index)].ortho_cost_index = ortho_costs[iseg];
 
+        int length;
         if (segment_inf_x[iseg].longline)
             length = grid.width();
         else
@@ -134,9 +133,10 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
     /* Y-directed segments*/
 
     for (size_t iseg = segment_inf_x.size(); iseg < ortho_costs.size(); ++iseg) {
-        index = iseg + CHANX_COST_INDEX_START;
+        int index = iseg + CHANX_COST_INDEX_START;
         rr_indexed_data[RRIndexedDataId(index)].ortho_cost_index = ortho_costs[iseg];
 
+        int length;
         if (segment_inf_x[iseg - segment_inf_x.size()].longline)
             length = grid.width();
         else
@@ -171,8 +171,8 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
  * a copy passed to the function to store the index w.r.t the parallel axis segment list.*/
 
 std::vector<int> find_ortho_cost_index(const RRGraphView& rr_graph,
-                                       const std::vector<t_segment_inf> segment_inf_x,
-                                       const std::vector<t_segment_inf> segment_inf_y,
+                                       const std::vector<t_segment_inf>& segment_inf_x,
+                                       const std::vector<t_segment_inf>& segment_inf_y,
                                        e_parallel_axis parallel_axis) {
     auto segment_inf_parallel = parallel_axis == X_AXIS ? segment_inf_x : segment_inf_y;
     auto segment_inf_perp = parallel_axis == X_AXIS ? segment_inf_y : segment_inf_x;
@@ -671,7 +671,7 @@ static void calculate_average_switch(const RRGraphView& rr_graph,
             }
 
             avg_switch_R += rr_graph.rr_switch_inf(RRSwitchId(switch_index)).R;
-            avg_switch_T += rr_graph.rr_switch_inf(RRSwitchId(switch_index)).Tdel;
+            avg_switch_T += rr_graph.edge_delay(edge);
             avg_switch_Cinternal += rr_graph.rr_switch_inf(RRSwitchId(switch_index)).Cinternal;
 
             if (buffered == UNDEFINED) {
diff --git a/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.h b/libs/librrgraph/src/utils/alloc_and_load_rr_indexed_data.h
@@ -18,8 +18,8 @@ void alloc_and_load_rr_indexed_data(const RRGraphView& rr_graph,
                                     const char* echo_file_name);
 
 std::vector<int> find_ortho_cost_index(const RRGraphView& rr_graph,
-                                       const std::vector<t_segment_inf> segment_inf_x,
-                                       const std::vector<t_segment_inf> segment_inf_y,
+                                       const std::vector<t_segment_inf>& segment_inf_x,
+                                       const std::vector<t_segment_inf>& segment_inf_y,
                                        e_parallel_axis parallel_axis); 
 
 #endif
diff --git a/vpr/src/route/connection_router.cpp b/vpr/src/route/connection_router.cpp
@@ -702,7 +702,10 @@ void ConnectionRouter<Heap>::evaluate_timing_driven_node_costs(RTExploredNode* t
     bool switch_buffered = rr_switch_inf_[iswitch].buffered();
     bool reached_configurably = rr_switch_inf_[iswitch].configurable();
     float switch_R = rr_switch_inf_[iswitch].R;
-    float switch_Tdel = rr_switch_inf_[iswitch].Tdel;
+    // Instead of looking up the delay from the RR switch type info,
+    // we call edge_delay() method that returns the exact delay calculated
+    // by adding edge-specific delays to the nominal delay of switch type
+    float switch_Tdel = rr_graph_->edge_delay(to->prev_edge);
     float switch_Cinternal = rr_switch_inf_[iswitch].Cinternal;
 
     //To node info
diff --git a/vpr/src/route/route_tree.cpp b/vpr/src/route/route_tree.cpp
@@ -184,7 +184,7 @@ void RouteTree::reload_timing(vtr::optional<RouteTreeNode&> from_node) {
 }
 
 void RouteTree::reload_timing_unlocked(vtr::optional<RouteTreeNode&> from_node) {
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     if (!from_node)
@@ -208,6 +208,7 @@ void RouteTree::reload_timing_unlocked(vtr::optional<RouteTreeNode&> from_node)
         /* TODO Just a note (no action needed for this PR): In future, we need to consider APIs that returns
          * the Tdel for a routing trace in RRGraphView.*/
         Tdel_start += rr_graph.rr_switch_inf(iswitch).R * unbuffered_subtree_rt_root.C_downstream;
+        // TODO: probably call edge_delay() to retrieve the per-edge delay instead of per switch type delay
         Tdel_start += rr_graph.rr_switch_inf(iswitch).Tdel;
     }
 
@@ -325,23 +326,23 @@ RouteTree::update_unbuffered_ancestors_C_downstream(RouteTreeNode& from_node) {
  * must be correct before this routine is called. Tarrival is the time at
  * at which the signal arrives at this node's *input*. */
 void RouteTree::load_route_tree_Tdel(RouteTreeNode& from_node, float Tarrival) {
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     RRNodeId inode = from_node.inode;
-    float Tdel, Tchild;
 
     /* Assuming the downstream connections are, on average, connected halfway
      * along a wire segment's length.  See discussion in net_delay.cpp if you want
      * to change this.                                                           */
-    Tdel = Tarrival + 0.5 * from_node.C_downstream * rr_graph.node_R(inode);
-    from_node.Tdel = Tdel;
+    from_node.Tdel = Tarrival + 0.5 * from_node.C_downstream * rr_graph.node_R(inode);
 
     /* Now expand the children of this node to load their Tdel values */
     for (RouteTreeNode& child : from_node._child_nodes()) {
         RRSwitchId iswitch = child.parent_switch;
 
-        Tchild = Tdel + rr_graph.rr_switch_inf(iswitch).R * child.C_downstream;
+        float Tchild = from_node.Tdel + rr_graph.rr_switch_inf(iswitch).R * child.C_downstream;
+        // TODO: we should probably look up the per-edge delay instead of switch type delay
+        //       For this, we need to add a new member variable to RouteTreeNode to record it parent edge
         Tchild += rr_graph.rr_switch_inf(iswitch).Tdel; /* Intrinsic switch delay. */
         load_route_tree_Tdel(child, Tchild);
     }
diff --git a/vpr/src/route/router_lookahead_map_utils.cpp b/vpr/src/route/router_lookahead_map_utils.cpp
@@ -166,15 +166,16 @@ PQ_Entry::PQ_Entry(RRNodeId set_rr_node, int /*switch_ind*/, float parent_delay,
     this->cost = this->delay;
 }
 
-PQ_Entry_Delay::PQ_Entry_Delay(
-    RRNodeId set_rr_node,
-    int switch_ind,
-    const PQ_Entry_Delay* parent) {
+PQ_Entry_Delay::PQ_Entry_Delay(RRNodeId set_rr_node,
+                               int switch_ind,
+                               const PQ_Entry_Delay* parent) {
     this->rr_node = set_rr_node;
 
     if (parent != nullptr) {
-        auto& device_ctx = g_vpr_ctx.device();
+        const auto& device_ctx = g_vpr_ctx.device();
         const auto& rr_graph = device_ctx.rr_graph;
+        // We use nominal switch delay instead of per-edge delay that can be retrieved
+        // by calling edge_delay() method
         float Tsw = rr_graph.rr_switch_inf(RRSwitchId(switch_ind)).Tdel;
         float Rsw = rr_graph.rr_switch_inf(RRSwitchId(switch_ind)).R;
         float Cnode = rr_graph.node_C(set_rr_node);
@@ -1019,6 +1020,8 @@ static void dijkstra_flood_to_wires(int itile,
 
             for (RREdgeId edge : rr_graph.edge_range(curr.node)) {
                 int iswitch = rr_graph.rr_nodes().edge_switch(edge);
+                // We use nominal switch delay instead of per-edge delay that can be retrieved
+                // by calling edge_delay() method
                 float incr_delay = rr_graph.rr_switch_inf(RRSwitchId(iswitch)).Tdel;
 
                 RRNodeId next_node = rr_graph.rr_nodes().edge_sink_node(edge);
@@ -1122,6 +1125,8 @@ static void dijkstra_flood_to_ipins(RRNodeId node, util::t_chan_ipins_delays& ch
 
             for (RREdgeId edge : rr_graph.edge_range(curr.node)) {
                 int iswitch = rr_graph.rr_nodes().edge_switch(edge);
+                // We use nominal switch delay instead of per-edge delay that can be retrieved
+                // by calling edge_delay() method
                 float new_delay = rr_graph.rr_switch_inf(RRSwitchId(iswitch)).Tdel;
 
                 RRNodeId next_node = rr_graph.rr_nodes().edge_sink_node(edge);
@@ -1262,6 +1267,8 @@ static void run_intra_tile_dijkstra(const RRGraphView& rr_graph,
                 auto cost_index = rr_graph.node_cost_index(next_node);
                 int iswitch = rr_graph.rr_nodes().edge_switch(edge);
 
+                // We use nominal switch delay instead of per-edge delay that can be retrieved
+                // by calling edge_delay() method
                 float incr_delay = rr_graph.rr_switch_inf(RRSwitchId(iswitch)).Tdel;
                 float incr_cong = device_ctx.rr_indexed_data[cost_index].base_cost;
 
diff --git a/vpr/src/route/rr_graph.cpp b/vpr/src/route/rr_graph.cpp
@@ -678,7 +678,7 @@ static void add_pin_chain(const std::vector<int>& pin_chain,
                           bool is_new_chain);
 
 /***
- * @brief Return a pair. The firt element indicates whether the switch is added or it was already added. The second element is the switch index.
+ * @brief Return a pair. The first element indicates whether the switch is added or it was already added. The second element is the switch index.
  * @param rr_graph
  * @param arch_sw_inf
  * @param R_minW_nmos Needs to be passed to use create_rr_switch_from_arch_switch
@@ -1838,11 +1838,11 @@ static void load_rr_switch_inf(RRGraphBuilder& rr_graph_builder,
         }
     }
 }
+
 /* This function creates a routing switch for the usage of routing resource graph, based on a routing switch defined in architecture file.
  *
  * Since users can specify a routing switch whose buffer size is automatically tuned for routing architecture, the function here sets a definite buffer size, as required by placers and routers.
  */
-
 t_rr_switch_inf create_rr_switch_from_arch_switch(const t_arch_switch_inf& arch_sw_inf,
                                                   const float R_minW_nmos,
                                                   const float R_minW_pmos) {
@@ -5103,11 +5103,11 @@ static std::pair<bool, int> find_create_intra_cluster_sw(RRGraphBuilder& rr_grap
                                                          float R_minW_pmos,
                                                          bool is_rr_sw,
                                                          float delay) {
-    const auto& rr_graph_switches = rr_graph.rr_switch();
+    const vtr::vector<RRSwitchId, t_rr_switch_inf>& rr_graph_switches = rr_graph.rr_switch();
 
     if (is_rr_sw) {
         for (int rr_switch_id = 0; rr_switch_id < (int)rr_graph_switches.size(); rr_switch_id++) {
-            const auto& rr_sw = rr_graph_switches[RRSwitchId(rr_switch_id)];
+            const t_rr_switch_inf& rr_sw = rr_graph_switches[RRSwitchId(rr_switch_id)];
             if (rr_sw.intra_tile) {
                 if (rr_sw.Tdel == delay) {
                     return std::make_pair(false, rr_switch_id);
@@ -5126,11 +5126,7 @@ static std::pair<bool, int> find_create_intra_cluster_sw(RRGraphBuilder& rr_grap
         auto find_res = std::find_if(arch_sw_inf.begin(), arch_sw_inf.end(),
                                      [delay](const std::pair<int, t_arch_switch_inf>& sw_inf_pair) {
                                          const t_arch_switch_inf& sw_inf = std::get<1>(sw_inf_pair);
-                                         if (sw_inf.intra_tile && sw_inf.Tdel() == delay) {
-                                             return true;
-                                         } else {
-                                             return false;
-                                         }
+                                         return sw_inf.intra_tile && sw_inf.Tdel() == delay;
                                      });
 
         // There isn't any other intra-tile edge with the same delay - Create a new one!
diff --git a/vpr/src/route/rr_graph2.cpp b/vpr/src/route/rr_graph2.cpp
@@ -60,7 +60,7 @@ static void add_classes_spatial_lookup(RRGraphBuilder& rr_graph_builder,
                                        int* index);
 
 static int get_bidir_track_to_chan_seg(RRGraphBuilder& rr_graph_builder,
-                                       const std::vector<int> conn_tracks,
+                                       const std::vector<int>& conn_tracks,
                                        const int layer,
                                        const int to_chan,
                                        const int to_seg,
@@ -2168,7 +2168,7 @@ void alloc_and_load_tile_rr_node_indices(RRGraphBuilder& rr_graph_builder,
 }
 
 static int get_bidir_track_to_chan_seg(RRGraphBuilder& rr_graph_builder,
-                                       const std::vector<int> conn_tracks,
+                                       const std::vector<int>& conn_tracks,
                                        const int layer,
                                        const int to_chan,
                                        const int to_seg,
diff --git a/vpr/src/util/vpr_utils.cpp b/vpr/src/util/vpr_utils.cpp
@@ -2019,10 +2019,14 @@ float get_min_cross_layer_delay() {
     const auto& rr_graph = g_vpr_ctx.device().rr_graph;
     float min_delay = std::numeric_limits<float>::max();
 
-    for (const auto& driver_node : rr_graph.nodes()) {
+    for (const RRNodeId driver_node : rr_graph.nodes()) {
         for (size_t edge_id = 0; edge_id < rr_graph.num_edges(driver_node); edge_id++) {
-            const auto& sink_node = rr_graph.edge_sink_node(driver_node, edge_id);
+            const RRNodeId sink_node = rr_graph.edge_sink_node(driver_node, edge_id);
             if (rr_graph.node_layer(driver_node) != rr_graph.node_layer(sink_node)) {
+                // Instead of calling edge_delay() method, we retrieve the delay from the switch type
+                // that the edge represents. Since the minimum delay returned by this function is used
+                // to construct the router lookahead, it is better nominal switch delays instead of exact
+                // ones that are calculated by adding edge-specific offsets.
                 int i_switch = rr_graph.edge_switch(driver_node, edge_id);
                 float edge_delay = rr_graph.rr_switch_inf(RRSwitchId(i_switch)).Tdel;
                 min_delay = std::min(min_delay, edge_delay);
diff --git a/vpr/src/util/vpr_utils.h b/vpr/src/util/vpr_utils.h
@@ -329,7 +329,7 @@ void apply_route_constraints(const UserRouteConstraints& constraint);
 /**
  * @brief Iterate over all inter-layer switch types and return the minimum delay of it.
  * useful four router lookahead to to have some estimate of the cost of crossing a layer
- * @return
+ * @return The minimum delay of goring through an inter-layer switch.
  */
 float get_min_cross_layer_delay();
 
