vpr: place_delay_model: use get_opin_min_delay to return a delay between two locations

Author: amin1377

vpr/src/place/place_delay_model.cpp

@@ -164,7 +164,8 @@ float SimpleDelayModel::delay(const t_physical_tile_loc& from_loc, int /*from_pi
     int delta_x = std::abs(from_loc.x - to_loc.x);
     int delta_y = std::abs(from_loc.y - to_loc.y);
 
-    return delays_[from_loc.layer_num][to_loc.layer_num][delta_x][delta_y];
+    int from_tile_idx = g_vpr_ctx.device().grid.get_physical_type(from_loc)->index;
+    return delays_[from_tile_idx][from_loc.layer_num][to_loc.layer_num][delta_x][delta_y];
 }
 
 /**

vpr/src/place/place_delay_model.h

@@ -238,7 +238,7 @@ class SimpleDelayModel : public PlaceDelayModel {
     void write(const std::string& /*file*/) const override {}
 
   private:
-    vtr::NdMatrix<float, 4> delays_; // [0..num_layers-1][0..max_dx][0..max_dy]
+    vtr::NdMatrix<float, 5> delays_; // [0..num_layers-1][0..max_dx][0..max_dy]
     float cross_layer_delay_;
     bool is_flat_;
 };

vpr/src/place/timing_place_lookup.cpp

@@ -143,7 +143,7 @@ static vtr::NdMatrix<float, 3> compute_delta_delay_model(
     int longest_length,
     bool is_flat);
 
-static vtr::NdMatrix<float, 4> compute_simple_delay_model(RouterDelayProfiler& route_profiler);
+static vtr::NdMatrix<float, 5> compute_simple_delay_model(RouterDelayProfiler& route_profiler);
 
 static bool find_direct_connect_sample_locations(const t_direct_inf* direct,
                                                  t_physical_tile_type_ptr from_type,
@@ -1016,18 +1016,27 @@ static vtr::NdMatrix<float, 3> compute_delta_delay_model(
     return delta_delays;
 }
 
-static vtr::NdMatrix<float, 4> compute_simple_delay_model(RouterDelayProfiler& route_profiler) {
+static vtr::NdMatrix<float, 5> compute_simple_delay_model(RouterDelayProfiler& route_profiler) {
     const auto& grid = g_vpr_ctx.device().grid;
-    vtr::NdMatrix<float, 4> delta_delays({static_cast<unsigned long>(grid.get_num_layers()),
+    int num_physical_tile_types = static_cast<int>(g_vpr_ctx.device().physical_tile_types.size());
+    vtr::NdMatrix<float, 5> delta_delays({static_cast<unsigned long>(num_physical_tile_types),
+                                          static_cast<unsigned long>(grid.get_num_layers()),
                                           static_cast<unsigned long>(grid.get_num_layers()),
                                           grid.width(),
                                           grid.height()});
-    for (int from_layer = 0; from_layer < grid.get_num_layers(); ++from_layer) {
-        for (int to_layer = 0; to_layer < grid.get_num_layers(); ++to_layer) {
-            for (int dx = 0; dx < static_cast<int>(grid.width()); ++dx) {
-                for (int dy = 0; dy < static_cast<int>(grid.height()); ++dy) {
-                    float min_delay = route_profiler.get_min_delay(from_layer, to_layer, dx, dy);
-                    delta_delays[from_layer][to_layer][dx][dy] = min_delay;
+
+    for (int physical_tile_type_idx = 0; physical_tile_type_idx < num_physical_tile_types; ++physical_tile_type_idx) {
+        for (int from_layer = 0; from_layer < grid.get_num_layers(); ++from_layer) {
+            for (int to_layer = 0; to_layer < grid.get_num_layers(); ++to_layer) {
+                for (int dx = 0; dx < static_cast<int>(grid.width()); ++dx) {
+                    for (int dy = 0; dy < static_cast<int>(grid.height()); ++dy) {
+                        float min_delay = route_profiler.get_min_delay(physical_tile_type_idx,
+                                                                       from_layer,
+                                                                       to_layer,
+                                                                       dx,
+                                                                       dy);
+                        delta_delays[physical_tile_type_idx][from_layer][to_layer][dx][dy] = min_delay;
+                    }
                 }
             }
         }

vpr/src/route/router_delay_profiling.cpp

@@ -23,16 +23,19 @@ RouterDelayProfiler::RouterDelayProfiler(const Netlist<>& net_list,
           is_flat)
     , is_flat_(is_flat) {
     const auto& grid = g_vpr_ctx.device().grid;
-    min_delays_.resize({static_cast<unsigned long>(grid.get_num_layers()),
+    min_delays_.resize({g_vpr_ctx.device().physical_tile_types.size(),
+                        static_cast<unsigned long>(grid.get_num_layers()),
                         static_cast<unsigned long>(grid.get_num_layers()),
                         grid.width(),
                         grid.height()});
-    for (int from_layer = 0; from_layer < grid.get_num_layers(); ++from_layer) {
-        for (int to_layer = 0; to_layer < grid.get_num_layers(); ++to_layer) {
-            for (int dx = 0; dx < static_cast<int>(grid.width()); ++dx) {
-                for (int dy = 0; dy < static_cast<int>(grid.height()); ++dy) {
-                    float min_delay = lookahead->get_distance_min_delay(from_layer, to_layer, dx, dy);
-                    min_delays_[from_layer][to_layer][dx][dy] = min_delay;
+    for (int physical_tile_type_idx = 0; physical_tile_type_idx < static_cast<int>(g_vpr_ctx.device().physical_tile_types.size()); ++physical_tile_type_idx) {
+        for (int from_layer = 0; from_layer < grid.get_num_layers(); ++from_layer) {
+            for (int to_layer = 0; to_layer < grid.get_num_layers(); ++to_layer) {
+                for (int dx = 0; dx < static_cast<int>(grid.width()); ++dx) {
+                    for (int dy = 0; dy < static_cast<int>(grid.height()); ++dy) {
+                        float min_delay = lookahead->get_opin_distance_min_delay(physical_tile_type_idx, from_layer, to_layer, dx, dy);
+                        min_delays_[physical_tile_type_idx][from_layer][to_layer][dx][dy] = min_delay;
+                    }
                 }
             }
         }
@@ -129,8 +132,8 @@ bool RouterDelayProfiler::calculate_delay(RRNodeId source_node,
     return found_path;
 }
 
-float RouterDelayProfiler::get_min_delay(int from_layer, int to_layer, int dx, int dy) const {
-    return min_delays_[from_layer][to_layer][dx][dy];
+float RouterDelayProfiler::get_min_delay(int physical_tile_type_idx, int from_layer, int to_layer, int dx, int dy) const {
+    return min_delays_[physical_tile_type_idx][from_layer][to_layer][dx][dy];
 }
 
 //Returns the shortest path delay from src_node to all RR nodes in the RR graph, or NaN if no path exists

vpr/src/route/router_delay_profiling.h

@@ -31,13 +31,13 @@ class RouterDelayProfiler {
                          float* net_delay,
                          int layer_num);
 
-    float get_min_delay(int from_layer, int to_layer, int dx, int dy) const;
+    float get_min_delay(int physical_tile_type_idx, int from_layer, int to_layer, int dx, int dy) const;
 
   private:
     const Netlist<>& net_list_;
     RouterStats router_stats_;
     ConnectionRouter<BinaryHeap> router_;
-    vtr::NdMatrix<float, 4> min_delays_;
+    vtr::NdMatrix<float, 5> min_delays_;
     bool is_flat_;
 };