Disabled RCV support for RouterLookahead, comments

Author: Nathan Shreve

vpr/src/base/read_options.cpp

@@ -1677,7 +1677,8 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help(
             "For every routed sink, record 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 the file name provided. File extension must be .csv.")
+            "other attributes of the node, are recorded into the file name provided. Used to assist in debugging or validating "
+            "the router lookahead. File extension must be .csv.")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     file_grp.add_argument(args.read_placement_delay_lookup, "--read_placement_delay_lookup")

vpr/src/base/vpr_types.h

@@ -1400,6 +1400,8 @@ struct t_router_opts {
     std::string write_intra_cluster_router_lookahead;
     std::string read_intra_cluster_router_lookahead;
 
+    ///@brief The name of the output .csv file when PROFILE_LOOKAHEAD and --profile_router_lookahead are used.
+    ///If the string is empty, there will be no output.
     std::string lookahead_profiling_output;
 
     e_heap_type router_heap;
@@ -1687,6 +1689,9 @@ struct t_rr_node_route_inf {
     float path_cost;
     float backward_path_cost;
 #ifdef PROFILE_LOOKAHEAD
+    // This data is needed for the LookaheadProfiler, when enabled. It is only conditionally
+    // compiled since this struct is a hot and large data structure.
+
     ///@brief Total delay in the path up to and including this node.
     float backward_path_delay;
     ///@brief Total congestion in the path up to and including this node.

vpr/src/place/timing_place_lookup.cpp

@@ -110,6 +110,22 @@ static void generic_compute_matrix_iterative_astar(
     const std::set<std::string>& allowed_types,
     bool /***/);
 
+/**
+ * @brief Compute delta delay matrix using Djikstra's algorithm to find shortest paths from a IPIN at the
+ * source location to OPINs within (start_x, start_y) to (end_x, end_y).
+ *
+ * @param route_profiler Only used to call get_net_list(), which is passed into
+ * calculate_all_path_delays_from_rr_node(), which is needed for the LookaheadProfiler.
+ * @param matrix The matrix to be filled.
+ * @param layer_num The layer of the source and sink nodes to be sampled.
+ * @param (source_x, source_y) The coordinates of the tile to sample an IPIN at.
+ * @param (start_x, start_y, end_x, end_y) The bounds within which OPINs should be sampled.
+ * @param router_opts
+ * @param measure_directconnect Whether to measure/include direct connects.
+ * @param allowed_types The allowed tile type names for the source location. If this vector is empty, all
+ * names are allowed. If the source tile type is not allowed, the matrix is filled with EMPTY_DELTA.
+ * @param is_flat Whether flat routing is being used.
+ */
 static void generic_compute_matrix_dijkstra_expansion(
     RouterDelayProfiler& route_profiler,
     vtr::Matrix<std::vector<float>>& matrix,

vpr/src/route/connection_router.cpp

@@ -239,21 +239,10 @@ 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()) {
-#ifdef PROFILE_LOOKAHEAD
-                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);
-#else
                 rcv_path_manager.insert_backwards_path_into_traceback(cheapest->path_data,
                                                                       cheapest->cost,
                                                                       cheapest->backward_path_cost,
-                                                                      /*backward_path_delay=*/0.f,
-                                                                      /*backward_path_congestion=*/0.f,
                                                                       route_ctx);
-#endif
             }
             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;
@@ -947,15 +936,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());
 
-#ifdef PROFILE_LOOKAHEAD
+#ifndef PROFILE_LOOKAHEAD
         push_back_node(&heap_,
                        rr_node_route_inf_,
                        inode,
                        tot_cost,
                        /*prev_edge=*/RREdgeId::INVALID(),
                        backward_path_cost,
-                       backward_path_delay,
-                       backward_path_congestion,
+                       /*backward_path_delay=*/0.f,
+                       /*backward_path_congestion=*/0.f,
                        R_upstream);
 #else
         push_back_node(&heap_,
@@ -964,8 +953,8 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
                        tot_cost,
                        /*prev_edge=*/RREdgeId::INVALID(),
                        backward_path_cost,
-                       /*backward_path_delay=*/0.f,
-                       /*backward_path_congestion=*/0.f,
+                       backward_path_delay,
+                       backward_path_congestion,
                        R_upstream);
 #endif
     } else {

vpr/src/route/heap_type.h

@@ -19,6 +19,9 @@ struct t_heap {
     ///.cost member contains not only the known backward cost but also an expected cost to the target.
     float backward_path_cost = 0.;
 #ifdef PROFILE_LOOKAHEAD
+    // This data is needed for the LookaheadProfiler, when enabled. It is only conditionally
+    // compiled since there may be many instances of this struct and it is in hot code.
+
     ///@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.

vpr/src/route/lookahead_profiler.cpp

@@ -55,6 +55,24 @@ void LookaheadProfiler::record(int iteration,
                                const ParentNetId& net_id,
                                const Netlist<>& net_list,
                                const std::vector<RRNodeId>& branch_inodes) {
+    /**
+     * This function records data into the output file created in set_file_name(). If that file name was
+     * an empty string, this function returns. If the output file is not open, VPR will throw an error.
+     *
+     * First, we get the RRNodeIds of the sink and source nodes (assumed to be the beginning and end of
+     * branch_inodes, respectively.
+     *
+     * Next, using net_id, net_list, and target_net_pin_index, we obtain the name of the atom block,
+     * the name of the type of atom block, the name of the type of cluster block, and the tile dimensions
+     * where the sink node is located.
+     *
+     * We then iterate through all other nodes in branch_inodes and calculate the expected and actual cost,
+     * congestion, and delay from the current node to the sink node, as well as the current node type and
+     * length, and the xy-deltas to the sink node.
+     *
+     * Finally, all this information is written to the output .csv file.
+     */
+
     if (!enabled_)
         return;
 
@@ -162,7 +180,7 @@ void LookaheadProfiler::record(int iteration,
         lookahead_verifier_csv_ << "\n";
     }
 #else
-    throw vtr::VtrError("Profiler enabled, but PROFILE_LOOKAHEAD not defined.", "lookahead_profiler.cpp", 165);
+    throw vtr::VtrError("Profiler enabled, but PROFILE_LOOKAHEAD not defined.", "lookahead_profiler.cpp", 183);
     (void)iteration;
     (void)target_net_pin_index;
     (void)cost_params;

vpr/src/route/lookahead_profiler.h

@@ -13,7 +13,7 @@
  * well as the lookahead's estimation of this cost.
  *
  * @warning
- * To use the LookaheadProfiler, you must build VPR with #define PROFILE_LOOKAHEAD.
+ * To use the LookaheadProfiler, you must build VPR with CMAKE_PARAMS="-DVPR_PROFILE_LOOKAHEAD=on".
  */
 class LookaheadProfiler {
   public:
@@ -38,10 +38,13 @@ class LookaheadProfiler {
      *
      * @param iteration The router iteration.
      * @param target_net_pin_index Target pin of this sink in the net.
-     * @param cost_params
-     * @param router_lookahead
-     * @param net_id
-     * @param net_list
+     * @param cost_params Passed into router_lookahead's methods to obtain expected cost,
+     * delay, and congestion.
+     * @param router_lookahead Its methods are called to obtain the expected cost, delay,
+     * and congestion to the node represented by target_net_pin_index from all other nodes
+     * in branch_inodes.
+     * @param net_id Used to obtain atom and cluster block IDs.
+     * @param net_list Used to obtain atom and cluster block IDs.
      * @param branch_inodes A backwards path of nodes, starting at a sink.
      *
      * @warning

vpr/src/route/route_common.h

@@ -145,14 +145,30 @@ float get_cost_from_lookahead(const RouterLookahead& router_lookahead,
                               const t_conn_cost_params cost_params,
                               bool is_flat);
 
-/* Creates a new t_heap object to be placed on the heap, if the new cost    *
- * given is lower than the current path_cost to this channel segment.  The  *
- * index of its predecessor is stored to make traceback easy.  The index of *
- * the edge used to get from its predecessor to it is also stored to make   *
- * timing analysis, etc.                                                    *
- *                                                                          *
- * Returns t_heap suitable for adding to heap or nullptr if node is more    *
- * expensive than previously explored path.                                 */
+/**
+ * @brief Creates a new t_heap object to be placed on the heap, if the new cost
+ * given is lower than the current path_cost to this channel segment. The index
+ * of its predecessor is stored to make traceback easy. The index of the edge
+ * used to get from its predecessor to it is also stored to make timing analysis,
+ * etc.
+ *
+ * @tparam T
+ * @tparam RouteInf
+ * @param heap
+ * @param rr_node_route_inf
+ * @param inode
+ * @param total_cost
+ * @param prev_edge
+ * @param backward_path_cost
+ * @param backward_path_delay The known backward path delay used to calculate
+ * backward_path_cost. Only used for RouterLookahead, when enabled.
+ * @param backward_path_congestion The known backward path congestion used to
+ * calculate backward_path_cost. Only used for RouterLookahead, when enabled.
+ * @param R_upstream
+ *
+ * @return t_heap suitable for adding to heap or nullptr if node is more expensive
+ * than previously explored path.
+ */
 template<typename T, typename RouteInf>
 t_heap* prepare_to_add_node_to_heap(
     T* heap,
@@ -173,12 +189,12 @@ t_heap* prepare_to_add_node_to_heap(
     hptr->cost = total_cost;
     hptr->set_prev_edge(prev_edge);
     hptr->backward_path_cost = backward_path_cost;
-#ifdef PROFILE_LOOKAHEAD
-    hptr->backward_path_delay = backward_path_delay;
-    hptr->backward_path_congestion = backward_path_congestion;
-#else
+#ifndef PROFILE_LOOKAHEAD
     (void)backward_path_delay;
     (void)backward_path_congestion;
+#else
+    hptr->backward_path_delay = backward_path_delay;
+    hptr->backward_path_congestion = backward_path_congestion;
 #endif
     hptr->R_upstream = R_upstream;
     return hptr;

vpr/src/route/route_path_manager.cpp

@@ -42,8 +42,6 @@ void PathManager::mark_node_visited(RRNodeId node) {
 void PathManager::insert_backwards_path_into_traceback(t_heap_path* path_data,
                                                        float cost,
                                                        float backward_path_cost,
-                                                       float backward_path_delay,
-                                                       float backward_path_congestion,
                                                        RoutingContext& route_ctx) {
     if (!is_enabled_) return;
 
@@ -53,13 +51,6 @@ void PathManager::insert_backwards_path_into_traceback(t_heap_path* path_data,
         route_ctx.rr_node_route_inf[node_2].prev_edge = edge;
         route_ctx.rr_node_route_inf[node_2].path_cost = cost;
         route_ctx.rr_node_route_inf[node_2].backward_path_cost = backward_path_cost;
-#ifdef PROFILE_LOOKAHEAD
-        route_ctx.rr_node_route_inf[node_2].backward_path_delay = backward_path_delay;
-        route_ctx.rr_node_route_inf[node_2].backward_path_congestion = backward_path_congestion;
-#else
-        (void)backward_path_delay;
-        (void)backward_path_congestion;
-#endif
     }
 }
 

vpr/src/route/route_path_manager.h

@@ -77,8 +77,6 @@ class PathManager {
     void insert_backwards_path_into_traceback(t_heap_path* path_data,
                                               float cost,
                                               float backward_path_cost,
-                                              float backward_path_delay,
-                                              float backward_path_congestion,
                                               RoutingContext& route_ctx);
 
     // Dynamically create a t_heap_path structure to be used in the heap

vpr/src/route/route_tree.cpp

@@ -491,7 +491,7 @@ RouteTree::update_from_heap(t_heap* hptr,
                             SpatialRouteTreeLookup* spatial_rt_lookup,
                             bool is_flat,
                             const RouterLookahead& router_lookahead,
-                            const t_conn_cost_params cost_params,
+                            const t_conn_cost_params& cost_params,
                             const Netlist<>& net_list,
                             const ParentNetId& net_id,
                             const int itry) {
@@ -534,7 +534,7 @@ 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 t_conn_cost_params& cost_params,
                                  const int itry,
                                  const Netlist<>& net_list,
                                  const ParentNetId& net_id) {

vpr/src/route/route_tree.h

@@ -350,23 +350,34 @@ class RouteTree {
         free_list(_root);
     }
 
-    /** Add the most recently finished wire segment to the routing tree, and
-     * update the Tdel, etc. numbers for the rest of the routing tree. hptr
-     * is the heap pointer of the SINK that was reached, and target_net_pin_index
-     * is the net pin index corresponding to the SINK that was reached. 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.
-     * Locking operation: only one thread can update_from_heap() a RouteTree at a time. */
+    /**
+     * @brief Add the most recently finished wire segment to the routing tree, and update the
+     * Tdel, etc. numbers for the rest of the routing tree.
+     *
+     * @param hptr The heap pointer of the SINK that was reached.
+     * @param target_net_pin_index The net pin index corresponding to the SINK that was reached.
+     * @param spatial_rt_lookup
+     * @param is_flat
+     * @param router_lookahead Only needed for the LookaheadProfiler.
+     * @param cost_params Only needed for the LookaheadProfiler.
+     * @param net_list Only needed for the LookaheadProfiler.
+     * @param net_id Only needed for the LookaheadProfiler.
+     * @param itry Only needed for the LookaheadProfiler. If this function is called outside of
+     * the router loop, this argument does not need to be specified.
+     *
+     * @return 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&>>
     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 t_conn_cost_params& cost_params,
                      const Netlist<>& net_list,
                      const ParentNetId& net_id,
-                     const int itry = -1);
+                     int itry = -1);
 
     /** Reload timing values (R_upstream, C_downstream, Tdel).
      * Can take a RouteTreeNode& to do an incremental update.
@@ -504,7 +515,7 @@ class RouteTree {
                           int target_net_pin_index,
                           bool is_flat,
                           const RouterLookahead& router_lookahead,
-                          const t_conn_cost_params cost_params,
+                          const t_conn_cost_params& cost_params,
                           const int itry,
                           const Netlist<>& net_list,
                           const ParentNetId& net_id);

vpr/src/route/router_delay_profiling.cpp

@@ -149,11 +149,11 @@ bool RouterDelayProfiler::calculate_delay(RRNodeId source_node,
 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];
 }
+
 const Netlist<>& RouterDelayProfiler::get_net_list() const {
     return net_list_;
 }
 
-//Returns the shortest path delay from src_node to all RR nodes in the RR graph, or NaN if no path exists
 vtr::vector<RRNodeId, float> calculate_all_path_delays_from_rr_node(RRNodeId src_rr_node,
                                                                     const t_router_opts& router_opts,
                                                                     bool is_flat,

vpr/src/route/router_delay_profiling.h

@@ -56,6 +56,9 @@ class RouterDelayProfiler {
     bool is_flat_;
 };
 
+/**
+ * @brief Returns the shortest path delay from src_node to all RR nodes in the RR graph, or NaN if no path exists.
+ */
 vtr::vector<RRNodeId, float> calculate_all_path_delays_from_rr_node(RRNodeId src_rr_node,
                                                                     const t_router_opts& router_opts,
                                                                     bool is_flat,

vpr/src/route/router_lookahead.cpp

@@ -78,7 +78,10 @@ float ClassicLookahead::get_expected_cost(RRNodeId current_node, RRNodeId target
     return delay_cost + cong_cost;
 }
 
-std::pair<float, float> ClassicLookahead::get_expected_delay_and_cong_ignore_criticality(RRNodeId node, RRNodeId target_node, const t_conn_cost_params& /*params*/, float R_upstream) const {
+std::pair<float, float> ClassicLookahead::get_expected_delay_and_cong_ignore_criticality(RRNodeId node,
+                                                                                         RRNodeId target_node,
+                                                                                         const t_conn_cost_params& /*params*/,
+                                                                                         float R_upstream) const {
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;