[Router] Enhanced the Connection Router by Optimizing the Heap Structure

- The heap node structure in the connection router is simplified by only
maintaining the node index (int32) and node total cost (fp32).
- Eliminated dynamic memory allocation for the heap node structure.
- The above optimization leads to an algorithmic change for path search;
specifically, we need to update node states right before pushing and
modify the prune functions.

The RCV feature also works when using `--routing_budgets_algorithm yoyo`
for the VPR launch.

Author: ueqri

.gitignore

@@ -153,4 +153,10 @@ tags
 .idea
 cmake-build-debug
 cmake-build-release
-/.metadata/
+/.metadata/
+
+#
+# Clangd
+#
+.cache
+compile_commands.json

vpr/src/base/vpr_types.h

@@ -1684,6 +1684,13 @@ struct t_rr_node_route_inf {
     float acc_cost;
     float path_cost;
     float backward_path_cost;
+    float R_upstream; // TODO: Investigate the effect of adding the R_upstream field in
+                      //       this struct. It is put in for the fine-grained parallel
+                      //       router's benefits. It is increasing the working set, which
+                      //       can have some performance implications. This could affect
+                      //       the performance of the serial connection router, which will
+                      //       make the Hybrid Connection Router less efficient (but that
+                      //       needs to be investigated).
 
   public: //Accessors
     short occ() const { return occ_; }

vpr/src/route/connection_router.cpp

@@ -10,8 +10,20 @@
 #include "router_stats.h"
 #include "spatial_route_tree_lookup.h"
 
+#include "d_ary_heap.h"
+
+// `node_t` is a simplified version of `t_heap`, and is used as a bundle of node
+// information in the functions inside the routing loop.
+struct node_t {
+    float total_cost;
+    float backward_path_cost;
+    float R_upstream;
+    RREdgeId prev_edge;
+    t_heap_path* path_data;
+};
+
 // Prune the heap when it contains 4x the number of nodes in the RR graph.
-constexpr size_t kHeapPruneFactor = 4;
+// constexpr size_t kHeapPruneFactor = 4;
 
 // This class encapsolates the timing driven connection router. This class
 // routes from some initial set of sources (via the input rt tree) to a
@@ -46,8 +58,13 @@ class ConnectionRouter : public ConnectionRouterInterface {
         , router_stats_(nullptr)
         , router_debug_(false) {
         heap_.init_heap(grid);
-        heap_.set_prune_limit(rr_nodes_.size(), kHeapPruneFactor * rr_nodes_.size());
+        // heap_.set_prune_limit(rr_nodes_.size(), kHeapPruneFactor * rr_nodes_.size());
         only_opin_inter_layer = (grid.get_num_layers() > 1) && inter_layer_connections_limited_to_opin(*rr_graph);
+        rcv_path_data.resize(rr_node_route_inf.size());
+    }
+
+    ~ConnectionRouter() {
+        VTR_LOG("Serial Connection Router is being destroyed. Time spent computing SSSP: %.3f seconds\n.", this->sssp_total_time.count() / 1000000.0);
     }
 
     // Clear's the modified list.  Should be called after reset_path_costs
@@ -58,7 +75,12 @@ class ConnectionRouter : public ConnectionRouterInterface {
 
     // Reset modified data in rr_node_route_inf based on modified_rr_node_inf.
     void reset_path_costs() final {
+        // Reset the node info stored in rr_node_route_inf variable
         ::reset_path_costs(modified_rr_node_inf_);
+        // Reset the node info stored inside the connection router
+        for (const auto& node : modified_rr_node_inf_) {
+            rcv_path_data[node] = nullptr;
+        }
     }
 
     /** Finds a path from the route tree rooted at rt_root to sink_node.
@@ -137,17 +159,17 @@ class ConnectionRouter : public ConnectionRouterInterface {
     }
 
     // Update the route path to the node pointed to by cheapest.
-    inline void update_cheapest(t_heap* cheapest) {
-        update_cheapest(cheapest, &rr_node_route_inf_[cheapest->index]);
+    inline void update_cheapest(const node_t& cheapest, RRNodeId inode) {
+        update_cheapest(cheapest, inode, &rr_node_route_inf_[inode]);
     }
 
-    inline void update_cheapest(t_heap* cheapest, t_rr_node_route_inf* route_inf) {
+    inline void update_cheapest(const node_t& cheapest, RRNodeId inode, t_rr_node_route_inf* route_inf) {
         //Record final link to target
-        add_to_mod_list(cheapest->index);
+        add_to_mod_list(inode);
 
-        route_inf->prev_edge = cheapest->prev_edge();
-        route_inf->path_cost = cheapest->cost;
-        route_inf->backward_path_cost = cheapest->backward_path_cost;
+        route_inf->prev_edge = cheapest.prev_edge;
+        route_inf->path_cost = cheapest.total_cost;
+        route_inf->backward_path_cost = cheapest.backward_path_cost;
     }
 
     /** Common logic from timing_driven_route_connection_from_route_tree and
@@ -159,7 +181,7 @@ class ConnectionRouter : public ConnectionRouterInterface {
      * @param[in] bounding_box Keep search confined to this bounding box
      * @return bool Signal to retry this connection with a full-device bounding box,
      * @return t_heap* Heap element describing the path found. */
-    std::tuple<bool, t_heap*> timing_driven_route_connection_common_setup(
+    bool timing_driven_route_connection_common_setup(
         const RouteTreeNode& rt_root,
         RRNodeId sink_node,
         const t_conn_cost_params& cost_params,
@@ -174,24 +196,26 @@ class ConnectionRouter : public ConnectionRouterInterface {
     //
     // Returns either the last element of the path, or nullptr if no path is
     // found
-    t_heap* timing_driven_route_connection_from_heap(
+    void timing_driven_route_connection_from_heap(
         RRNodeId sink_node,
         const t_conn_cost_params& cost_params,
         const t_bb& bounding_box);
 
     // Expand this current node if it is a cheaper path.
     void timing_driven_expand_cheapest(
-        t_heap* cheapest,
+        RRNodeId from_node,
+        float new_total_cost,
         RRNodeId target_node,
         const t_conn_cost_params& cost_params,
         const t_bb& bounding_box,
         const t_bb& target_bb);
 
     // Expand each neighbor of the current node.
     void timing_driven_expand_neighbours(
-        t_heap* current,
+        const node_t& current,
         const t_conn_cost_params& cost_params,
         const t_bb& bounding_box,
+        RRNodeId from_node,
         RRNodeId target_node,
         const t_bb& target_bb);
 
@@ -201,7 +225,7 @@ class ConnectionRouter : public ConnectionRouterInterface {
     // RR nodes outside bounding box specified in bounding_box are not added
     // to the heap.
     void timing_driven_expand_neighbour(
-        t_heap* current,
+        const node_t& current,
         RRNodeId from_node,
         RREdgeId from_edge,
         RRNodeId to_node,
@@ -214,15 +238,15 @@ class ConnectionRouter : public ConnectionRouterInterface {
     // non-configurable edges
     void timing_driven_add_to_heap(
         const t_conn_cost_params& cost_params,
-        const t_heap* current,
+        const node_t& current,
         RRNodeId from_node,
         RRNodeId to_node,
         RREdgeId from_edge,
         RRNodeId target_node);
 
     // Calculates the cost of reaching to_node
     void evaluate_timing_driven_node_costs(
-        t_heap* to,
+        node_t* to,
         const t_conn_cost_params& cost_params,
         RRNodeId from_node,
         RRNodeId to_node,
@@ -234,8 +258,6 @@ class ConnectionRouter : public ConnectionRouterInterface {
         const t_conn_cost_params& cost_params,
         const t_bb& bounding_box);
 
-    void empty_heap_annotating_node_route_inf();
-
     //Adds the route tree rooted at rt_node to the heap, preparing it to be
     //used as branch-points for further routing.
     void add_route_tree_to_heap(const RouteTreeNode& rt_node,
@@ -281,13 +303,17 @@ class ConnectionRouter : public ConnectionRouterInterface {
     std::vector<RRNodeId> modified_rr_node_inf_;
     RouterStats* router_stats_;
     const ConnectionParameters* conn_params_;
-    HeapImplementation heap_;
+    DAryHeap heap_;
     bool router_debug_;
 
     bool only_opin_inter_layer;
 
+    // Timing
+    std::chrono::microseconds sssp_total_time{0};
+
     // The path manager for RCV, keeps track of the route tree as a set, also manages the allocation of the heap types
     PathManager rcv_path_manager;
+    vtr::vector<RRNodeId, t_heap_path*> rcv_path_data;
 };
 
 /** Construct a connection router that uses the specified heap type.

vpr/src/route/connection_router.h

@@ -0,0 +1,82 @@
+#ifndef _VTR_D_ARY_HEAP_H
+#define _VTR_D_ARY_HEAP_H
+
+#include <cstdint>
+#include <tuple>
+#include <vector>
+
+#include "device_grid.h"
+#include "rr_graph_fwd.h"
+#include "d_ary_heap.tpp"
+
+using pq_prio_t = float;
+using pq_index_t = uint32_t;
+
+inline pq_index_t cast_RRNodeId_to_pq_index_t(RRNodeId node) {
+    static_assert(sizeof(RRNodeId) == sizeof(pq_index_t));
+    return static_cast<pq_index_t>(std::size_t(node));
+}
+
+class DAryHeap {
+  public:
+    using pq_pair_t = std::tuple<pq_prio_t /*priority*/, pq_index_t>;
+    struct pq_compare {
+        bool operator()(const pq_pair_t& u, const pq_pair_t& v) {
+            return std::get<0>(u) > std::get<0>(v);
+        }
+    };
+    using pq_io_t = customized_d_ary_priority_queue<4, pq_pair_t, std::vector<pq_pair_t>, pq_compare>;
+
+    DAryHeap() {
+        pq_ = new pq_io_t();
+    }
+
+    ~DAryHeap(){
+        delete pq_;
+    }
+
+    void init_heap(const DeviceGrid& grid) {
+        size_t target_heap_size = (grid.width() - 1) * (grid.height() - 1);
+        pq_->reserve(target_heap_size);
+    }
+
+    bool try_pop(pq_prio_t &prio, RRNodeId &node) {
+        if (pq_->empty()) {
+            return false;
+        } else {
+            pq_index_t node_id;
+            std::tie(prio, node_id) = pq_->top();
+            static_assert(sizeof(RRNodeId) == sizeof(pq_index_t));
+            node = RRNodeId(node_id);
+            pq_->pop();
+            return true;
+        }
+    }
+
+    void add_to_heap(const pq_prio_t& prio, const RRNodeId& node) {
+        pq_->push({prio, cast_RRNodeId_to_pq_index_t(node)});
+    }
+
+    void push_back(const pq_prio_t& prio, const RRNodeId& node) {
+        pq_->push({prio, cast_RRNodeId_to_pq_index_t(node)});
+    }
+
+    bool is_empty_heap() const {
+        return (bool)(pq_->empty());
+    }
+
+    bool is_valid() const {
+        return true;
+    }
+
+    void empty_heap() {
+        pq_->clear();
+    }
+
+    void build_heap() {}
+
+  private:
+    pq_io_t* pq_;
+};
+
+#endif /* _VTR_D_ARY_HEAP_H */