use the correct layer for CHANZ nodes when initalizing src_opin_delays

Author: soheilshahrouz

vpr/src/base/read_options.cpp

@@ -1104,7 +1104,7 @@ struct ParseRouteBBUpdate {
 
 struct ParseRouterLookahead {
     ConvertedValue<e_router_lookahead> from_str(std::string str) {
-        std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+        std::ranges::transform(str, str.begin(), ::tolower);
         ConvertedValue<e_router_lookahead> conv_value;
         if (str == "classic")
             conv_value.set_value(e_router_lookahead::CLASSIC);

vpr/src/place/delay_model/simple_delay_model.cpp

@@ -13,7 +13,7 @@ void SimpleDelayModel::compute(RouterDelayProfiler& route_profiler,
                                const t_placer_opts& /*placer_opts*/,
                                const t_router_opts& /*router_opts*/,
                                int /*longest_length*/) {
-    const auto& grid = g_vpr_ctx.device().grid;
+    const DeviceGrid& grid = g_vpr_ctx.device().grid;
     const size_t num_physical_tile_types = g_vpr_ctx.device().physical_tile_types.size();
     const size_t num_layers = grid.get_num_layers();
 
@@ -31,10 +31,8 @@ void SimpleDelayModel::compute(RouterDelayProfiler& route_profiler,
                 for (size_t dx = 0; dx < grid.width(); ++dx) {
                     for (size_t dy = 0; dy < grid.height(); ++dy) {
                         float min_delay = route_profiler.get_min_delay(physical_tile_type_idx,
-                                                                       from_layer,
-                                                                       to_layer,
-                                                                       dx,
-                                                                       dy);
+                                                                       from_layer, to_layer,
+                                                                       dx, dy);
                         delays_[physical_tile_type_idx][from_layer][to_layer][dx][dy] = min_delay;
                     }
                 }

vpr/src/route/router_lookahead/router_lookahead.h

@@ -66,7 +66,8 @@ class RouterLookahead {
     virtual void write_intra_cluster(const std::string& file) const = 0;
 
     /**
-     * @brief Retrieve the minimum delay to a point on the "to_layer," which is dx and dy away, across all the OPINs on the physical tile identified by "physical_tile_idx."
+     * @brief Retrieve the minimum delay to a point on the "to_layer," which is dx and dy away,
+     *        across all the OPINs on the physical tile identified by "physical_tile_idx".
      * @param physical_tile_idx The index of the physical tile from which the cost is calculated
      * @param from_layer The layer that the tile is located on
      * @param to_layer The layer on which the destination is located

vpr/src/route/router_lookahead/router_lookahead_map.cpp

@@ -118,10 +118,8 @@ static void store_min_cost_to_sinks(std::unordered_map<int, std::unordered_map<i
 static void min_chann_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distance_min_cost);
 
 /**
- * @brief // Given the src/opin map of each physical tile type, iterate over all OPINs/sources of a type and create
+ * @brief Given the src/opin map of each physical tile type, iterate over all OPINs/sources of a type and create
  * the minimum cost map across all of them for each tile type.
- * @param src_opin_delays
- * @param distance_min_cost
  */
 static void min_opin_distance_cost_map(const util::t_src_opin_delays& src_opin_delays, vtr::NdMatrix<util::Cost_Entry, 5>& distance_min_cost);
 
@@ -390,8 +388,6 @@ std::pair<float, float> MapLookahead::get_expected_delay_and_cong(RRNodeId from_
                                                           delta_x,
                                                           delta_y,
                                                           to_layer_num);
-        expected_delay_cost = cost_entry.delay;
-        expected_cong_cost = cost_entry.congestion;
 
         VTR_ASSERT_SAFE_MSG(std::isfinite(expected_delay_cost),
                             vtr::string_fmt("Lookahead failed to estimate cost from %s: %s",
@@ -835,13 +831,11 @@ static void min_chann_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distan
 }
 
 static void min_opin_distance_cost_map(const util::t_src_opin_delays& src_opin_delays, vtr::NdMatrix<util::Cost_Entry, 5>& distance_min_cost) {
-    /**
-     * This function calculates and stores the minimum cost to reach a point on layer `n_sink`, which is `dx` and `dy` further from the current point
-     * on layer `n_source` and is located on physical tile type `t`. To compute this cost, the function iterates over all output pins of tile `t`,
-     * and for each pin, iterates over all segment types accessible by it. It then determines and stores the minimum cost to the destination point.
-     * "src_opin_delays" stores the routing segments accessible by each OPIN of each physical type on each layer. After getting the accessible segment types,
-     * "get_wire_cost_entry" is called to get the cost from that segment type to the destination point.
-     */
+    // This function calculates and stores the minimum cost to reach a point on layer `n_sink`, which is `dx` and `dy` further from the current point
+    // on layer `n_source` and is located on physical tile type `t`. To compute this cost, the function iterates over all output pins of tile `t`,
+    // and for each pin, iterates over all segment types accessible by it. It then determines and stores the minimum cost to the destination point.
+    // "src_opin_delays" stores the routing segments accessible by each OPIN of each physical type on each layer. After getting the accessible segment types,
+    // "get_wire_cost_entry" is called to get the cost from that segment type to the destination point.
     int num_tile_types = g_vpr_ctx.device().physical_tile_types.size();
     int num_layers = g_vpr_ctx.device().grid.get_num_layers();
     int width = (int)g_vpr_ctx.device().grid.width();
@@ -874,14 +868,13 @@ static void min_opin_distance_cost_map(const util::t_src_opin_delays& src_opin_d
                                         if (reachable_wire_inf.wire_rr_type == e_rr_type::SINK) {
                                             continue;
                                         }
-                                        util::Cost_Entry wire_cost_entry;
-
-                                        wire_cost_entry = get_wire_cost_entry(reachable_wire_inf.wire_rr_type,
-                                                                              reachable_wire_inf.wire_seg_index,
-                                                                              reachable_wire_inf.layer_number,
-                                                                              dx,
-                                                                              dy,
-                                                                              to_layer_num);
+
+                                        util::Cost_Entry wire_cost_entry = get_wire_cost_entry(reachable_wire_inf.wire_rr_type,
+                                                                                               reachable_wire_inf.wire_seg_index,
+                                                                                               reachable_wire_inf.layer_number,
+                                                                                               dx,
+                                                                                               dy,
+                                                                                               to_layer_num);
 
                                         float this_delay_cost = reachable_wire_inf.delay + wire_cost_entry.delay;
                                         float this_cong_cost = reachable_wire_inf.congestion + wire_cost_entry.congestion;

vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp

@@ -11,6 +11,7 @@
  * To access the utility functions, the util namespace needs to be used. */
 
 #include <fstream>
+#include <ranges>
 #include "globals.h"
 #include "physical_types_util.h"
 #include "vpr_context.h"
@@ -372,8 +373,7 @@ t_src_opin_delays compute_router_src_opin_lookahead(bool is_flat,
 
     int num_layers = device_ctx.grid.get_num_layers();
 
-    t_src_opin_delays src_opin_delays;
-    src_opin_delays.resize(num_layers);
+    t_src_opin_delays src_opin_delays(num_layers);
     std::vector<int> tile_max_ptc(device_ctx.physical_tile_types.size(), UNDEFINED);
 
     // Get the maximum OPIN ptc for each tile type to reserve src_opin_delays
@@ -392,8 +392,8 @@ t_src_opin_delays compute_router_src_opin_lookahead(bool is_flat,
         }
     }
 
-    //We assume that the routing connectivity of each instance of a physical tile is the same,
-    //and so only measure one instance of each type
+    // We assume that the routing connectivity of each instance of a physical tile is the same,
+    // and so only measure one instance of each type
     for (int from_layer_num = 0; from_layer_num < num_layers; from_layer_num++) {
         for (size_t itile = 0; itile < device_ctx.physical_tile_types.size(); ++itile) {
             if (device_ctx.grid.num_instances(&device_ctx.physical_tile_types[itile], from_layer_num) == 0) {
@@ -430,11 +430,9 @@ t_src_opin_delays compute_router_src_opin_lookahead(bool is_flat,
 
                         VTR_ASSERT(ptc < int(src_opin_delays[from_layer_num][itile].size()));
 
-                        //Find the wire types which are reachable from inode and record them and
-                        //the cost to reach them
-                        dijkstra_flood_to_wires(itile,
-                                                node_id,
-                                                src_opin_delays);
+                        // Find the wire types which are reachable from inode and record them and
+                        // the cost to reach them
+                        dijkstra_flood_to_wires(itile, node_id, src_opin_delays);
 
                         bool reachable_wire_found = false;
                         for (int to_layer_num = 0; to_layer_num < num_layers; to_layer_num++) {
@@ -876,7 +874,7 @@ std::pair<float, float> get_cost_from_src_opin(const std::map<int, util::t_reach
         //From the current SOURCE/OPIN we look-up the wiretypes which are reachable
         //and then add the estimates from those wire types for the distance of interest.
         //If there are multiple options we use the minimum value.
-        for (const auto& [_, reachable_wire_inf] : src_opin_delay_map) {
+        for (const util::t_reachable_wire_inf& reachable_wire_inf : src_opin_delay_map | std::views::values) {
 
             util::Cost_Entry wire_cost_entry;
             if (reachable_wire_inf.wire_rr_type == e_rr_type::SINK) {
@@ -967,7 +965,7 @@ void dump_readable_router_lookahead_map(const std::string& file_name, const std:
 static void dijkstra_flood_to_wires(int itile,
                                     RRNodeId node,
                                     util::t_src_opin_delays& src_opin_delays) {
-    const auto& device_ctx = g_vpr_ctx.device();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     struct t_pq_entry {
@@ -1018,23 +1016,27 @@ static void dijkstra_flood_to_wires(int itile,
         e_rr_type curr_rr_type = rr_graph.node_type(curr.node);
         int curr_layer_num = rr_graph.node_layer_low(curr.node);
         if (curr_rr_type == e_rr_type::CHANX || curr_rr_type == e_rr_type::CHANY || curr_rr_type == e_rr_type::CHANZ || curr_rr_type == e_rr_type::SINK) {
-            //We stop expansion at any CHANX/CHANY/SINK
+            // We stop expansion at any CHANX/CHANY/SINK
             int seg_index;
             if (curr_rr_type != e_rr_type::SINK) {
                 //It's a wire, figure out its type
-                auto cost_index = rr_graph.node_cost_index(curr.node);
+                RRIndexedDataId cost_index = rr_graph.node_cost_index(curr.node);
                 seg_index = device_ctx.rr_indexed_data[cost_index].seg_index;
             } else {
-                //This is a direct-connect path between an IPIN and OPIN,
-                //which terminated at a SINK.
+                // This is a direct-connect path between an IPIN and OPIN,
+                // which terminated at a SINK.
                 //
-                //We treat this as a 'special' wire type.
-                //When the src_opin_delays data structure is queried and a SINK rr_type
-                //is found, the lookahead is not accessed to get the cost entries
-                //as this is a special case of direct connections between OPIN and IPIN.
+                // We treat this as a 'special' wire type.
+                // When the src_opin_delays data structure is queried and a SINK rr_type
+                // is found, the lookahead is not accessed to get the cost entries
+                // as this is a special case of direct connections between OPIN and IPIN.
                 seg_index = DIRECT_CONNECT_SPECIAL_SEG_TYPE;
             }
 
+            if (curr_rr_type == e_rr_type::CHANZ) {
+                curr_layer_num = (root_layer_num + 1) % 2;
+            }
+
             //Keep costs of the best path to reach each wire type
             if (!src_opin_delays[root_layer_num][itile][ptc][curr_layer_num].count(seg_index)
                 || curr.delay < src_opin_delays[root_layer_num][itile][ptc][curr_layer_num][seg_index].delay) {
@@ -1047,7 +1049,7 @@ static void dijkstra_flood_to_wires(int itile,
 
         } else if (curr_rr_type == e_rr_type::SOURCE || curr_rr_type == e_rr_type::OPIN || curr_rr_type == e_rr_type::IPIN || curr_rr_type == e_rr_type::MUX) {
             //We allow expansion through SOURCE/OPIN/IPIN types
-            auto cost_index = rr_graph.node_cost_index(curr.node);
+            RRIndexedDataId cost_index = rr_graph.node_cost_index(curr.node);
             float incr_cong = device_ctx.rr_indexed_data[cost_index].base_cost; //Current nodes congestion cost
 
             for (RREdgeId edge : rr_graph.edge_range(curr.node)) {
@@ -1201,8 +1203,6 @@ static t_physical_tile_loc pick_sample_tile(int layer_num, t_physical_tile_type_
     //Very simple for now, just pick the fist matching tile found
     t_physical_tile_loc loc(UNDEFINED, UNDEFINED, UNDEFINED);
 
-    //VTR_LOG("Prev: %d,%d\n", prev.x, prev.y);
-
     auto& device_ctx = g_vpr_ctx.device();
     auto& grid = device_ctx.grid;
 
@@ -1235,8 +1235,6 @@ static t_physical_tile_loc pick_sample_tile(int layer_num, t_physical_tile_type_
         }
     }
 
-    //VTR_LOG("Next: %d,%d\n", loc.x, loc.y);
-
     return loc;
 }