Fixed bug in FourAryHeap::get_heap_head and make FourAryHeap default heap implementation

Nathan Shreve · Nathan Shreve · commit 9a5d3b1e2f5d · 2024-06-21T12:14:50.000-04:00
diff --git a/utils/route_diag/src/main.cpp b/utils/route_diag/src/main.cpp
@@ -104,8 +104,8 @@ static void do_one_route(const Netlist<>& net_list,
                                                   is_flat);
 
     ConnectionRouter<FourAryHeap> router(
-            device_ctx.grid,
-            *router_lookahead,
+        device_ctx.grid,
+        *router_lookahead,
             device_ctx.rr_graph.rr_nodes(),
             &device_ctx.rr_graph,
             device_ctx.rr_rc_data,
diff --git a/vpr/src/base/ShowSetup.cpp b/vpr/src/base/ShowSetup.cpp
@@ -410,6 +410,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
                 case e_heap_type::BINARY_HEAP:
                     VTR_LOG("BINARY_HEAP\n");
                     break;
+                case e_heap_type::FOUR_ARY_HEAP:
+                    VTR_LOG("FOUR_ARY_HEAP\n");
+                    break;
                 case e_heap_type::BUCKET_HEAP_APPROXIMATION:
                     VTR_LOG("BUCKET_HEAP_APPROXIMATION\n");
                     break;
@@ -553,6 +556,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
                 case e_heap_type::BINARY_HEAP:
                     VTR_LOG("BINARY_HEAP\n");
                     break;
+                case e_heap_type::FOUR_ARY_HEAP:
+                    VTR_LOG("FOUR_ARY_HEAP:\n");
+                    break;
                 case e_heap_type::BUCKET_HEAP_APPROXIMATION:
                     VTR_LOG("BUCKET_HEAP_APPROXIMATION\n");
                     break;
diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp
@@ -1061,6 +1061,8 @@ struct ParseRouterHeap {
         ConvertedValue<e_heap_type> conv_value;
         if (str == "binary")
             conv_value.set_value(e_heap_type::BINARY_HEAP);
+        else if (str == "four_ary")
+            conv_value.set_value(e_heap_type::FOUR_ARY_HEAP);
         else if (str == "bucket")
             conv_value.set_value(e_heap_type::BUCKET_HEAP_APPROXIMATION);
         else {
@@ -1075,6 +1077,8 @@ struct ParseRouterHeap {
         ConvertedValue<std::string> conv_value;
         if (val == e_heap_type::BINARY_HEAP)
             conv_value.set_value("binary");
+        else if (val == e_heap_type::FOUR_ARY_HEAP)
+            conv_value.set_value("four_ary");
         else {
             VTR_ASSERT(val == e_heap_type::BUCKET_HEAP_APPROXIMATION);
             conv_value.set_value("bucket");
@@ -1083,7 +1087,7 @@ struct ParseRouterHeap {
     }
 
     std::vector<std::string> default_choices() {
-        return {"binary", "bucket"};
+        return {"binary", "four_ary", "bucket"};
     }
 };
 
@@ -2648,11 +2652,12 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help(
             "Controls what type of heap to use for timing driven router.\n"
             " * binary: A binary heap is used.\n"
+            " * four_ary: A four_ary heap is used.\n"
             " * bucket: A bucket heap approximation is used. The bucket heap\n"
             " *         is faster because it is only a heap approximation.\n"
             " *         Testing has shown the approximation results in\n"
-            " *         similiar QoR with less CPU work.\n")
-        .default_value("binary")
+            " *         similar QoR with less CPU work.\n")
+        .default_value("four_ary")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     route_timing_grp.add_argument(args.router_first_iteration_timing_report_file, "--router_first_iter_timing_report")
diff --git a/vpr/src/route/binary_heap.cpp b/vpr/src/route/binary_heap.cpp
@@ -5,7 +5,7 @@
 static inline size_t left(size_t i) { return i << 1; }
 static inline size_t right(size_t i) { return (i << 1) + 1; }
 
-size_t BinaryHeap::parent(size_t i) const { return i >> 1; }
+inline size_t BinaryHeap::parent(size_t i) const { return i >> 1; }
 
 bool BinaryHeap::is_valid() const {
     if (heap_.empty()) {
diff --git a/vpr/src/route/connection_router.cpp b/vpr/src/route/connection_router.cpp
@@ -1,6 +1,7 @@
 #include "connection_router.h"
 #include "rr_graph.h"
 
+#include "binary_heap.h"
 #include "four_ary_heap.h"
 #include "bucket.h"
 #include "rr_graph_fwd.h"
@@ -1155,6 +1156,16 @@ std::unique_ptr<ConnectionRouterInterface> make_connection_router(e_heap_type he
                                                                   bool is_flat) {
     switch (heap_type) {
         case e_heap_type::BINARY_HEAP:
+            return std::make_unique<ConnectionRouter<BinaryHeap>>(
+                grid,
+                router_lookahead,
+                rr_nodes,
+                rr_graph,
+                rr_rc_data,
+                rr_switch_inf,
+                rr_node_route_inf,
+                is_flat);
+        case e_heap_type::FOUR_ARY_HEAP:
             return std::make_unique<ConnectionRouter<FourAryHeap>>(
                 grid,
                 router_lookahead,
diff --git a/vpr/src/route/four_ary_heap.cpp b/vpr/src/route/four_ary_heap.cpp
@@ -3,10 +3,10 @@
 
 static inline size_t first_child(size_t i) { return (i << 2) - 2; }
 
-size_t FourAryHeap::parent(size_t i) const { return (i + 2) >> 2; }
+inline size_t FourAryHeap::parent(size_t i) const { return (i + 2) >> 2; }
 
-size_t FourAryHeap::smallest_child(size_t i) const {
-    // Returns heap_tail_ if i has no children
+inline size_t FourAryHeap::smallest_child(size_t i) const {
+    // Returns first_child(i) if i has no children
 
     size_t child_1 = first_child(i);
     size_t child_2 = child_1 + 1;
@@ -27,10 +27,8 @@ size_t FourAryHeap::smallest_child(size_t i) const {
         }
         case 2:
             return (heap_[child_1].cost < heap_[child_2].cost) ? child_1 : child_2;
-        case 1:
-            return child_1;
         default:
-            return heap_tail_;
+            return child_1;
     }
 }
 
@@ -75,9 +73,11 @@ t_heap* FourAryHeap::get_heap_head() {
         --heap_tail_;
 
         while (child < heap_tail_) {
+            child = smallest_child(hole);
+
             heap_[hole] = heap_[child];
             hole = child;
-            child = smallest_child(child);
+            child = first_child(hole);
         }
 
         sift_up(hole, heap_[heap_tail_]);
@@ -89,14 +89,13 @@ t_heap* FourAryHeap::get_heap_head() {
 // make a heap rooted at index hole by **sifting down** in O(lgn) time
 void FourAryHeap::sift_down(size_t hole) {
     heap_elem head{heap_[hole]};
-
     size_t child{smallest_child(hole)};
 
     while (child < heap_tail_) {
         if (heap_[child].cost < head.cost) {
             heap_[hole] = heap_[child];
             hole = child;
-            child = smallest_child(child);
+            child = smallest_child(hole);
         } else
             break;
     }
diff --git a/vpr/src/route/k_ary_heap.cpp b/vpr/src/route/k_ary_heap.cpp
@@ -62,7 +62,6 @@ size_t KAryHeap::size() const { return heap_tail_ - 1; } // heap[0] is not valid
 // runs in O(n) time by sifting down; the least work is done on the most elements: 1 swap for bottom layer, 2 swap for 2nd, ... lgn swap for top
 // 1*(n/2) + 2*(n/4) + 3*(n/8) + ... + lgn*1 = 2n (sum of i/2^i)
 void KAryHeap::build_heap() {
-    // second half of heap are leaves
     for (size_t i = parent(heap_tail_); i != 0; --i)
         sift_down(i);
 }
diff --git a/vpr/src/route/netlist_routers.h b/vpr/src/route/netlist_routers.h
@@ -16,6 +16,7 @@
  * of this interface. */
 
 #include "NetPinTimingInvalidator.h"
+#include "binary_heap.h"
 #include "four_ary_heap.h"
 #include "bucket.h"
 #include "clustered_netlist_utils.h"
@@ -154,6 +155,20 @@ inline std::unique_ptr<NetlistRouter> make_netlist_router(
     const vtr::vector<ParentNetId, std::vector<std::unordered_map<RRNodeId, int>>>& choking_spots,
     bool is_flat) {
     if (router_opts.router_heap == e_heap_type::BINARY_HEAP) {
+        return make_netlist_router_with_heap<BinaryHeap>(
+            net_list,
+            router_lookahead,
+            router_opts,
+            connections_inf,
+            net_delay,
+            netlist_pin_lookup,
+            timing_info,
+            pin_timing_invalidator,
+            budgeting_inf,
+            routing_predictor,
+            choking_spots,
+            is_flat);
+    } else if (router_opts.router_heap == e_heap_type::FOUR_ARY_HEAP) {
         return make_netlist_router_with_heap<FourAryHeap>(
             net_list,
             router_lookahead,
diff --git a/vpr/src/route/router_delay_profiling.h b/vpr/src/route/router_delay_profiling.h
@@ -2,6 +2,7 @@
 #define ROUTER_DELAY_PROFILING_H_
 
 #include "vpr_types.h"
+#include "binary_heap.h"
 #include "four_ary_heap.h"
 #include "connection_router.h"
 

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,6 @@ size_t KAryHeap::size() const { return heap_tail_ - 1; } // heap[0] is not valid`
`62`	`62`	`// runs in O(n) time by sifting down; the least work is done on the most elements: 1 swap for bottom layer, 2 swap for 2nd, ... lgn swap for top`
`63`	`63`	`// 1(n/2) + 2(n/4) + 3(n/8) + ... + lgn1 = 2n (sum of i/2^i)`
`64`	`64`	`void KAryHeap::build_heap() {`
`65`		`- // second half of heap are leaves`
`66`	`65`	`for (size_t i = parent(heap_tail_); i != 0; --i)`
`67`	`66`	`sift_down(i);`
`68`	`67`	`}`