Merge branch 'simple_place_delay_model' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into 3d_track_to_track_conn

Author: amin1377

vpr/src/place/place_delay_model.cpp

@@ -157,7 +157,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

@@ -147,7 +147,7 @@ static vtr::NdMatrix<float, 4> 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,
@@ -1051,18 +1051,27 @@ static vtr::NdMatrix<float, 4> 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;
+                    }
                 }
             }
         }
@@ -127,8 +130,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

@@ -30,13 +30,13 @@ class RouterDelayProfiler {
                          const t_router_opts& router_opts,
                          float* net_delay);
 
-    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_;
 };
 

vpr/src/route/router_lookahead.h

@@ -36,7 +36,7 @@ class RouterLookahead {
     // May be unimplemented, in which case method should throw an exception.
     virtual void write_intra_cluster(const std::string& file) const = 0;
 
-    virtual float get_distance_min_delay(int from_layer, int to_layer, int dx, int dy) const = 0;
+    virtual float get_opin_distance_min_delay(int physical_tile_idx, int from_layer, int to_layer, int dx, int dy) const = 0;
 
     virtual ~RouterLookahead() {}
 };
@@ -94,7 +94,7 @@ class ClassicLookahead : public RouterLookahead {
         VPR_THROW(VPR_ERROR_ROUTE, "ClassicLookahead::write_intra_cluster unimplemented");
     }
 
-    float get_distance_min_delay(int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
+    float get_opin_distance_min_delay(int /*physical_tile_idx*/, int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
         VPR_THROW(VPR_ERROR_ROUTE, "ClassicLookahead::get_distance_min_delay unimplemented");
         return -1.;
     }
@@ -131,7 +131,7 @@ class NoOpLookahead : public RouterLookahead {
         VPR_THROW(VPR_ERROR_ROUTE, "write_intra_cluster not supported for NoOpLookahead");
     }
 
-    float get_distance_min_delay(int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
+    float get_opin_distance_min_delay(int /*physical_tile_idx*/, int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
         VPR_THROW(VPR_ERROR_ROUTE, "ClassicLookahead::get_distance_min_delay unimplemented");
         return -1.;
     }

vpr/src/route/router_lookahead_extended_map.h

@@ -104,7 +104,7 @@ class ExtendedMapLookahead : public RouterLookahead {
         VPR_THROW(VPR_ERROR_ROUTE, "ExtendedMapLookahead::write_intra_cluster unimplemented");
     }
 
-    float get_distance_min_delay(int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
+    float get_opin_distance_min_delay(int /*physical_tile_idx*/, int /*from_layer*/, int /*to_layer*/, int /*dx*/, int /*dy*/) const override {
         VPR_THROW(VPR_ERROR_ROUTE, "ClassicLookahead::get_distance_min_delay unimplemented");
         return -1.;
     }

vpr/src/route/router_lookahead_map.cpp

@@ -255,7 +255,9 @@ static void store_min_cost_to_sinks(std::unordered_map<int, std::unordered_map<i
  * @brief Iterate over the first and second dimension of f_wire_cost_map to get the minimum cost for each dx and dy_
  * @param internal_opin_global_cost_map This map is populated in this function. [dx][dy] -> cost
  */
-static void min_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distance_min_cost);
+static void min_chann_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& 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);
 
 /**
  * @brief Iterate over all of the wire segments accessible from the SOURCE/OPIN (stored in src_opin_delay_map) and return the minimum cost (congestion and delay) across them to the sink
@@ -377,14 +379,14 @@ float MapLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target_nod
                     }
                 } else {
                     // Since we don't know which type of wires are accessible from an OPIN inside the cluster, we use
-                    // distance_based_min_cost to get an estimation of the global cost, and then, add this cost to the tile_min_cost
+                    // chann_distance_based_min_cost to get an estimation of the global cost, and then, add this cost to the tile_min_cost
                     // to have an estimation of the cost of getting into a cluster - We don't have any estimation of the cost to get out of the cluster
                     int delta_x, delta_y;
                     get_xy_deltas(current_node, target_node, &delta_x, &delta_y);
                     delta_x = abs(delta_x);
                     delta_y = abs(delta_y);
-                    delay_cost = params.criticality * distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].delay;
-                    cong_cost = (1. - params.criticality) * distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].congestion;
+                    delay_cost = params.criticality * chann_distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].delay;
+                    cong_cost = (1. - params.criticality) * chann_distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].congestion;
 
                     delay_offset_cost = params.criticality * tile_min_cost.at(to_physical_type->index).at(to_node_ptc_num).delay;
                     cong_offset_cost = (1. - params.criticality) * tile_min_cost.at(to_physical_type->index).at(to_node_ptc_num).congestion;
@@ -415,8 +417,8 @@ float MapLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target_nod
                 get_xy_deltas(current_node, target_node, &delta_x, &delta_y);
                 delta_x = abs(delta_x);
                 delta_y = abs(delta_y);
-                delay_cost = params.criticality * distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].delay;
-                cong_cost = (1. - params.criticality) * distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].congestion;
+                delay_cost = params.criticality * chann_distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].delay;
+                cong_cost = (1. - params.criticality) * chann_distance_based_min_cost[rr_graph.node_layer(current_node)][to_layer_num][delta_x][delta_y].congestion;
 
                 delay_offset_cost = params.criticality * tile_min_cost.at(to_physical_type->index).at(to_node_ptc_num).delay;
                 cong_offset_cost = (1. - params.criticality) * tile_min_cost.at(to_physical_type->index).at(to_node_ptc_num).congestion;
@@ -540,7 +542,8 @@ void MapLookahead::compute(const std::vector<t_segment_inf>& segment_inf) {
     //from the different physical tile type's SOURCEs & OPINs
     this->src_opin_delays = util::compute_router_src_opin_lookahead(is_flat_);
 
-    min_global_cost_map(distance_based_min_cost);
+    min_chann_global_cost_map(chann_distance_based_min_cost);
+    min_opin_distance_cost_map(src_opin_delays, opin_distance_based_min_cost);
 }
 
 void MapLookahead::compute_intra_tile() {
@@ -581,8 +584,8 @@ void MapLookahead::read_intra_cluster(const std::string& file) {
                                 inter_tile_pin_primitive_pin_delay);
     }
 
-    // The information about distance_based_min_cost is not stored in the file, thus it needs to be computed
-    min_global_cost_map(distance_based_min_cost);
+    // The information about chann_distance_based_min_cost is not stored in the file, thus it needs to be computed
+    min_chann_global_cost_map(chann_distance_based_min_cost);
 }
 
 void MapLookahead::write(const std::string& file) const {
@@ -594,8 +597,8 @@ void MapLookahead::write_intra_cluster(const std::string& file) const {
                                          inter_tile_pin_primitive_pin_delay);
 }
 
-float MapLookahead::get_distance_min_delay(int from_layer, int to_layer, int dx, int dy) const {
-    return distance_based_min_cost[from_layer][to_layer][dx][dy].delay;
+float MapLookahead::get_opin_distance_min_delay(int physical_tile_idx, int from_layer, int to_layer, int dx, int dy) const {
+    return opin_distance_based_min_cost[physical_tile_idx][from_layer][to_layer][dx][dy].delay;
 }
 
 /******** Function Definitions ********/
@@ -1463,7 +1466,7 @@ static void store_min_cost_to_sinks(std::unordered_map<int, std::unordered_map<i
     VTR_ASSERT(insert_res.second);
 }
 
-static void min_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distance_min_cost) {
+static void min_chann_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distance_min_cost) {
     int num_layers = g_vpr_ctx.device().grid.get_num_layers();
     int width = (int)g_vpr_ctx.device().grid.width();
     int height = (int)g_vpr_ctx.device().grid.height();
@@ -1494,6 +1497,43 @@ static void min_global_cost_map(vtr::NdMatrix<util::Cost_Entry, 4>& distance_min
     }
 }
 
+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) {
+    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();
+    int height = (int)g_vpr_ctx.device().grid.height();
+    distance_min_cost.resize({static_cast<unsigned long>(num_tile_types),
+                              static_cast<unsigned long>(num_layers),
+                              static_cast<unsigned long>(num_layers),
+                              static_cast<unsigned long>(width),
+                              static_cast<unsigned long>(height)});
+
+    for (int tile_type_idx = 0; tile_type_idx < num_tile_types; tile_type_idx++) {
+        for (int from_layer_num = 0; from_layer_num < num_layers; from_layer_num++) {
+            for (int to_layer_num = 0; to_layer_num < num_layers; to_layer_num++) {
+                for (int dx = 0; dx < width; dx++) {
+                    for (int dy = 0; dy < height; dy++) {
+                        float expected_delay_cost = std::numeric_limits<float>::infinity();
+                        float expected_cong_cost = std::numeric_limits<float>::infinity();
+                        util::Cost_Entry min_cost(std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity());
+                        for (const auto& tile_opin_map : src_opin_delays[from_layer_num][tile_type_idx]) {
+                            std::tie(expected_delay_cost, expected_cong_cost) = get_cost_from_src_opin(tile_opin_map,
+                                                                                                       dx,
+                                                                                                       dy,
+                                                                                                       to_layer_num);
+                            if (expected_delay_cost < min_cost.delay) {
+                                min_cost.delay = expected_delay_cost;
+                                min_cost.congestion = expected_cong_cost;
+                            }
+                        }
+                        distance_min_cost[tile_type_idx][from_layer_num][to_layer_num][dx][dy] = min_cost;
+                    }
+                }
+            }
+        }
+    }
+}
+
 static std::pair<float, float> get_cost_from_src_opin(const std::vector<std::map<int, util::t_reachable_wire_inf>>& src_opin_delay_map,
                                                       int delta_x,
                                                       int delta_y,

vpr/src/route/router_lookahead_map.h

@@ -18,7 +18,8 @@ class MapLookahead : public RouterLookahead {
     // Lookup table to store the minimum cost to reach to a primitive pin from the root-level IPINs
     std::unordered_map<int, std::unordered_map<int, util::Cost_Entry>> tile_min_cost; // [physical_tile_type][sink_physical_num] -> cost
     // Lookup table to store the minimum cost for each dx and dy
-    vtr::NdMatrix<util::Cost_Entry, 4> distance_based_min_cost; // [from_layer_num][to_layer_num][dx][dy] -> cost
+    vtr::NdMatrix<util::Cost_Entry, 4> chann_distance_based_min_cost; // [from_layer_num][to_layer_num][dx][dy] -> cost
+    vtr::NdMatrix<util::Cost_Entry, 5> opin_distance_based_min_cost; // [from_layer_num][to_layer_num][dx][dy] -> cost
 
     const t_det_routing_arch& det_routing_arch_;
     bool is_flat_;
@@ -33,7 +34,7 @@ class MapLookahead : public RouterLookahead {
     void read_intra_cluster(const std::string& file) override;
     void write(const std::string& file) const override;
     void write_intra_cluster(const std::string& file) const override;
-    float get_distance_min_delay(int from_layer, int to_layer, int dx, int dy) const override;
+    float get_opin_distance_min_delay(int physical_tile_idx, int from_layer, int to_layer, int dx, int dy) const override;
 };
 
 /* f_cost_map is an array of these cost entries that specifies delay/congestion estimates