Added command-line option for profiler

Author: Nathan Shreve

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, router.get_router_lookahead(), cost_params, -1, net_list, conn_params.net_id_);
+        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(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_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;

vpr/src/route/lookahead_profiler.cpp

@@ -15,7 +15,8 @@ LookaheadProfiler::LookaheadProfiler() {
     lookahead_verifier_csv.open("lookahead_verifier_info.csv", std::ios::out);
 
     if (!lookahead_verifier_csv.is_open()) {
-        VTR_LOG_ERROR("Could not open lookahead_verifier_info.csv", "error");
+        VTR_LOG_WARN("Could not open lookahead_verifier_info.csv");
+        return;
     }
 
     lookahead_verifier_csv
@@ -54,6 +55,9 @@ void LookaheadProfiler::record(int iteration,
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.routing();
 
+    if (!lookahead_verifier_csv.is_open())
+        return;
+
     if (iteration < 1)
         return;
 

vpr/src/route/route_net.tpp

@@ -190,7 +190,8 @@ inline NetResultFlags route_net(ConnectionRouter& router,
                                             spatial_route_tree_lookup,
                                             router_stats,
                                             is_flat,
-                                            itry);
+                                            itry,
+                                            router_opts);
 
             if (flags.success == false)
                 return flags;
@@ -298,7 +299,8 @@ inline NetResultFlags pre_route_to_clock_root(ConnectionRouter& router,
                                               SpatialRouteTreeLookup& spatial_rt_lookup,
                                               RouterStats& router_stats,
                                               bool is_flat,
-                                              int itry) {
+                                              int itry,
+                                              const t_router_opts& router_opts) {
     const auto& device_ctx = g_vpr_ctx.device();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     auto& m_route_ctx = g_vpr_ctx.mutable_routing();
@@ -354,8 +356,16 @@ inline NetResultFlags pre_route_to_clock_root(ConnectionRouter& router,
      * points. Therefore, we can set the net pin index of the sink node to      *
      * OPEN (meaning illegal) as it is not meaningful for this sink.            */
     vtr::optional<const RouteTreeNode&> new_branch, new_sink;
-    std::tie(new_branch, new_sink) = tree.update_from_heap(&cheapest, OPEN, ((high_fanout) ? &spatial_rt_lookup : nullptr), is_flat, router.get_router_lookahead(), cost_params, itry, net_list,
-                                                           conn_params.net_id_);
+    std::tie(new_branch, new_sink) = tree.update_from_heap(&cheapest,
+                                                           OPEN,
+                                                           ((high_fanout) ? &spatial_rt_lookup : nullptr),
+                                                           is_flat,
+                                                           router.get_router_lookahead(),
+                                                           cost_params,
+                                                           net_list,
+                                                           conn_params.net_id_,
+                                                           itry,
+                                                           router_opts.router_lookahead_profiling);
 
     VTR_ASSERT_DEBUG(!high_fanout || validate_route_tree_spatial_lookup(tree.root(), spatial_rt_lookup));
 
@@ -483,7 +493,16 @@ inline NetResultFlags route_sink(ConnectionRouter& router,
     profiling::sink_criticality_end(cost_params.criticality);
 
     vtr::optional<const RouteTreeNode&> new_branch, new_sink;
-    std::tie(new_branch, new_sink) = tree.update_from_heap(&cheapest, target_pin, ((high_fanout) ? &spatial_rt_lookup : nullptr), is_flat, router.get_router_lookahead(), cost_params, itry, net_list, conn_params.net_id_);
+    std::tie(new_branch, new_sink) = tree.update_from_heap(&cheapest,
+                                                           target_pin,
+                                                           ((high_fanout) ? &spatial_rt_lookup : nullptr),
+                                                           is_flat,
+                                                           router.get_router_lookahead(),
+                                                           cost_params,
+                                                           net_list,
+                                                           conn_params.net_id_,
+                                                           itry,
+                                                           router_opts.router_lookahead_profiling);
 
     VTR_ASSERT_DEBUG(!high_fanout || validate_route_tree_spatial_lookup(tree.root(), spatial_rt_lookup));
 

vpr/src/route/route_tree.cpp

@@ -486,13 +486,22 @@ void RouteTree::print(void) const {
  * This routine returns a tuple: RouteTreeNode of the branch it adds to the route tree and
  * RouteTreeNode of the SINK it adds to the routing. */
 std::tuple<vtr::optional<const RouteTreeNode&>, vtr::optional<const RouteTreeNode&>>
-RouteTree::update_from_heap(t_heap* hptr, int target_net_pin_index, SpatialRouteTreeLookup* spatial_rt_lookup, bool is_flat, const RouterLookahead& router_lookahead, const t_conn_cost_params cost_params, const int itry, const Netlist<>& net_list, const ParentNetId& net_id) {
+RouteTree::update_from_heap(t_heap* hptr,
+                            int target_net_pin_index,
+                            SpatialRouteTreeLookup* spatial_rt_lookup,
+                            bool is_flat,
+                            const RouterLookahead& router_lookahead,
+                            const t_conn_cost_params cost_params,
+                            const Netlist<>& net_list,
+                            const ParentNetId& net_id,
+                            const int itry,
+                            bool profile_lookahead) {
     /* Lock the route tree for writing. At least on Linux this shouldn't have an impact on single-threaded code */
     std::unique_lock<std::mutex> write_lock(_write_mutex);
 
     //Create a new subtree from the target in hptr to existing routing
     vtr::optional<RouteTreeNode&> start_of_new_subtree_rt_node, sink_rt_node;
-    std::tie(start_of_new_subtree_rt_node, sink_rt_node) = add_subtree_from_heap(hptr, target_net_pin_index, is_flat, router_lookahead, cost_params, itry, net_list, net_id);
+    std::tie(start_of_new_subtree_rt_node, sink_rt_node) = add_subtree_from_heap(hptr, target_net_pin_index, is_flat, router_lookahead, cost_params, itry, net_list, net_id, profile_lookahead);
 
     if (!start_of_new_subtree_rt_node)
         return {vtr::nullopt, *sink_rt_node};
@@ -515,7 +524,15 @@ RouteTree::update_from_heap(t_heap* hptr, int target_net_pin_index, SpatialRoute
  * to the SINK indicated by hptr. Returns the first (most upstream) new rt_node,
  * and the rt_node of the new SINK. Traverses up from SINK  */
 std::tuple<vtr::optional<RouteTreeNode&>, vtr::optional<RouteTreeNode&>>
-RouteTree::add_subtree_from_heap(t_heap* hptr, int target_net_pin_index, bool is_flat, const RouterLookahead& router_lookahead, const t_conn_cost_params cost_params, const int itry, const Netlist<>& net_list, const ParentNetId& net_id) {
+RouteTree::add_subtree_from_heap(t_heap* hptr,
+                                 int target_net_pin_index,
+                                 bool is_flat,
+                                 const RouterLookahead& router_lookahead,
+                                 const t_conn_cost_params cost_params,
+                                 const int itry,
+                                 const Netlist<>& net_list,
+                                 const ParentNetId& net_id,
+                                 bool profile_lookahead) {
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.routing();
@@ -549,12 +566,15 @@ RouteTree::add_subtree_from_heap(t_heap* hptr, int target_net_pin_index, bool is
     }
     new_branch_iswitches.push_back(new_iswitch);
 
-    g_vpr_ctx.mutable_routing().lookahead_profiler.record(itry,
-                                                          target_net_pin_index,
-                                                          cost_params,
-                                                          router_lookahead,
-                                                          net_id,
-                                                          net_list, std::vector<RRNodeId>());
+    if (profile_lookahead) {
+        g_vpr_ctx.mutable_routing().lookahead_profiler.record(itry,
+                                                              target_net_pin_index,
+                                                              cost_params,
+                                                              router_lookahead,
+                                                              net_id,
+                                                              net_list,
+                                                              new_branch_inodes);
+    }
 
     /* Build the new tree branch starting from the existing node we found */
     RouteTreeNode* last_node = _rr_node_to_rt_node[new_inode];

vpr/src/route/route_tree.h

@@ -358,7 +358,16 @@ class RouteTree {
      * RouteTreeNode of the SINK it adds to the routing.
      * Locking operation: only one thread can update_from_heap() a RouteTree at a time. */
     std::tuple<vtr::optional<const RouteTreeNode&>, vtr::optional<const RouteTreeNode&>>
-    update_from_heap(t_heap* hptr, int target_net_pin_index, SpatialRouteTreeLookup* spatial_rt_lookup, bool is_flat, const RouterLookahead& router_lookahead, const t_conn_cost_params cost_params, const int itry, const Netlist<>& net_list, const ParentNetId& net_id);
+    update_from_heap(t_heap* hptr,
+                     int target_net_pin_index,
+                     SpatialRouteTreeLookup* spatial_rt_lookup,
+                     bool is_flat,
+                     const RouterLookahead& router_lookahead,
+                     t_conn_cost_params cost_params,
+                     const Netlist<>& net_list,
+                     const ParentNetId& net_id,
+                     int itry = -1,
+                     bool profile_lookahead = false);
 
     /** Reload timing values (R_upstream, C_downstream, Tdel).
      * Can take a RouteTreeNode& to do an incremental update.
@@ -492,7 +501,15 @@ class RouteTree {
 
   private:
     std::tuple<vtr::optional<RouteTreeNode&>, vtr::optional<RouteTreeNode&>>
-    add_subtree_from_heap(t_heap* hptr, int target_net_pin_index, bool is_flat, const RouterLookahead& router_lookahead, const t_conn_cost_params cost_params, const int itry, const Netlist<>& net_list, const ParentNetId& net_id);
+    add_subtree_from_heap(t_heap* hptr,
+                          int target_net_pin_index,
+                          bool is_flat,
+                          const RouterLookahead& router_lookahead,
+                          const t_conn_cost_params cost_params,
+                          const int itry,
+                          const Netlist<>& net_list,
+                          const ParentNetId& net_id,
+                          bool profile_lookahead);
 
     void add_non_configurable_nodes(RouteTreeNode* rt_node,
                                     bool reached_by_non_configurable_edge,

vpr/src/route/router_delay_profiling.cpp

@@ -121,7 +121,14 @@ bool RouterDelayProfiler::calculate_delay(RRNodeId source_node,
         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, is_flat_, router_.get_router_lookahead(), cost_params, -1, net_list_, conn_params.net_id_);
+        std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&cheapest,
+                                                                       OPEN,
+                                                                       nullptr,
+                                                                       is_flat_,
+                                                                       router_.get_router_lookahead(),
+                                                                       cost_params,
+                                                                       net_list_,
+                                                                       conn_params.net_id_);
 
         //find delay
         *net_delay = rt_node_of_sink->Tdel;
@@ -208,7 +215,14 @@ vtr::vector<RRNodeId, float> calculate_all_path_delays_from_rr_node(RRNodeId src
             //Build the routing tree to get the delay
             tree = RouteTree(RRNodeId(src_rr_node));
             vtr::optional<const RouteTreeNode&> rt_node_of_sink;
-            std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&shortest_paths[sink_rr_node], OPEN, nullptr, router_opts.flat_routing, router.get_router_lookahead(), cost_params, -1, net_list, conn_params.net_id_);
+            std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(&shortest_paths[sink_rr_node],
+                                                                           OPEN,
+                                                                           nullptr,
+                                                                           router_opts.flat_routing,
+                                                                           router.get_router_lookahead(),
+                                                                           cost_params,
+                                                                           net_list,
+                                                                           conn_params.net_id_);
 
             VTR_ASSERT(rt_node_of_sink->inode == RRNodeId(sink_rr_node));
 

vpr/src/route/router_lookahead_compressed_map.cpp

@@ -422,7 +422,7 @@ float CompressedMapLookahead::get_expected_cost(RRNodeId current_node, RRNodeId
     }
 }
 
-std::pair<float, float> CompressedMapLookahead::get_expected_delay_and_cong(RRNodeId from_node, RRNodeId to_node, const t_conn_cost_params& params, float) const {
+std::pair<float, float> CompressedMapLookahead::get_expected_delay_and_cong(RRNodeId from_node, RRNodeId to_node, const t_conn_cost_params& /*params*/, float) const {
     auto& device_ctx = g_vpr_ctx.device();
     auto& rr_graph = device_ctx.rr_graph;
 

vpr/test/test_connection_router.cpp

@@ -87,7 +87,14 @@ static float do_one_route(RRNodeId source_node,
 
         // Get the delay
         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, router.get_router_lookahead(), cost_params, -1, net_list, conn_params.net_id_);
+        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_);
         delay = rt_node_of_sink.value().Tdel;
     }