More refactoring, commenting

Author: Nathan Shreve

utils/route_diag/src/main.cpp

@@ -130,9 +130,9 @@ 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,
+        std::tie(std::ignore, rt_node_of_sink) = tree.update_from_heap(/*htpr=*/&cheapest,
+                                                                       /*target_net_pin_index=*/OPEN,
+                                                                       /*spatial_rt_lookup=*/nullptr,
                                                                        router_opts.flat_routing,
                                                                        router.get_router_lookahead(),
                                                                        cost_params,

vpr/src/base/vpr_context.h

@@ -39,13 +39,14 @@
 #include "gateio.h"
 #include "taskresolver.h"
 
-#    include "lookahead_profiler.h"
-
 class SetupHoldTimingInfo;
 class PostClusterDelayCalculator;
 
 #endif /* NO_SERVER */
 
+// Forward declaration
+class LookaheadProfiler;
+
 /**
  * @brief A Context is collection of state relating to a particular part of VPR
  *
@@ -499,6 +500,9 @@ struct RoutingContext : public Context {
      */
     UserRouteConstraints constraints;
 
+    /**
+     * @brief Writes out information used to profile the accuracy of the router lookahead.
+     */
     LookaheadProfiler lookahead_profiler;
 };
 

vpr/src/base/vpr_types.h

@@ -1740,16 +1740,20 @@ constexpr bool is_src_sink(e_rr_type type) { return (type == SOURCE || type == S
  * @brief Extra information about each rr_node needed only during routing
  *        (i.e. during the maze expansion).
  *
- *   @param prev_edge  ID of the edge (globally unique edge ID in the RR Graph)
- *                     that was used to reach this node from the previous node.
- *                     If there is no predecessor, prev_edge = NO_PREVIOUS.
- *   @param acc_cost   Accumulated cost term from previous Pathfinder iterations.
- *   @param path_cost  Total cost of the path up to and including this node +
- *                     the expected cost to the target if the timing_driven router
- *                     is being used.
- *   @param backward_path_cost  Total cost of the path up to and including this
- *                     node.
- *   @param occ        The current occupancy of the associated rr node
+ *   @param prev_edge   ID of the edge (globally unique edge ID in the RR Graph)
+ *                      that was used to reach this node from the previous node.
+ *                      If there is no predecessor, prev_edge = NO_PREVIOUS.
+ *   @param acc_cost    Accumulated cost term from previous Pathfinder iterations.
+ *   @param path_cost   Total cost of the path up to and including this node +
+ *                      the expected cost to the target if the timing_driven router
+ *                      is being used.
+ *   @param backward_path_cost          Total cost of the path up to and including
+ *                                      this node. Recorded for LookaheadProfiler.
+ *   @param backward_path_delay         Total delay in the path up to and including
+ *                                      this node. Recorded for LookaheadProfiler.
+ *   @param backward_path_congestion    Total congestion in the path up to and
+ *                                      including this node.
+ *   @param occ         The current occupancy of the associated rr node
  */
 struct t_rr_node_route_inf {
     RREdgeId prev_edge;

vpr/src/route/connection_router.cpp

@@ -239,7 +239,12 @@ 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, cheapest->backward_path_delay, cheapest->backward_path_congestion, 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;
@@ -661,7 +666,6 @@ 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;
@@ -928,7 +932,7 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
                        rr_node_route_inf_,
                        inode,
                        tot_cost,
-                       RREdgeId::INVALID(),
+                       /*prev_edge=*/RREdgeId::INVALID(),
                        backward_path_cost,
                        backward_path_delay,
                        backward_path_congestion,

vpr/src/route/heap_type.h

@@ -18,7 +18,9 @@ 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.;
+    ///@brief The "known" delay in the path up to and including this node. Recorded for LookaheadProfiler during routing.
     float backward_path_delay = 0.;
+    ///@brief The "known" congestion in the path up to and including this node. Recorded for LookaheadProfiler during routing.
     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).

vpr/src/route/lookahead_profiler.cpp

@@ -24,14 +24,17 @@ void LookaheadProfiler::record(int iteration,
     auto& route_ctx = g_vpr_ctx.routing();
 
     // If csv file hasn't been opened, open it and write out column headers
-    if (is_empty) {
-        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");
+    if (is_empty_) {
+        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");
+            throw vtr::VtrError("Could not open lookahead_verifier_info.csv",
+                                "lookahead_profiler.cpp",
+                                32);
         }
 
-        lookahead_verifier_csv
+        lookahead_verifier_csv_
             << "iteration no."
             << ",source node"
             << ",sink node"
@@ -53,13 +56,21 @@ void LookaheadProfiler::record(int iteration,
             << ",predicted delay"
             << ",predicted congestion"
             << ",criticality"
-            << std::endl;
+            << "\n";
 
-        is_empty = false;
+        is_empty_ = false;
     }
 
-    if (!lookahead_verifier_csv.is_open())
+    if (!lookahead_verifier_csv_.is_open()) {
+        if (toggle_warn_) {
+            VTR_LOG_WARN("lookahead_verifier_info.csv is not open");
+            toggle_warn_ = false;
+        }
+
         return;
+    } else {
+        toggle_warn_ = true;
+    }
 
     // The default value in RouteTree::update_from_heap() is -1; only calls which descend from route_net()
     // pass in an iteration value, which is the only context in which we want to profile.
@@ -73,51 +84,52 @@ void LookaheadProfiler::record(int iteration,
 
     /* Get sink node attributes (atom block name, atom block model, cluster type, tile dimensions) */
 
-    if (atom_block_names.find(sink_inode) == atom_block_names.end()) {
+    if (atom_block_names_.find(sink_inode) == atom_block_names_.end()) {
         if (net_id != ParentNetId::INVALID() && target_net_pin_index != OPEN) {
-            atom_block_names[sink_inode] = net_list.block_name(net_list.net_pin_block(net_id, target_net_pin_index));
+            atom_block_names_[sink_inode] = net_list.block_name(net_list.net_pin_block(net_id, target_net_pin_index));
 
-            AtomBlockId atom_block_id = g_vpr_ctx.atom().nlist.find_block(atom_block_names[sink_inode]);
-            atom_block_models[sink_inode] = g_vpr_ctx.atom().nlist.block_model(atom_block_id)->name;
+            AtomBlockId atom_block_id = g_vpr_ctx.atom().nlist.find_block(atom_block_names_[sink_inode]);
+            atom_block_models_[sink_inode] = g_vpr_ctx.atom().nlist.block_model(atom_block_id)->name;
 
             ClusterBlockId cluster_block_id = atom_to_cluster(atom_block_id);
 
-            cluster_block_types[sink_inode] = g_vpr_ctx.clustering().clb_nlist.block_type(cluster_block_id)->name;
+            cluster_block_types_[sink_inode] = g_vpr_ctx.clustering().clb_nlist.block_type(cluster_block_id)->name;
 
             auto tile_type = physical_tile_type(cluster_block_id);
-            tile_dimensions[sink_inode] = std::pair(std::to_string(tile_type->width), std::to_string(tile_type->height));
+            tile_dimensions_[sink_inode] = std::pair(std::to_string(tile_type->width), std::to_string(tile_type->height));
         } else {
-            atom_block_names[sink_inode] = "--";
-            atom_block_models[sink_inode] = "--";
-            cluster_block_types[sink_inode] = "--";
-            tile_dimensions[sink_inode] = {"--", "--"};
+            atom_block_names_[sink_inode] = "--";
+            atom_block_models_[sink_inode] = "--";
+            cluster_block_types_[sink_inode] = "--";
+            tile_dimensions_[sink_inode] = {"--", "--"};
         }
     }
 
-    VTR_ASSERT_SAFE(atom_block_models.find(sink_inode) != atom_block_models.end());
-    VTR_ASSERT_SAFE(cluster_block_types.find(sink_inode) != cluster_block_types.end());
-    VTR_ASSERT_SAFE(tile_dimensions.find(sink_inode) != tile_dimensions.end());
+    VTR_ASSERT_SAFE(atom_block_models_.find(sink_inode) != atom_block_models_.end());
+    VTR_ASSERT_SAFE(cluster_block_types_.find(sink_inode) != cluster_block_types_.end());
+    VTR_ASSERT_SAFE(tile_dimensions_.find(sink_inode) != tile_dimensions_.end());
 
-    std::string block_name = atom_block_names[sink_inode];
-    std::string atom_block_model = atom_block_models[sink_inode];
-    std::string cluster_block_type = cluster_block_types[sink_inode];
-    auto [tile_width, tile_height] = tile_dimensions[sink_inode];
+    const std::string& block_name = atom_block_names_[sink_inode];
+    const std::string& atom_block_model = atom_block_models_[sink_inode];
+    const std::string& cluster_block_type = cluster_block_types_[sink_inode];
+    const auto& [tile_width, tile_height] = tile_dimensions_[sink_inode];
 
     /* Iterate through the given path and record information for each node */
-    for (size_t i = 2; i < branch_inodes.size(); ++i) { // Distance one node away is always 0. (IPIN->SINK)
-        RRNodeId curr_inode = branch_inodes[i];
+    for (size_t nodes_from_sink = 2; nodes_from_sink < branch_inodes.size(); ++nodes_from_sink) { // Distance one node away is always 0. (IPIN->SINK)
+        RRNodeId curr_inode = branch_inodes[nodes_from_sink];
 
-        // Get backwards path cost, delay, and congestion from sink node
-        t_rr_node_route_inf sink_node_info = route_ctx.rr_node_route_inf[sink_inode];
-        float total_backward_cost = sink_node_info.backward_path_cost;
-        float total_backward_delay = sink_node_info.backward_path_delay;
-        float total_backward_congestion = sink_node_info.backward_path_congestion;
+        // Calculate the actual cost, delay, and congestion from the current node to the sink.
+        const t_rr_node_route_inf& curr_node_info = route_ctx.rr_node_route_inf[curr_inode];
+        const t_rr_node_route_inf& sink_node_info = route_ctx.rr_node_route_inf[sink_inode];
 
-        // Get backwards path cost, delay, and congestion from current node
-        t_rr_node_route_inf curr_node_info = route_ctx.rr_node_route_inf[curr_inode];
-        float current_backward_cost = curr_node_info.backward_path_cost;
-        float current_backward_delay = curr_node_info.backward_path_delay;
-        float current_backward_congestion = curr_node_info.backward_path_congestion;
+        float actual_cost = sink_node_info.backward_path_cost - curr_node_info.backward_path_cost;
+        float actual_delay = sink_node_info.backward_path_delay - curr_node_info.backward_path_delay;
+        float actual_congestion = sink_node_info.backward_path_congestion - curr_node_info.backward_path_congestion;
+
+        // Get the cost, delay, and congestion estimates made by the lookahead.
+        // Note: lookahead_cost = lookahead_delay * criticality + lookahead_congestion * (1. - criticality)
+        float lookahead_cost = router_lookahead.get_expected_cost(curr_inode, sink_inode, cost_params, 0.0);
+        auto [lookahead_delay, lookahead_congestion] = router_lookahead.get_expected_delay_and_cong_ignore_criticality(curr_inode, sink_inode, cost_params, 0.0);
 
         // Get the difference in the coordinates in the current and sink nodes.
         // Note: we are not using util::get_xy_deltas() because this always gives positive values
@@ -129,45 +141,35 @@ void LookaheadProfiler::record(int iteration,
         int delta_x = to_x - from_x;
         int delta_y = to_y - from_y;
 
-        // Calculate the actual cost, delay, and congestion from the current node to the sink.
-        float actual_cost = total_backward_cost - current_backward_cost;
-        float actual_delay = total_backward_delay - current_backward_delay;
-        float actual_congestion = total_backward_congestion - current_backward_congestion;
-
-        // Get the cost, delay, and congestion estimates made by the lookahead.
-        // Note: lookahead_cost = lookahead_delay * criticality + lookahead_congestion * (1. - criticality)
-        float lookahead_cost = router_lookahead.get_expected_cost(curr_inode, sink_inode, cost_params, 0.0);
-        auto [lookahead_delay, lookahead_congestion] = router_lookahead.get_expected_delay_and_cong(curr_inode, sink_inode, cost_params, 0.0);
-
         // Get the current node's type and length
         std::string node_type_str = rr_graph.node_type_string(curr_inode);
-        std::string node_length = (node_type_str == "CHANX" || node_type_str == "CHANX")
+        std::string node_length = (node_type_str == "CHANX" || node_type_str == "CHANY")
                                       ? std::to_string(rr_graph.node_length(curr_inode))
                                       : "--";
 
         /* Write out all info */
 
-        lookahead_verifier_csv << iteration << ",";            // iteration no.
-        lookahead_verifier_csv << source_inode << ",";         // source node
-        lookahead_verifier_csv << sink_inode << ",";           // sink node
-        lookahead_verifier_csv << block_name << ",";           // sink block name
-        lookahead_verifier_csv << atom_block_model << ",";     // sink atom block model
-        lookahead_verifier_csv << cluster_block_type << ",";   // sink cluster block type
-        lookahead_verifier_csv << tile_height << ",";          // sink cluster tile height
-        lookahead_verifier_csv << tile_width << ",";           // sink cluster tile width
-        lookahead_verifier_csv << curr_inode << ",";           // current node
-        lookahead_verifier_csv << node_type_str << ",";        // node type
-        lookahead_verifier_csv << node_length << ",";          // node length
-        lookahead_verifier_csv << i << ",";                    // num. nodes from sink
-        lookahead_verifier_csv << delta_x << ",";              // delta x
-        lookahead_verifier_csv << delta_y << ",";              // delta y
-        lookahead_verifier_csv << actual_cost << ",";          // actual cost
-        lookahead_verifier_csv << actual_delay << ",";         // actual delay
-        lookahead_verifier_csv << actual_congestion << ",";    // actual congestion
-        lookahead_verifier_csv << lookahead_cost << ",";       // predicted cost
-        lookahead_verifier_csv << lookahead_delay << ",";      // predicted delay
-        lookahead_verifier_csv << lookahead_congestion << ","; // predicted congestion
-        lookahead_verifier_csv << cost_params.criticality;     // criticality
-        lookahead_verifier_csv << std::endl;
+        lookahead_verifier_csv_ << iteration << ",";            // iteration no.
+        lookahead_verifier_csv_ << source_inode << ",";         // source node
+        lookahead_verifier_csv_ << sink_inode << ",";           // sink node
+        lookahead_verifier_csv_ << block_name << ",";           // sink block name
+        lookahead_verifier_csv_ << atom_block_model << ",";     // sink atom block model
+        lookahead_verifier_csv_ << cluster_block_type << ",";   // sink cluster block type
+        lookahead_verifier_csv_ << tile_height << ",";          // sink cluster tile height
+        lookahead_verifier_csv_ << tile_width << ",";           // sink cluster tile width
+        lookahead_verifier_csv_ << curr_inode << ",";           // current node
+        lookahead_verifier_csv_ << node_type_str << ",";        // node type
+        lookahead_verifier_csv_ << node_length << ",";          // node length
+        lookahead_verifier_csv_ << nodes_from_sink << ",";      // num. nodes from sink
+        lookahead_verifier_csv_ << delta_x << ",";              // delta x
+        lookahead_verifier_csv_ << delta_y << ",";              // delta y
+        lookahead_verifier_csv_ << actual_cost << ",";          // actual cost
+        lookahead_verifier_csv_ << actual_delay << ",";         // actual delay
+        lookahead_verifier_csv_ << actual_congestion << ",";    // actual congestion
+        lookahead_verifier_csv_ << lookahead_cost << ",";       // predicted cost
+        lookahead_verifier_csv_ << lookahead_delay << ",";      // predicted delay
+        lookahead_verifier_csv_ << lookahead_congestion << ","; // predicted congestion
+        lookahead_verifier_csv_ << cost_params.criticality;     // criticality
+        lookahead_verifier_csv_ << "\n";
     }
 }