[Route][Types] Removed prev_node from t_rr_node_route_inf

Removed the prev_node member of t_rr_node_route_inf since the
information can easily be found by getting the source of the previous
edge. This will reduce the size of the data that needs to be collected
during routing. This may also make the route function a bit faster since
the previous node does not need to be stored during the wave expansion;
however, this may make reconstructing the path slower.

Also updated the comment in the t_rr_node_route_inf struct regarding the
prev_edge member, since it was no longer accurate. The edge ID used to
be an index into the edges of the previous node; however, that has since
changed to a globally unique ID within the RR Graph.

Author: AlexandreSinger

libs/librrgraph/src/base/rr_graph_storage.h

@@ -336,6 +336,11 @@ class t_rr_graph_storage {
         return ret;
     }
 
+    /** @brief Get the source node for the specified edge. */
+    RRNodeId edge_src_node(const RREdgeId& edge) const {
+        return edge_src_node_[edge];
+    }
+
     /** @brief Get the destination node for the specified edge. */
     RRNodeId edge_sink_node(const RREdgeId& edge) const {
         return edge_dest_node_[edge];

libs/librrgraph/src/base/rr_graph_view.h

@@ -321,6 +321,12 @@ class RRGraphView {
     inline short edge_switch(RRNodeId id, t_edge_size iedge) const {
         return node_storage_.edge_switch(id, iedge);
     }
+
+    /** @brief Get the source node for the specified edge. */
+    inline RRNodeId edge_src_node(const RREdgeId edge_id) const {
+        return node_storage_.edge_src_node(edge_id);
+    }
+
     /** @brief Get the destination node for the iedge'th edge from specified RRNodeId.
      *  This method should generally not be used, and instead first_edge and
      *  last_edge should be used.*/

vpr/src/base/vpr_types.h

@@ -1717,10 +1717,7 @@ 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_node  Index of the previous node (on the lowest cost path known
- *                     to reach this node); used to generate the traceback.
- *                     If there is no predecessor, prev_node = NO_PREVIOUS.
- *   @param prev_edge  Index of the edge (from 0 to num_edges-1 of prev_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.
@@ -1732,7 +1729,6 @@ constexpr bool is_src_sink(e_rr_type type) { return (type == SOURCE || type == S
  *   @param occ        The current occupancy of the associated rr node
  */
 struct t_rr_node_route_inf {
-    RRNodeId prev_node;
     RREdgeId prev_edge;
 
     float acc_cost;

vpr/src/route/connection_router.h

@@ -145,7 +145,6 @@ class ConnectionRouter : public ConnectionRouterInterface {
         //Record final link to target
         add_to_mod_list(cheapest->index);
 
-        route_inf->prev_node = cheapest->prev_node();
         route_inf->prev_edge = cheapest->prev_edge();
         route_inf->path_cost = cheapest->cost;
         route_inf->backward_path_cost = cheapest->backward_path_cost;

vpr/src/route/route_common.cpp

@@ -286,7 +286,6 @@ void reset_path_costs(const std::vector<RRNodeId>& visited_rr_nodes) {
     for (auto node : visited_rr_nodes) {
         route_ctx.rr_node_route_inf[node].path_cost = std::numeric_limits<float>::infinity();
         route_ctx.rr_node_route_inf[node].backward_path_cost = std::numeric_limits<float>::infinity();
-        route_ctx.rr_node_route_inf[node].prev_node = RRNodeId::INVALID();
         route_ctx.rr_node_route_inf[node].prev_edge = RREdgeId::INVALID();
     }
 }
@@ -420,7 +419,6 @@ void reset_rr_node_route_structs() {
     for (const RRNodeId& rr_id : device_ctx.rr_graph.nodes()) {
         auto& node_inf = route_ctx.rr_node_route_inf[rr_id];
 
-        node_inf.prev_node = RRNodeId::INVALID();
         node_inf.prev_edge = RREdgeId::INVALID();
         node_inf.acc_cost = 1.0;
         node_inf.path_cost = std::numeric_limits<float>::infinity();
@@ -908,8 +906,8 @@ void print_rr_node_route_inf() {
     for (size_t inode = 0; inode < route_ctx.rr_node_route_inf.size(); ++inode) {
         const auto& inf = route_ctx.rr_node_route_inf[RRNodeId(inode)];
         if (!std::isinf(inf.path_cost)) {
-            RRNodeId prev_node = inf.prev_node;
             RREdgeId prev_edge = inf.prev_edge;
+            RRNodeId prev_node = rr_graph.edge_src_node(prev_edge);
             auto switch_id = rr_graph.rr_nodes().edge_switch(prev_edge);
             VTR_LOG("rr_node: %d prev_node: %d prev_edge: %zu",
                     inode, prev_node, (size_t)prev_edge);
@@ -944,8 +942,8 @@ void print_rr_node_route_inf_dot() {
     for (size_t inode = 0; inode < route_ctx.rr_node_route_inf.size(); ++inode) {
         const auto& inf = route_ctx.rr_node_route_inf[RRNodeId(inode)];
         if (!std::isinf(inf.path_cost)) {
-            RRNodeId prev_node = inf.prev_node;
             RREdgeId prev_edge = inf.prev_edge;
+            RRNodeId prev_node = rr_graph.edge_src_node(prev_edge);
             auto switch_id = rr_graph.rr_nodes().edge_switch(prev_edge);
 
             if (prev_node.is_valid() && prev_edge.is_valid()) {

vpr/src/route/route_net.cpp

@@ -117,7 +117,6 @@ void update_rr_route_inf_from_tree(const RouteTreeNode& rt_node) {
 
     for (auto& node : rt_node.all_nodes()) {
         RRNodeId inode = node.inode;
-        route_ctx.rr_node_route_inf[inode].prev_node = RRNodeId::INVALID();
         route_ctx.rr_node_route_inf[inode].prev_edge = RREdgeId::INVALID();
 
         // path cost should be unset

vpr/src/route/route_path_manager.cpp

@@ -45,7 +45,6 @@ void PathManager::insert_backwards_path_into_traceback(t_heap_path* path_data, f
     for (unsigned i = 1; i < path_data->edge.size() - 1; i++) {
         RRNodeId node_2 = path_data->path_rr[i];
         RREdgeId edge = path_data->edge[i - 1];
-        route_ctx.rr_node_route_inf[node_2].prev_node = path_data->path_rr[i - 1];
         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;

vpr/src/route/route_tree.cpp

@@ -532,7 +532,7 @@ RouteTree::add_subtree_from_heap(t_heap* hptr, int target_net_pin_index, bool is
      * new_branch_inodes: [sink, nodeN-1, nodeN-2, ... node 1] of length N
      * and new_branch_iswitches: [N-1->sink, N-2->N-1, ... 2->1, 1->found_node] of length N */
     RREdgeId edge = hptr->prev_edge();
-    RRNodeId new_inode = RRNodeId(hptr->prev_node());
+    RRNodeId new_inode = rr_graph.edge_src_node(edge);
     RRSwitchId new_iswitch = RRSwitchId(rr_graph.rr_nodes().edge_switch(edge));
 
     /* build a path, looking up rr nodes and switches from rr_node_route_inf */
@@ -541,7 +541,7 @@ RouteTree::add_subtree_from_heap(t_heap* hptr, int target_net_pin_index, bool is
         new_branch_inodes.push_back(new_inode);
         new_branch_iswitches.push_back(new_iswitch);
         edge = route_ctx.rr_node_route_inf[new_inode].prev_edge;
-        new_inode = RRNodeId(route_ctx.rr_node_route_inf[new_inode].prev_node);
+        new_inode = rr_graph.edge_src_node(edge);
         new_iswitch = RRSwitchId(rr_graph.rr_nodes().edge_switch(edge));
     }
     new_branch_iswitches.push_back(new_iswitch);