Reduce computation in edge loop.

Signed-off-by: Keith Rothman <[email protected]>

Author: litghost

vpr/src/route/route_timing.cpp

@@ -1957,11 +1957,15 @@ void Router::timing_driven_expand_neighbours(t_heap* current,
     //For each node associated with the current heap element, expand all of it's neighbors
     int from_node_int = current->index;
     RRNodeId from_node(from_node_int);
-    int num_edges = rr_nodes_->num_edges(from_node);
+    RREdgeId first_edge = rr_nodes_->first_edge(from_node);
+    RREdgeId last_edge = rr_nodes_->last_edge(from_node);
+    int num_edges = size_t(last_edge) - size_t(first_edge);
     for (int iconn = 0; iconn < num_edges; iconn++) {
-        RRNodeId to_node = rr_nodes_->edge_sink_node(from_node, iconn);
+        RREdgeId from_edge(size_t(first_edge) + iconn);
+        RRNodeId to_node = rr_nodes_->edge_sink_node(from_edge);
         timing_driven_expand_neighbour(current,
                                        from_node_int,
+                                       from_edge,
                                        iconn,
                                        size_t(to_node),
                                        cost_params,
@@ -1976,7 +1980,8 @@ void Router::timing_driven_expand_neighbours(t_heap* current,
 //to the heap.
 void Router::timing_driven_expand_neighbour(t_heap* current,
                                             const int from_node,
-                                            const t_edge_size from_edge,
+                                            const RREdgeId from_edge,
+                                            const t_edge_size from_edge_int,
                                             const int to_node_int,
                                             const t_conn_cost_params cost_params,
                                             const t_bb bounding_box,
@@ -1996,7 +2001,7 @@ void Router::timing_driven_expand_neighbour(t_heap* current,
                        "      Pruned expansion of node %d edge %d -> %d"
                        " (to node location %d,%dx%d,%d outside of expanded"
                        " net bounding box %d,%dx%d,%d)\n",
-                       from_node, from_edge, to_node_int,
+                       from_node, from_edge_int, to_node_int,
                        to_xlow, to_ylow, to_xhigh, to_yhigh,
                        bounding_box.xmin, bounding_box.ymin, bounding_box.xmax, bounding_box.ymax);
         return; /* Node is outside (expanded) bounding box. */
@@ -2019,7 +2024,7 @@ void Router::timing_driven_expand_neighbour(t_heap* current,
                                "      Pruned expansion of node %d edge %d -> %d"
                                " (to node is IPIN at %d,%dx%d,%d which does not"
                                " lead to target block %d,%dx%d,%d)\n",
-                               from_node, from_edge, to_node_int,
+                               from_node, from_edge_int, to_node_int,
                                to_xlow, to_ylow, to_xhigh, to_yhigh,
                                target_bb.xmin, target_bb.ymin, target_bb.xmax, target_bb.ymax);
                 return;
@@ -2028,13 +2033,14 @@ void Router::timing_driven_expand_neighbour(t_heap* current,
     }
 
     VTR_LOGV_DEBUG(f_router_debug, "      Expanding node %d edge %d -> %d\n",
-                   from_node, from_edge, to_node_int);
+                   from_node, from_edge_int, to_node_int);
 
     timing_driven_add_to_heap(cost_params,
                               current,
                               from_node,
                               to_node_int,
                               from_edge,
+                              from_edge_int,
                               target_node);
 }
 
@@ -2043,65 +2049,59 @@ void Router::timing_driven_add_to_heap(const t_conn_cost_params cost_params,
                                        const t_heap* current,
                                        const int from_node,
                                        const int to_node,
+                                       const RREdgeId from_edge,
                                        const int iconn,
                                        const int target_node) {
-    t_heap* next = alloc_heap_data();
-    next->index = to_node;
+    t_heap next;
 
     //Costs initialized to current
-    next->cost = std::numeric_limits<float>::infinity(); //Not used directly
-    next->backward_path_cost = current->backward_path_cost;
-    next->R_upstream = current->R_upstream;
+    next.cost = std::numeric_limits<float>::infinity(); //Not used directly
+    next.backward_path_cost = current->backward_path_cost;
+    next.R_upstream = current->R_upstream;
 
-    timing_driven_expand_node(cost_params,
-                              next, from_node, to_node, iconn, target_node);
+
+    VTR_LOGV_DEBUG(f_router_debug, "      Expanding to node %d (%s)\n", to_node, describe_rr_node(to_node).c_str());
+
+    evaluate_timing_driven_node_costs(&next,
+                                      cost_params,
+                                      from_node,
+                                      to_node,
+                                      from_edge,
+                                      target_node);
 
     float best_total_cost = rr_node_route_inf_[to_node].path_cost;
     float best_back_cost = rr_node_route_inf_[to_node].backward_path_cost;
 
-    float new_total_cost = next->cost;
-    float new_back_cost = next->backward_path_cost;
-
-    VTR_ASSERT_SAFE(next->index == to_node);
+    float new_total_cost = next.cost;
+    float new_back_cost = next.backward_path_cost;
 
     if (new_total_cost < best_total_cost && new_back_cost < best_back_cost) {
         //Add node to the heap only if the cost via the current partial path is less than the
         //best known cost, since there is no reason for the router to expand more expensive paths.
         //
         //Pre-heap prune to keep the heap small, by not putting paths which are known to be
         //sub-optimal (at this point in time) into the heap.
-        add_to_heap(next);
-        ++router_stats_->heap_pushes;
-    } else {
-        free_heap_data(next);
-    }
-}
+        t_heap* next_ptr = alloc_heap_data();
 
-//Updates current (path step and costs) to account for the step taken to reach to_node
-void Router::timing_driven_expand_node(const t_conn_cost_params cost_params,
-                                       t_heap* current,
-                                       const int from_node,
-                                       const int to_node,
-                                       const int iconn,
-                                       const int target_node) {
-    VTR_LOGV_DEBUG(f_router_debug, "      Expanding to node %d (%s)\n", to_node, describe_rr_node(to_node).c_str());
+        //Record how we reached this node
+        next_ptr->cost = next.cost;
+        next_ptr->R_upstream = next.R_upstream;
+        next_ptr->backward_path_cost = next.backward_path_cost;
+        next_ptr->index = to_node;
+        next_ptr->u.prev.edge = iconn;
+        next_ptr->u.prev.node = from_node;
 
-    evaluate_timing_driven_node_costs(current,
-                                      cost_params,
-                                      from_node, to_node, iconn, target_node);
-
-    //Record how we reached this node
-    current->index = to_node;
-    current->u.prev.edge = iconn;
-    current->u.prev.node = from_node;
+        add_to_heap(next_ptr);
+        ++router_stats_->heap_pushes;
+    }
 }
 
 //Calculates the cost of reaching to_node
 void Router::evaluate_timing_driven_node_costs(t_heap* to,
                                                const t_conn_cost_params cost_params,
                                                const int from_node,
                                                const int to_node,
-                                               const int iconn,
+                                               const RREdgeId from_edge,
                                                const int target_node) {
     /* new_costs.backward_cost: is the "known" part of the cost to this node -- the
      * congestion cost of all the routing resources back to the existing route
@@ -2113,7 +2113,7 @@ void Router::evaluate_timing_driven_node_costs(t_heap* to,
      */
 
     //Info for the switch connecting from_node to_node
-    int iswitch = rr_nodes_->edge_switch(RRNodeId(from_node), iconn);
+    int iswitch = rr_nodes_->edge_switch(from_edge);
     bool switch_buffered = rr_switch_inf_[iswitch].buffered();
     bool reached_configurably = rr_switch_inf_[iswitch].configurable();
     float switch_R = rr_switch_inf_[iswitch].R;

vpr/src/route/route_timing.h

@@ -100,7 +100,8 @@ class Router {
     void timing_driven_expand_neighbour(
         t_heap* current,
         const int from_node,
-        const t_edge_size from_edge,
+        const RREdgeId from_edge,
+        const t_edge_size from_edge_int,
         const int to_node,
         const t_conn_cost_params cost_params,
         const t_bb bounding_box,
@@ -111,21 +112,15 @@ class Router {
         const t_heap* current,
         const int from_node,
         const int to_node,
-        const int iconn,
-        const int target_node);
-    void timing_driven_expand_node(
-        const t_conn_cost_params cost_params,
-        t_heap* current,
-        const int from_node,
-        const int to_node,
+        const RREdgeId from_edge,
         const int iconn,
         const int target_node);
     void evaluate_timing_driven_node_costs(
         t_heap* to,
         const t_conn_cost_params cost_params,
         const int from_node,
         const int to_node,
-        const int iconn,
+        const RREdgeId from_edge,
         const int target_node);
     std::vector<t_heap> timing_driven_find_all_shortest_paths_from_heap(
         const t_conn_cost_params cost_params,

vpr/src/route/rr_graph_storage.h

@@ -316,18 +316,23 @@ class t_rr_graph_storage {
     }
 
     t_edge_size num_edges(const RRNodeId& id) const {
-        RREdgeId first_id = first_edge_[id];
-        RREdgeId last_id = (&first_edge_[id])[1];
-        return size_t(last_id) - size_t(first_id);
+        return size_t(last_edge(id)) - size_t(first_edge(id));
+    }
+
+    RREdgeId first_edge(const RRNodeId& id) const {
+        return first_edge_[id];
+    }
+    RREdgeId last_edge(const RRNodeId& id) const {
+        return (&first_edge_[id])[1];
     }
 
     t_edge_size num_configurable_edges(const RRNodeId& id) const;
     t_edge_size num_non_configurable_edges(const RRNodeId& id) const;
 
     RREdgeId edge_id(const RRNodeId& id, t_edge_size iedge) const {
-        RREdgeId first_edge = first_edge_[id];
+        RREdgeId first_edge = this->first_edge(id);
         RREdgeId ret(size_t(first_edge) + iedge);
-        VTR_ASSERT_SAFE(ret < (&first_edge_[id])[1]);
+        VTR_ASSERT_SAFE(ret < last_edge(id));
         return ret;
     }
     RRNodeId edge_sink_node(const RREdgeId& edge) const {