vpr: Cleanup and optimize router heap element struct

kmurray · kmurray · commit 616833ee243d · 2019-05-21T13:58:18.000-04:00
Uses a union to shrink the size from 32 to 24 bytes and clarifies comments. Closes #525
diff --git a/vpr/src/route/route_breadth_first.cpp b/vpr/src/route/route_breadth_first.cpp
@@ -207,8 +207,8 @@ static bool breadth_first_route_net(ClusterNetId net_id, float bend_cost) {
                 add_to_mod_list(current->index, modified_rr_node_inf);
 
                 route_ctx.rr_node_route_inf[current->index].path_cost = new_pcost;
-                route_ctx.rr_node_route_inf[current->index].prev_node = current->prev_node;
-                route_ctx.rr_node_route_inf[current->index].prev_edge = current->prev_edge;
+                route_ctx.rr_node_route_inf[current->index].prev_node = current->u.prev.node;
+                route_ctx.rr_node_route_inf[current->index].prev_edge = current->u.prev.edge;
 
 #ifdef ROUTER_DEBUG
                 VTR_LOG("    Expanding node %d neighbours\n", inode);
@@ -242,8 +242,8 @@ static bool breadth_first_route_net(ClusterNetId net_id, float bend_cost) {
             add_to_mod_list(current->index, modified_rr_node_inf);
 
             route_ctx.rr_node_route_inf[current->index].path_cost = current->cost;
-            route_ctx.rr_node_route_inf[current->index].prev_node = current->prev_node;
-            route_ctx.rr_node_route_inf[current->index].prev_edge = current->prev_edge;
+            route_ctx.rr_node_route_inf[current->index].prev_node = current->u.prev.node;
+            route_ctx.rr_node_route_inf[current->index].prev_edge = current->u.prev.edge;
         }
 
 		route_ctx.rr_node_route_inf[inode].target_flag--; /* Connected to this SINK. */
@@ -405,8 +405,8 @@ static void breadth_first_add_to_heap(const float path_cost, const float bend_co
 
     //Record how we reached this node
     next->index = to_node;
-    next->prev_edge = iconn;
-    next->prev_node = from_node;
+    next->u.prev.edge = iconn;
+    next->u.prev.node = from_node;
 
     add_to_heap(next);
 }
diff --git a/vpr/src/route/route_common.cpp b/vpr/src/route/route_common.cpp
@@ -818,10 +818,10 @@ void node_to_heap(int inode, float total_cost, int prev_node, int prev_edge,
 	t_heap* hptr = alloc_heap_data();
 	hptr->index = inode;
 	hptr->cost = total_cost;
-    VTR_ASSERT_SAFE(hptr->prev_node == NO_PREVIOUS);
-    VTR_ASSERT_SAFE(hptr->prev_edge == NO_PREVIOUS);
-    hptr->prev_node = prev_node;
-    hptr->prev_edge = prev_edge;
+    VTR_ASSERT_SAFE(hptr->u.prev.node == NO_PREVIOUS);
+    VTR_ASSERT_SAFE(hptr->u.prev.edge == NO_PREVIOUS);
+    hptr->u.prev.node = prev_node;
+    hptr->u.prev.edge = prev_edge;
 	hptr->backward_path_cost = backward_path_cost;
 	hptr->R_upstream = R_upstream;
 	add_to_heap(hptr);
@@ -978,7 +978,7 @@ void free_route_structs() {
         t_heap* curr = heap_free_head;
         while(curr) {
             t_heap* tmp = curr;
-            curr = curr->next;
+            curr = curr->u.next;
 
             vtr::chunk_delete(tmp, &heap_ch);
         }
@@ -1299,8 +1299,8 @@ namespace heap_ {
 		t_heap* hptr = alloc_heap_data();
 		hptr->index = inode;
 		hptr->cost = total_cost;
-        hptr->prev_node = prev_node;
-        hptr->prev_edge = prev_edge;
+        hptr->u.prev.node = prev_node;
+        hptr->u.prev.edge = prev_edge;
 		hptr->backward_path_cost = backward_path_cost;
 		hptr->R_upstream = R_upstream;
 		push_back(hptr);
@@ -1412,23 +1412,23 @@ alloc_heap_data() {
 
     //Extract the head
 	t_heap* temp_ptr = heap_free_head;
-	heap_free_head = heap_free_head->next;
+	heap_free_head = heap_free_head->u.next;
 
 	num_heap_allocated++;
 
     //Reset
-    temp_ptr->next = nullptr;
+    temp_ptr->u.next = nullptr;
     temp_ptr->cost = 0.;
     temp_ptr->backward_path_cost = 0.;
     temp_ptr->R_upstream = 0.;
     temp_ptr->index = OPEN;
-    temp_ptr->prev_node = NO_PREVIOUS;
-    temp_ptr->prev_edge = NO_PREVIOUS;
+    temp_ptr->u.prev.node = NO_PREVIOUS;
+    temp_ptr->u.prev.edge = NO_PREVIOUS;
 	return (temp_ptr);
 }
 
 void free_heap_data(t_heap *hptr) {
-	hptr->next = heap_free_head;
+	hptr->u.next = heap_free_head;
 	heap_free_head = hptr;
 	num_heap_allocated--;
 }
@@ -1441,7 +1441,7 @@ void invalidate_heap_entries(int sink_node, int ipin_node) {
 
 	for (int i = 1; i < heap_tail; i++) {
 		if (heap[i]->index == sink_node) {
-            if (heap[i]->prev_node == ipin_node) {
+            if (heap[i]->u.prev.node == ipin_node) {
                 heap[i]->index = OPEN; /* Invalid. */
                 break;
             }
diff --git a/vpr/src/route/route_common.h b/vpr/src/route/route_common.h
@@ -8,42 +8,47 @@
 /* Used by the heap as its fundamental data structure.
  * Each heap element represents a partial route.
  *
- * next:    pointer to the next s_heap structure in the free
- *          linked list.  Not used when on the heap.
- *
  * cost:    The cost used to sort heap.
  *          For the timing-driven router this is the backward_path_cost +
  *          expected cost to the target.
  *          For the breadth-first router it is the node cost to reach this
  *          point.
+ *
  * backward_path_cost:  Used only by the timing-driven router.  The "known"
  *                      cost of the path up to and including this node.
  *                      In this case, the .cost member contains not only
  *                      the known backward cost but also an expected cost
  *                      to the target.
+ *
  * R_upstream: 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).
  *
  * index: The RR node index associated with the costs/R_upstream values
- * nodes: The set of nodes represented by this heap element.
- *        Usually this contains a single element corresponding to index.
- *        However in some cases (e.g. non-configurable edges) multiple RR 
- *        nodes may be required to be used together. In such cases each
- *        node will be inclued in 'nodes' and 'cost', 'backward_path_cost',
- *        R_upstream will be those associated with the lowest cost node (who's
- *        index is stored in 'index' for reference).
+ *
+ * u.prev.node: The previous node used to reach the current 'index' node
+ * u.prev.next: The edge from u.prev.node used to reach the current 'index' node
+ *
+ * u.next:  pointer to the next s_heap structure in the free
+ *          linked list.  Not used when on the heap.
+ *
  */
 struct t_heap {
-    t_heap *next = nullptr;
-
 	float cost = 0.;
 	float backward_path_cost = 0.;
 	float R_upstream = 0.;
 
 	int index = OPEN;
-    int prev_node = NO_PREVIOUS;
-    int prev_edge = NO_PREVIOUS;
+
+    struct t_prev {
+        int node;
+        int edge;
+    };
+
+    union {
+        t_heap* next;
+        t_prev prev;
+    } u;
 };
 
 /******* Subroutines in route_common used only by other router modules ******/
diff --git a/vpr/src/route/route_timing.cpp b/vpr/src/route/route_timing.cpp
@@ -1073,8 +1073,8 @@ static bool timing_driven_route_sink(ClusterNetId net_id, unsigned itarget, int
         //Record final link to target
         add_to_mod_list(cheapest->index, modified_rr_node_inf);
 
-        route_ctx.rr_node_route_inf[cheapest->index].prev_node = cheapest->prev_node;
-        route_ctx.rr_node_route_inf[cheapest->index].prev_edge = cheapest->prev_edge;
+        route_ctx.rr_node_route_inf[cheapest->index].prev_node = cheapest->u.prev.node;
+        route_ctx.rr_node_route_inf[cheapest->index].prev_edge = cheapest->u.prev.edge;
         route_ctx.rr_node_route_inf[cheapest->index].path_cost = cheapest->cost;
         route_ctx.rr_node_route_inf[cheapest->index].backward_path_cost = cheapest->backward_path_cost;
     }
@@ -1378,12 +1378,12 @@ static void timing_driven_expand_cheapest(t_heap* cheapest,
     if (old_total_cost > new_total_cost && old_back_cost > new_back_cost) {
 
         VTR_LOGV_DEBUG(f_router_debug, "    Better cost to %d\n", inode);
-        VTR_LOGV_DEBUG(f_router_debug, "      Setting path costs for assicated node %d (from %d edge %d)\n", cheapest->index, cheapest->prev_node, cheapest->prev_edge);
+        VTR_LOGV_DEBUG(f_router_debug, "      Setting path costs for assicated node %d (from %d edge %d)\n", cheapest->index, cheapest->u.prev.node, cheapest->u.prev.edge);
 
         add_to_mod_list(cheapest->index, modified_rr_node_inf);
 
-        route_ctx.rr_node_route_inf[cheapest->index].prev_node = cheapest->prev_node;
-        route_ctx.rr_node_route_inf[cheapest->index].prev_edge = cheapest->prev_edge;
+        route_ctx.rr_node_route_inf[cheapest->index].prev_node = cheapest->u.prev.node;
+        route_ctx.rr_node_route_inf[cheapest->index].prev_edge = cheapest->u.prev.edge;
         route_ctx.rr_node_route_inf[cheapest->index].path_cost = new_total_cost;
         route_ctx.rr_node_route_inf[cheapest->index].backward_path_cost = new_back_cost;
 
@@ -1837,8 +1837,8 @@ static void timing_driven_expand_node(const t_conn_cost_params cost_params,
 
     //Record how we reached this node
     current->index = to_node;
-    current->prev_edge = iconn;
-    current->prev_node = from_node;
+    current->u.prev.edge = iconn;
+    current->u.prev.node = from_node;
 }
 
 //Calculates the cost of reaching to_node
diff --git a/vpr/src/route/route_tree_timing.cpp b/vpr/src/route/route_tree_timing.cpp
@@ -305,8 +305,8 @@ add_subtree_to_route_tree(t_heap *hptr, t_rt_node ** sink_rt_node_ptr) {
 	downstream_rt_node = sink_rt_node;
 
     std::unordered_set<int> main_branch_visited;
-    inode = hptr->prev_node;
-    iedge = hptr->prev_edge;
+    inode = hptr->u.prev.node;
+    iedge = hptr->u.prev.edge;
     iswitch = device_ctx.rr_nodes[inode].edge_switch(iedge);
 
     /* For all "new" nodes in the main path */
