[WIP] Router Lookahead Profiler

utils/route_diag/src/main.cpp

@@ -130,7 +130,14 @@ static void do_one_route(const Netlist<>& net_list,
         VTR_ASSERT(cheapest.index == sink_node);
 
         vtr::optional<const RouteTreeNode&> rt_node_of_sink;
-        std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&cheapest, OPEN, nullptr, router_opts.flat_routing);
+        std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&cheapest,
+                                                                       OPEN,
+                                                                       nullptr,
+                                                                       router_opts.flat_routing,
+                                                                       router.get_router_lookahead(),
+                                                                       cost_params,
+                                                                       net_list,
+                                                                       conn_params.net_id_);
 
         //find delay
         float net_delay = rt_node_of_sink.value().Tdel;

vpr/src/base/SetupVPR.cpp

@@ -473,6 +473,7 @@ static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts)
     RouterOpts->router_debug_sink_rr = Options.router_debug_sink_rr;
     RouterOpts->router_debug_iteration = Options.router_debug_iteration;
     RouterOpts->lookahead_type = Options.router_lookahead_type;
+    RouterOpts->router_lookahead_profiling = Options.router_lookahead_profiler;
     RouterOpts->max_convergence_count = Options.router_max_convergence_count;
     RouterOpts->reconvergence_cpd_threshold = Options.router_reconvergence_cpd_threshold;
     RouterOpts->initial_timing = Options.router_initial_timing;

vpr/src/base/read_options.cpp

@@ -2626,6 +2626,14 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("map")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument<bool, ParseOnOff>(args.router_lookahead_profiler, "--router_lookahead_profiler")
+        .help(
+            "For every routed sink, records the cost, delay, and congestion estimated by the router lookahead and the "
+            "actual cost, delay, and congestion, from every node along each route to the sink. These results, along with many "
+            "other attributes of the node, are recorded into lookahead_verifier_info.csv.")
+        .default_value("off")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     route_timing_grp.add_argument(args.router_max_convergence_count, "--router_max_convergence_count")
         .help(
             "Controls how many times the router is allowed to converge to a legal routing before halting."

vpr/src/base/read_options.h

@@ -238,6 +238,7 @@ struct t_options {
     argparse::ArgValue<int> router_debug_sink_rr;
     argparse::ArgValue<int> router_debug_iteration;
     argparse::ArgValue<e_router_lookahead> router_lookahead_type;
+    argparse::ArgValue<bool> router_lookahead_profiler;
     argparse::ArgValue<int> router_max_convergence_count;
     argparse::ArgValue<float> router_reconvergence_cpd_threshold;
     argparse::ArgValue<bool> router_update_lower_bound_delays;

vpr/src/base/vpr_context.h

@@ -39,6 +39,8 @@
 #include "gateio.h"
 #include "taskresolver.h"
 
+#    include "lookahead_profiler.h"
+
 class SetupHoldTimingInfo;
 class PostClusterDelayCalculator;
 
@@ -496,6 +498,8 @@ struct RoutingContext : public Context {
      * @brief User specified routing constraints
      */
     UserRouteConstraints constraints;
+
+    LookaheadProfiler lookahead_profiler;
 };
 
 /**

vpr/src/base/vpr_types.h

@@ -1458,6 +1458,7 @@ struct t_router_opts {
     int router_debug_sink_rr;
     int router_debug_iteration;
     e_router_lookahead lookahead_type;
+    bool router_lookahead_profiling;
     int max_convergence_count;
     float reconvergence_cpd_threshold;
     e_router_initial_timing initial_timing;
@@ -1756,6 +1757,8 @@ struct t_rr_node_route_inf {
     float acc_cost;
     float path_cost;
     float backward_path_cost;
+    float backward_path_delay;
+    float backward_path_congestion;
 
   public: //Accessors
     short occ() const { return occ_; }

vpr/src/place/timing_place_lookup.cpp

@@ -442,7 +442,7 @@ static void add_delay_to_matrix(
 }
 
 static void generic_compute_matrix_dijkstra_expansion(
-    RouterDelayProfiler& /*route_profiler*/,
+    RouterDelayProfiler& route_profiler,
     vtr::Matrix<std::vector<float>>& matrix,
     int layer_num,
     int source_x,
@@ -490,7 +490,7 @@ static void generic_compute_matrix_dijkstra_expansion(
         RRNodeId source_rr_node = device_ctx.rr_graph.node_lookup().find_node(layer_num, source_x, source_y, SOURCE, driver_ptc);
 
         VTR_ASSERT(source_rr_node != RRNodeId::INVALID());
-        auto delays = calculate_all_path_delays_from_rr_node(source_rr_node, router_opts, is_flat);
+        auto delays = calculate_all_path_delays_from_rr_node(source_rr_node, router_opts, is_flat, route_profiler.get_net_list());
 
         bool path_to_all_sinks = true;
         for (int sink_x = start_x; sink_x <= end_x; sink_x++) {

vpr/src/route/connection_router.cpp

@@ -239,7 +239,7 @@ t_heap* ConnectionRouter<Heap>::timing_driven_route_connection_from_heap(RRNodeI
             // This is then placed into the traceback so that the correct path is returned
             // TODO: This can be eliminated by modifying the actual traceback function in route_timing
             if (rcv_path_manager.is_enabled()) {
-                rcv_path_manager.insert_backwards_path_into_traceback(cheapest->path_data, cheapest->cost, cheapest->backward_path_cost, route_ctx);
+                rcv_path_manager.insert_backwards_path_into_traceback(cheapest->path_data, cheapest->cost, cheapest->backward_path_cost, cheapest->backward_path_delay, cheapest->backward_path_congestion, route_ctx);
             }
             VTR_LOGV_DEBUG(router_debug_, "  Found target %8d (%s)\n", inode, describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, inode, is_flat_).c_str());
             break;
@@ -552,6 +552,8 @@ void ConnectionRouter<Heap>::timing_driven_add_to_heap(const t_conn_cost_params&
     // Costs initialized to current
     next.cost = std::numeric_limits<float>::infinity(); //Not used directly
     next.backward_path_cost = current->backward_path_cost;
+    next.backward_path_delay = current->backward_path_delay;
+    next.backward_path_congestion = current->backward_path_congestion;
 
     // path_data variables are initialized to current values
     if (rcv_path_manager.is_enabled() && current->path_data) {
@@ -597,6 +599,8 @@ void ConnectionRouter<Heap>::timing_driven_add_to_heap(const t_conn_cost_params&
         next_ptr->cost = next.cost;
         next_ptr->R_upstream = next.R_upstream;
         next_ptr->backward_path_cost = next.backward_path_cost;
+        next_ptr->backward_path_delay = next.backward_path_delay;
+        next_ptr->backward_path_congestion = next.backward_path_congestion;
         next_ptr->index = to_node;
         next_ptr->set_prev_edge(from_edge);
 
@@ -657,6 +661,7 @@ float ConnectionRouter<Heap>::compute_node_cost_using_rcv(const t_conn_cost_para
     // TODO: This function is not tested for is_flat == true
     VTR_ASSERT(is_flat_ != true);
     std::tie(expected_delay, expected_cong) = router_lookahead_.get_expected_delay_and_cong(to_node, target_node, cost_params, R_upstream);
+    router_lookahead_.scale_delay_and_cong_by_criticality(expected_delay, expected_cong, cost_params);
 
     float expected_total_delay_cost;
     float expected_total_cong_cost;
@@ -784,6 +789,8 @@ void ConnectionRouter<Heap>::evaluate_timing_driven_node_costs(t_heap* to,
     //Update the backward cost (upstream already included)
     to->backward_path_cost += (1. - cost_params.criticality) * cong_cost; //Congestion cost
     to->backward_path_cost += cost_params.criticality * Tdel;             //Delay cost
+    to->backward_path_delay += Tdel;
+    to->backward_path_congestion += cong_cost;
 
     if (cost_params.bend_cost != 0.) {
         t_rr_type from_type = rr_graph_->node_type(from_node);
@@ -832,6 +839,8 @@ void ConnectionRouter<Heap>::empty_heap_annotating_node_route_inf() {
 
         rr_node_route_inf_[tmp->index].path_cost = tmp->cost;
         rr_node_route_inf_[tmp->index].backward_path_cost = tmp->backward_path_cost;
+        rr_node_route_inf_[tmp->index].backward_path_delay = tmp->backward_path_delay;
+        rr_node_route_inf_[tmp->index].backward_path_congestion = tmp->backward_path_congestion;
         modified_rr_node_inf_.push_back(tmp->index);
 
         rcv_path_manager.free_path_struct(tmp->path_data);
@@ -892,6 +901,8 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
     const auto& device_ctx = g_vpr_ctx.device();
     const RRNodeId inode = rt_node.inode;
     float backward_path_cost = cost_params.criticality * rt_node.Tdel;
+    float backward_path_delay = rt_node.Tdel;
+    float backward_path_congestion = 0.0;
     float R_upstream = rt_node.R_upstream;
 
     /* Don't push to heap if not in bounding box: no-op for serial router, important for parallel router */
@@ -913,9 +924,15 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
                        tot_cost,
                        describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, inode, is_flat_).c_str());
 
-        push_back_node(&heap_, rr_node_route_inf_,
-                       inode, tot_cost, RREdgeId::INVALID(),
-                       backward_path_cost, R_upstream);
+        push_back_node(&heap_,
+                       rr_node_route_inf_,
+                       inode,
+                       tot_cost,
+                       RREdgeId::INVALID(),
+                       backward_path_cost,
+                       backward_path_delay,
+                       backward_path_congestion,
+                       R_upstream);
     } else {
         float expected_total_cost = compute_node_cost_using_rcv(cost_params, inode, target_node, rt_node.Tdel, 0, R_upstream);
 

vpr/src/route/connection_router.h

@@ -127,6 +127,11 @@ class ConnectionRouter : public ConnectionRouterInterface {
     // Ensure route budgets have been calculated before enabling this
     void set_rcv_enabled(bool enable) final;
 
+    // Get a const reference to the router's lookahead
+    const RouterLookahead& get_router_lookahead() const {
+        return router_lookahead_;
+    }
+
   private:
     // Mark that data associated with rr_node "inode" has been modified, and
     // needs to be reset in reset_path_costs.
@@ -148,6 +153,8 @@ class ConnectionRouter : public ConnectionRouterInterface {
         route_inf->prev_edge = cheapest->prev_edge();
         route_inf->path_cost = cheapest->cost;
         route_inf->backward_path_cost = cheapest->backward_path_cost;
+        route_inf->backward_path_delay = cheapest->backward_path_delay;
+        route_inf->backward_path_congestion = cheapest->backward_path_congestion;
     }
 
     /** Common logic from timing_driven_route_connection_from_route_tree and

vpr/src/route/heap_type.cpp

@@ -27,6 +27,8 @@ HeapStorage::alloc() {
     temp_ptr->set_next_heap_item(nullptr);
     temp_ptr->cost = 0.;
     temp_ptr->backward_path_cost = 0.;
+    temp_ptr->backward_path_delay = 0.;
+    temp_ptr->backward_path_congestion = 0.;
     temp_ptr->R_upstream = 0.;
     temp_ptr->index = RRNodeId::INVALID();
     temp_ptr->path_data = nullptr;

vpr/src/route/heap_type.h

@@ -18,6 +18,8 @@ struct t_heap {
     ///@brief The "known" cost of the path up to and including this node. Used only by the timing-driven router. In this case, the
     ///.cost member contains not only the known backward cost but also an expected cost to the target.
     float backward_path_cost = 0.;
+    float backward_path_delay = 0.;
+    float backward_path_congestion = 0.;
     ///@brief Used only by the timing-driven router. Stores the upstream resistance to ground from this node, including the resistance
     /// of the node itself (device_ctx.rr_nodes[index].R).
     float R_upstream = 0.;