Merge pull request #2512 from AlexandreSinger/feature_remove_prev_node

[Route][Heap] Removed prev_node From t_heap

Author: vaughnbetz

vpr/src/route/connection_router.cpp

@@ -374,8 +374,8 @@ void ConnectionRouter<Heap>::timing_driven_expand_cheapest(t_heap* cheapest,
         VTR_LOGV_DEBUG(router_debug_, "    New back cost: %g\n", new_back_cost);
         VTR_LOGV_DEBUG(router_debug_, "      Setting path costs for associated node %d (from %d edge %zu)\n",
                        cheapest->index,
-                       cheapest->prev_node(),
-                       size_t(cheapest->prev_edge()));
+                       static_cast<size_t>(rr_graph_->edge_src_node(cheapest->prev_edge())),
+                       static_cast<size_t>(cheapest->prev_edge()));
 
         update_cheapest(cheapest, route_inf);
 
@@ -601,7 +601,6 @@ void ConnectionRouter<Heap>::timing_driven_add_to_heap(const t_conn_cost_params&
         next_ptr->backward_path_cost = next.backward_path_cost;
         next_ptr->index = to_node;
         next_ptr->set_prev_edge(from_edge);
-        next_ptr->set_prev_node(from_node);
 
         if (rcv_path_manager.is_enabled() && current->path_data) {
             next_ptr->path_data->path_rr = current->path_data->path_rr;
@@ -924,7 +923,7 @@ void ConnectionRouter<Heap>::add_route_tree_node_to_heap(
                        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, RRNodeId::INVALID(), RREdgeId::INVALID(),
+                       inode, tot_cost, RREdgeId::INVALID(),
                        backward_path_cost, R_upstream);
     } else {
         float expected_total_cost = compute_node_cost_using_rcv(cost_params, inode, target_node, rt_node.Tdel, 0, R_upstream);
@@ -1191,4 +1190,4 @@ std::unique_ptr<ConnectionRouterInterface> make_connection_router(e_heap_type he
             VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "Unknown heap_type %d",
                             heap_type);
     }
-}
+}

vpr/src/route/heap_type.cpp

@@ -29,7 +29,6 @@ HeapStorage::alloc() {
     temp_ptr->R_upstream = 0.;
     temp_ptr->index = RRNodeId::INVALID();
     temp_ptr->path_data = nullptr;
-    temp_ptr->set_prev_node(RRNodeId::INVALID());
     temp_ptr->set_prev_edge(RREdgeId::INVALID());
     return (temp_ptr);
 }

vpr/src/route/heap_type.h

@@ -45,15 +45,6 @@ struct t_heap {
     // Managed by PathManager class
     t_heap_path* path_data;
 
-    /** Previous node and edge IDs. These are not StrongIds for performance & brevity
-     * reasons: StrongIds can't be trivially placed into an anonymous union (see below) */
-    struct t_prev {
-        uint32_t node;
-        uint32_t edge;
-        static_assert(sizeof(uint32_t) == sizeof(RRNodeId));
-        static_assert(sizeof(uint32_t) == sizeof(RREdgeId));
-    };
-
     t_heap* next_heap_item() const {
         return u.next;
     }
@@ -62,30 +53,25 @@ struct t_heap {
         u.next = next;
     }
 
-    /** Get prev_node.
-     * Be careful: will return 0 (a valid id!) if uninitialized. */
-    constexpr RRNodeId prev_node() const {
-        return RRNodeId(u.prev.node);
-    }
-
-    inline void set_prev_node(RRNodeId node) {
-        u.prev.node = size_t(node);
-    }
-
     /** Get prev_edge.
      * Be careful: will return 0 (a valid id!) if uninitialized. */
     constexpr RREdgeId prev_edge() const {
-        return RREdgeId(u.prev.edge);
+        static_assert(sizeof(uint32_t) == sizeof(RREdgeId));
+        return RREdgeId(u.prev_edge);
     }
 
     inline void set_prev_edge(RREdgeId edge) {
-        u.prev.edge = size_t(edge);
+        static_assert(sizeof(uint32_t) == sizeof(RREdgeId));
+        u.prev_edge = size_t(edge);
     }
 
   private:
     union {
         t_heap* next = nullptr;
-        t_prev prev;
+        // The previous edge is not a StrongId for performance & brevity
+        // reasons: StrongIds can't be trivially placed into an anonymous
+        // union.
+        uint32_t prev_edge;
     } u;
 };
 

vpr/src/route/route_common.cpp

@@ -810,7 +810,7 @@ void reserve_locally_used_opins(HeapInterface* heap, float pres_fac, float acc_f
                 //Add the OPIN to the heap according to it's congestion cost
                 cost = get_rr_cong_cost(to_node, pres_fac);
                 add_node_to_heap(heap, route_ctx.rr_node_route_inf,
-                                 to_node, cost, RRNodeId::INVALID(), RREdgeId::INVALID(),
+                                 to_node, cost, RREdgeId::INVALID(),
                                  0., 0.);
             }
 

vpr/src/route/route_common.h

@@ -159,7 +159,6 @@ t_heap* prepare_to_add_node_to_heap(
     const RouteInf& rr_node_route_inf,
     RRNodeId inode,
     float total_cost,
-    RRNodeId prev_node,
     RREdgeId prev_edge,
     float backward_path_cost,
     float R_upstream) {
@@ -170,7 +169,6 @@ t_heap* prepare_to_add_node_to_heap(
 
     hptr->index = inode;
     hptr->cost = total_cost;
-    hptr->set_prev_node(prev_node);
     hptr->set_prev_edge(prev_edge);
     hptr->backward_path_cost = backward_path_cost;
     hptr->R_upstream = R_upstream;
@@ -184,13 +182,12 @@ void add_node_to_heap(
     const RouteInf& rr_node_route_inf,
     RRNodeId inode,
     float total_cost,
-    RRNodeId prev_node,
     RREdgeId prev_edge,
     float backward_path_cost,
     float R_upstream) {
     t_heap* hptr = prepare_to_add_node_to_heap(
         heap,
-        rr_node_route_inf, inode, total_cost, prev_node,
+        rr_node_route_inf, inode, total_cost,
         prev_edge, backward_path_cost, R_upstream);
     if (hptr) {
         heap->add_to_heap(hptr);
@@ -206,13 +203,12 @@ void push_back_node(
     const RouteInf& rr_node_route_inf,
     RRNodeId inode,
     float total_cost,
-    RRNodeId prev_node,
     RREdgeId prev_edge,
     float backward_path_cost,
     float R_upstream) {
     t_heap* hptr = prepare_to_add_node_to_heap(
         heap,
-        rr_node_route_inf, inode, total_cost, prev_node, prev_edge,
+        rr_node_route_inf, inode, total_cost, prev_edge,
         backward_path_cost, R_upstream);
     if (hptr) {
         heap->push_back(hptr);