add RoutingChanUtilEstimator class

When the placement was read from a file, NetCostHandler was never read, and channel util estimate was never computed. RoutingChanUtilEstimator computes BBs in the routing stage and calculates channel utilization there

Author: soheilshahrouz

vpr/src/base/vpr_api.cpp

@@ -903,7 +903,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup,
     auto& blk_loc_registry = place_ctx.mutable_blk_loc_registry();
     const auto& filename_opts = vpr_setup.FileNameOpts;
 
-    //Initialize the block location registry, which will be filled when loading placement
+    // Initialize the block location registry, which will be filled when loading placement
     blk_loc_registry.init();
 
     // Alloc and load the placement macros.
@@ -913,13 +913,12 @@ void vpr_load_placement(t_vpr_setup& vpr_setup,
                                                            g_vpr_ctx.atom().netlist(),
                                                            g_vpr_ctx.atom().lookup());
 
-    //Load an existing placement from a file
+    // Load an existing placement from a file
     place_ctx.placement_id = read_place(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(),
                                         blk_loc_registry,
                                         filename_opts.verify_file_digests, device_ctx.grid);
 
-    // Verify that the placement invariants are met after reading the placement
-    // from a file.
+    // Verify that the placement invariants are met after reading the placement from a file.
     unsigned num_errors = verify_placement(g_vpr_ctx);
     if (num_errors == 0) {
         VTR_LOG("Completed placement consistency check successfully.\n");

vpr/src/base/vpr_context.h

@@ -554,18 +554,11 @@ struct RoutingContext : public Context {
                RouterLookahead>
         cached_router_lookahead_;
 
-    /**
-     * @brief User specified routing constraints
-     */
+    /// @brief User specified routing constraints
     UserRouteConstraints constraints;
 
     /** Is flat routing enabled? */
     bool is_flat;
-
-    /// @brief Post-placement estimate of CHANX routing utilization per (layer, x, y) location.
-    vtr::NdMatrix<double, 3> chanx_util;
-    /// @brief Post-placement estimate of CHANY routing utilization per (layer, x, y) location.
-    vtr::NdMatrix<double, 3> chany_util;
 };
 
 /**

vpr/src/place/net_cost_handler.cpp

@@ -461,15 +461,15 @@ void NetCostHandler::update_net_info_on_pin_move_(const PlaceDelayModel* delay_m
         return;
     }
 
-    /* Record effected nets */
+    // Record effected nets
     record_affected_net_(net_id);
 
     ClusterBlockId blk_id = moving_blk_inf.block_num;
-    /* Update the net bounding boxes. */
+    // Update the net bounding boxes.
     update_net_bb_(net_id, blk_id, pin_id, moving_blk_inf);
 
     if (placer_opts_.place_algorithm.is_timing_driven()) {
-        /* Determine the change in connection delay and timing cost. */
+        // Determine the change in connection delay and timing cost.
         update_td_delta_costs_(delay_model,
                                *criticalities,
                                net_id,

vpr/src/place/placer.cpp

@@ -311,7 +311,7 @@ void Placer::place() {
 
             // Outer loop of the simulated annealing ends
         } while (annealer_->outer_loop_update_state());
-    } //skip_anneal ends
+    } // skip_anneal ends
 
     // Start Quench
     annealer_->start_quench();
@@ -378,7 +378,6 @@ void Placer::place() {
 
 void Placer::update_global_state() {
     auto& mutable_palce_ctx = g_vpr_ctx.mutable_placement();
-    auto& mutable_routing_ctx = g_vpr_ctx.mutable_routing();
 
     // the placement location variables should be unlocked before being accessed
     mutable_palce_ctx.unlock_loc_vars();
@@ -387,11 +386,6 @@ void Placer::update_global_state() {
     auto& global_blk_loc_registry = mutable_palce_ctx.mutable_blk_loc_registry();
     global_blk_loc_registry = placer_state_.blk_loc_registry();
 
-    auto [chanx_util, chany_util] = net_cost_handler_.estimate_routing_chan_util();
-
-    mutable_routing_ctx.chanx_util = std::move(chanx_util);
-    mutable_routing_ctx.chany_util = std::move(chany_util);
-
 #ifndef NO_GRAPHICS
     // update the graphics' reference to placement location variables
     get_draw_state_vars()->set_graphics_blk_loc_registry_ref(global_blk_loc_registry);

vpr/src/route/route_common.cpp

@@ -9,6 +9,7 @@
 #include "physical_types_util.h"
 #include "route_export.h"
 #include "vpr_utils.h"
+#include "route_utilization.h"
 
 #if defined(VPR_USE_TBB)
 #include <tbb/parallel_for_each.h>
@@ -79,10 +80,15 @@ static bool classes_in_same_block(ParentBlockId blk_id, int first_class_ptc_num,
  * @param route_opts Contains channel utilization threshold and weighting factor
  *                   used to increase initial 'acc_cost' for nodes going through
  *                   congested channels.
+ * @param chanx_util Post-placement estimate of CHANX routing utilization per (layer, x, y) location.
+ * @param chany_util Post-placement estimate of CHANY routing utilization per (layer, x, y) location.
  * @return Initial `acc_cost` for the given RR node.
  */
+
 static float comp_initial_acc_cost(RRNodeId node_id,
-                                   const t_router_opts& route_opts);
+                                   const t_router_opts& route_opts,
+                                   const vtr::NdMatrix<double, 3>& chanx_util,
+                                   const vtr::NdMatrix<double, 3>& chany_util);
 
 /************************** Subroutine definitions ***************************/
 
@@ -430,7 +436,9 @@ void alloc_and_load_rr_node_route_structs(const t_router_opts& router_opts) {
 }
 
 static float comp_initial_acc_cost(RRNodeId node_id,
-                                   const t_router_opts& route_opts) {
+                                   const t_router_opts& route_opts,
+                                   const vtr::NdMatrix<double, 3>& chanx_util,
+                                   const vtr::NdMatrix<double, 3>& chany_util) {
     const auto& route_ctx = g_vpr_ctx.routing();
     const auto& rr_graph = g_vpr_ctx.device().rr_graph;
 
@@ -444,23 +452,22 @@ static float comp_initial_acc_cost(RRNodeId node_id,
     const double weight = route_opts.initial_acc_cost_chan_congestion_weight;
 
     // TODO: We don't have an explicit CHANZ type. These wires are marked as CHANX. This should be fixed.
-    if (is_chan(rr_type) && !route_ctx.chanx_util.empty()) {
-        VTR_ASSERT_SAFE(!route_ctx.chany_util.empty());
+    if (is_chan(rr_type)) {
         double max_util = 0.;
 
         if (rr_type == e_rr_type::CHANX) {
             int y = rr_graph.node_ylow(node_id);
             int layer = rr_graph.node_layer(node_id);
             for (int x = rr_graph.node_xlow(node_id); x <= rr_graph.node_xhigh(node_id); x++) {
-                max_util = std::max(max_util, route_ctx.chanx_util[layer][x][y]);
+                max_util = std::max(max_util, chanx_util[layer][x][y]);
             }
 
         } else {
             VTR_ASSERT_SAFE(rr_type == e_rr_type::CHANY);
             int x = rr_graph.node_xlow(node_id);
             int layer = rr_graph.node_layer(node_id);
             for (int y = rr_graph.node_ylow(node_id); y <= rr_graph.node_yhigh(node_id); y++) {
-                max_util = std::max(max_util, route_ctx.chany_util[layer][x][y]);
+                max_util = std::max(max_util, chany_util[layer][x][y]);
             }
         }
 
@@ -475,14 +482,19 @@ void reset_rr_node_route_structs(const t_router_opts& route_opts) {
 
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     const auto& device_ctx = g_vpr_ctx.device();
+    const auto& blk_loc_registry = g_vpr_ctx.placement().blk_loc_registry();
+    const bool cube_bb = g_vpr_ctx.placement().cube_bb;
 
     VTR_ASSERT(route_ctx.rr_node_route_inf.size() == size_t(device_ctx.rr_graph.num_nodes()));
 
+    RoutingChanUtilEstimator routing_chan_util_estimator(blk_loc_registry, cube_bb);
+    const auto [chanx_util, chany_util] = routing_chan_util_estimator.estimate_routing_chan_util();
+
     for (const RRNodeId rr_id : device_ctx.rr_graph.nodes()) {
         t_rr_node_route_inf& node_inf = route_ctx.rr_node_route_inf[rr_id];
 
         node_inf.prev_edge = RREdgeId::INVALID();
-        node_inf.acc_cost = comp_initial_acc_cost(rr_id, route_opts);
+        node_inf.acc_cost = comp_initial_acc_cost(rr_id, route_opts, chanx_util, chany_util);
         node_inf.path_cost = std::numeric_limits<float>::infinity();
         node_inf.backward_path_cost = std::numeric_limits<float>::infinity();
         node_inf.set_occ(0);

vpr/src/route/route_utilization.cpp

@@ -5,6 +5,22 @@
 #include "vpr_utils.h"
 #include "route_common.h"
 
+RoutingChanUtilEstimator::RoutingChanUtilEstimator(const BlkLocRegistry& blk_loc_registry, bool cube_bb) {
+    placer_state_ = std::make_unique<PlacerState>(/*placement_is_timing_driven=*/false);
+    placer_state_->mutable_blk_loc_registry() = blk_loc_registry;
+
+    placer_opts_.place_algorithm = e_place_algorithm::BOUNDING_BOX_PLACE;
+    net_cost_handler_ = std::make_unique<NetCostHandler>(placer_opts_, *placer_state_, cube_bb);
+}
+
+std::pair<vtr::NdMatrix<double, 3>, vtr::NdMatrix<double, 3>> RoutingChanUtilEstimator::estimate_routing_chan_util() {
+    // Compute net bounding boxes
+    net_cost_handler_->comp_bb_cost(e_cost_methods::NORMAL);
+
+    // Estimate routing channel utilization using
+    return net_cost_handler_->estimate_routing_chan_util();
+}
+
 vtr::Matrix<float> calculate_routing_usage(e_rr_type rr_type, bool is_flat, bool is_print) {
     VTR_ASSERT(rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY);
 
@@ -15,21 +31,21 @@ vtr::Matrix<float> calculate_routing_usage(e_rr_type rr_type, bool is_flat, bool
 
     vtr::Matrix<float> usage({{device_ctx.grid.width(), device_ctx.grid.height()}}, 0.);
 
-    //Collect all the in-use RR nodes
+    // Collect all the in-use RR nodes
     std::set<RRNodeId> rr_nodes;
-    for (auto net : cluster_ctx.clb_nlist.nets()) {
-        auto parent_id = get_cluster_net_parent_id(g_vpr_ctx.atom().lookup(), net, is_flat);
+    for (ClusterNetId net : cluster_ctx.clb_nlist.nets()) {
+        ParentNetId parent_id = get_cluster_net_parent_id(g_vpr_ctx.atom().lookup(), net, is_flat);
 
         if (!route_ctx.route_trees[parent_id])
             continue;
-        for (auto& rt_node : route_ctx.route_trees[parent_id].value().all_nodes()) {
+        for (const RouteTreeNode& rt_node : route_ctx.route_trees[parent_id].value().all_nodes()) {
             if (rr_graph.node_type(rt_node.inode) == rr_type) {
                 rr_nodes.insert(rt_node.inode);
             }
         }
     }
 
-    //Record number of used resources in each x/y channel
+    // Record number of used resources in each x/y channel
     for (RRNodeId rr_node : rr_nodes) {
 #ifndef NO_GRAPHICS
         if (!is_print) {
@@ -66,7 +82,7 @@ vtr::Matrix<float> calculate_routing_usage(e_rr_type rr_type, bool is_flat, bool
 }
 
 vtr::Matrix<float> calculate_routing_avail(e_rr_type rr_type) {
-    //Calculate the number of available resources in each x/y channel
+    // Calculate the number of available resources in each x/y channel
     VTR_ASSERT(rr_type == e_rr_type::CHANX || rr_type == e_rr_type::CHANY);
 
     auto& device_ctx = g_vpr_ctx.device();

vpr/src/route/route_utilization.h

@@ -3,6 +3,22 @@
 #include "rr_node_types.h"
 #include "vtr_ndmatrix.h"
 
+#include "net_cost_handler.h"
+#include "placer_state.h"
+
+class RoutingChanUtilEstimator {
+  public:
+    RoutingChanUtilEstimator(const BlkLocRegistry& blk_loc_registry, bool cube_bb);
+
+    std::pair<vtr::NdMatrix<double, 3>, vtr::NdMatrix<double, 3>> estimate_routing_chan_util();
+
+  private:
+    std::unique_ptr<PlacerState> placer_state_;
+    std::unique_ptr<NetCostHandler> net_cost_handler_;
+    t_placer_opts placer_opts_;
+
+};
+
 vtr::Matrix<float> calculate_routing_avail(e_rr_type rr_type);
 
 /**
@@ -15,4 +31,5 @@ vtr::Matrix<float> calculate_routing_avail(e_rr_type rr_type);
  * drawing settings.
  */
 vtr::Matrix<float> calculate_routing_usage(e_rr_type rr_type, bool is_flat, bool is_print);
+
 float routing_util(float used, float avail);