Add prune checking to both heap types.

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

Author: litghost

vpr/src/route/binary_heap.cpp

@@ -9,7 +9,9 @@ static size_t right(size_t i) { return (i << 1) + 1; }
 BinaryHeap::BinaryHeap()
     : heap_(nullptr)
     , heap_size_(0)
-    , heap_tail_(0) {}
+    , heap_tail_(0)
+    , max_index_(std::numeric_limits<size_t>::max())
+    , prune_limit_(std::numeric_limits<size_t>::max()) {}
 
 BinaryHeap::~BinaryHeap() {
     free_all_memory();
@@ -26,7 +28,7 @@ void BinaryHeap::free(t_heap* hptr) {
 //       or realloc() must be eliminated from add_to_heap()
 //       because there is no C++ equivalent.
 void BinaryHeap::init_heap(const DeviceGrid& grid) {
-    ssize_t target_heap_size = (grid.width() - 1) * (grid.height() - 1);
+    size_t target_heap_size = (grid.width() - 1) * (grid.height() - 1);
     if (heap_ == nullptr || heap_size_ < target_heap_size) {
         if (heap_ != nullptr) {
             // coverity[offset_free : Intentional]
@@ -45,6 +47,11 @@ void BinaryHeap::add_to_heap(t_heap* hptr) {
     // start with undefined hole
     ++heap_tail_;
     sift_up(heap_tail_ - 1, hptr);
+
+    // If we have pruned, rebuild the heap now.
+    if (check_prune_limit()) {
+        build_heap();
+    }
 }
 
 bool BinaryHeap::is_empty_heap() const {
@@ -70,7 +77,7 @@ t_heap* BinaryHeap::get_heap_head() {
         hole = 1;
         child = 2;
         --heap_tail_;
-        while ((int)child < heap_tail_) {
+        while (child < heap_tail_) {
             if (heap_[child + 1]->cost < heap_[child]->cost)
                 ++child; // become right child
             heap_[hole] = heap_[child];
@@ -85,20 +92,20 @@ t_heap* BinaryHeap::get_heap_head() {
 }
 
 void BinaryHeap::empty_heap() {
-    for (int i = 1; i < heap_tail_; i++)
+    for (size_t i = 1; i < heap_tail_; i++)
         free(heap_[i]);
 
     heap_tail_ = 1;
 }
 
-size_t BinaryHeap::size() const { return static_cast<size_t>(heap_tail_ - 1); } // heap[0] is not valid element
+size_t BinaryHeap::size() const { return heap_tail_ - 1; } // heap[0] is not valid element
 
 // make a heap rooted at index hole by **sifting down** in O(lgn) time
 void BinaryHeap::sift_down(size_t hole) {
     t_heap* head{heap_[hole]};
     size_t child{left(hole)};
-    while ((int)child < heap_tail_) {
-        if ((int)child + 1 < heap_tail_ && heap_[child + 1]->cost < heap_[child]->cost)
+    while (child < heap_tail_) {
+        if (child + 1 < heap_tail_ && heap_[child + 1]->cost < heap_[child]->cost)
             ++child;
         if (heap_[child]->cost < head->cost) {
             heap_[hole] = heap_[child];
@@ -118,6 +125,14 @@ void BinaryHeap::build_heap() {
         sift_down(i);
 }
 
+void BinaryHeap::set_prune_limit(size_t max_index, size_t prune_limit) {
+    if (prune_limit != std::numeric_limits<size_t>::max()) {
+        VTR_ASSERT(max_index < prune_limit);
+    }
+    max_index_ = max_index;
+    prune_limit_ = prune_limit;
+}
+
 // O(lgn) sifting up to maintain heap property after insertion (should sift down when building heap)
 void BinaryHeap::sift_up(size_t leaf, t_heap* const node) {
     while ((leaf > 1) && (node->cost < heap_[parent(leaf)]->cost)) {
@@ -142,16 +157,18 @@ void BinaryHeap::push_back(t_heap* const hptr) {
     expand_heap_if_full();
     heap_[heap_tail_] = hptr;
     ++heap_tail_;
+
+    check_prune_limit();
 }
 
 bool BinaryHeap::is_valid() const {
     if (heap_ == nullptr) {
         return false;
     }
 
-    for (size_t i = 1; (int)i <= heap_tail_ >> 1; ++i) {
-        if ((int)left(i) < heap_tail_ && heap_[left(i)]->cost < heap_[i]->cost) return false;
-        if ((int)right(i) < heap_tail_ && heap_[right(i)]->cost < heap_[i]->cost) return false;
+    for (size_t i = 1; i <= heap_tail_ >> 1; ++i) {
+        if (left(i) < heap_tail_ && heap_[left(i)]->cost < heap_[i]->cost) return false;
+        if (right(i) < heap_tail_ && heap_[right(i)]->cost < heap_[i]->cost) return false;
     }
     return true;
 }
@@ -166,7 +183,7 @@ void BinaryHeap::invalidate_heap_entries(int sink_node, int ipin_node) {
      * architectures.
      * */
 
-    for (int i = 1; i < heap_tail_; i++) {
+    for (size_t i = 1; i < heap_tail_; i++) {
         if (heap_[i]->index == sink_node) {
             if (heap_[i]->prev_node() == ipin_node) {
                 heap_[i]->index = OPEN; /* Invalid. */
@@ -188,3 +205,57 @@ void BinaryHeap::free_all_memory() {
 
     storage_.free_all_memory();
 }
+
+bool BinaryHeap::check_prune_limit() {
+    if (heap_tail_ > prune_limit_) {
+        prune_heap();
+        return true;
+    }
+
+    return false;
+}
+
+void BinaryHeap::prune_heap() {
+    VTR_ASSERT(max_index_ < prune_limit_);
+
+    std::vector<t_heap*> best_heap_item(max_index_, nullptr);
+
+    // Find the cheapest instance of each index and store it.
+    for (size_t i = 1; i < heap_tail_; i++) {
+        if (heap_[i] == nullptr) {
+            continue;
+        }
+
+        if (heap_[i]->index == OPEN) {
+            free(heap_[i]);
+            heap_[i] = nullptr;
+            continue;
+        }
+
+        VTR_ASSERT(static_cast<size_t>(heap_[i]->index) < max_index_);
+
+        if (best_heap_item[heap_[i]->index] == nullptr || best_heap_item[heap_[i]->index]->cost > heap_[i]->cost) {
+            best_heap_item[heap_[i]->index] = heap_[i];
+        }
+    }
+
+    // Free unused nodes.
+    for (size_t i = 1; i < heap_tail_; i++) {
+        if (heap_[i] == nullptr) {
+            continue;
+        }
+
+        if (best_heap_item[heap_[i]->index] != heap_[i]) {
+            free(heap_[i]);
+            heap_[i] = nullptr;
+        }
+    }
+
+    heap_tail_ = 1;
+
+    for (size_t i = 0; i < max_index_; ++i) {
+        if (best_heap_item[i] != nullptr) {
+            heap_[heap_tail_++] = best_heap_item[i];
+        }
+    }
+}

vpr/src/route/binary_heap.h

@@ -19,6 +19,7 @@ class BinaryHeap : public HeapInterface {
     void empty_heap() final;
     t_heap* get_heap_head() final;
     void build_heap() final;
+    void set_prune_limit(size_t max_index, size_t prune_limit) final;
 
     void invalidate_heap_entries(int sink_node, int ipin_node) final;
 
@@ -29,11 +30,16 @@ class BinaryHeap : public HeapInterface {
     void sift_up(size_t leaf, t_heap* const node);
     void sift_down(size_t hole);
     void expand_heap_if_full();
+    bool check_prune_limit();
+    void prune_heap();
 
     HeapStorage storage_;
-    t_heap** heap_; /* Indexed from [1..heap_size] */
-    int heap_size_; /* Number of slots in the heap array */
-    int heap_tail_; /* Index of first unused slot in the heap array */
+    t_heap** heap_;    /* Indexed from [1..heap_size] */
+    size_t heap_size_; /* Number of slots in the heap array */
+    size_t heap_tail_; /* Index of first unused slot in the heap array */
+
+    size_t max_index_;
+    size_t prune_limit_;
 };
 
 #endif /* _BINARY_HEAP_H */

vpr/src/route/bucket.cpp

@@ -2,6 +2,7 @@
 
 #include <cmath>
 #include "vtr_log.h"
+#include "vpr_error.h"
 
 BucketItems::BucketItems() noexcept
     : alloced_items_(0)
@@ -17,7 +18,10 @@ Bucket::Bucket() noexcept
     , heap_tail_(0)
     , conv_factor_(0.f)
     , min_cost_(0.f)
-    , max_cost_(0.f) {}
+    , max_cost_(0.f)
+    , num_items_(0)
+    , max_index_(std::numeric_limits<size_t>::max())
+    , prune_limit_(std::numeric_limits<size_t>::max()) {}
 
 Bucket::~Bucket() {
     free_all_memory();
@@ -33,6 +37,7 @@ void Bucket::init_heap(const DeviceGrid& grid) {
 
     heap_head_ = std::numeric_limits<size_t>::max();
     heap_tail_ = 0;
+    num_items_ = 0;
 
     conv_factor_ = kDefaultConvFactor;
 
@@ -60,7 +65,13 @@ void Bucket::verify() {
     for (size_t bucket = heap_head_; bucket <= heap_tail_; ++bucket) {
         for (BucketItem* data = heap_[bucket]; data != nullptr;
              data = data->next_bucket) {
-            VTR_ASSERT(data->item.cost > 0 && ((size_t)cost_to_int(data->item.cost)) == bucket);
+            VTR_ASSERT(data->item.cost >= 0);
+            int bucket_idx = cost_to_int(data->item.cost);
+            if (bucket_idx != static_cast<ssize_t>(bucket)) {
+                VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                                "Wrong bucket for cost %g bucket_idx %d bucket %zu conv_factor %g",
+                                data->item.cost, bucket_idx, bucket, conv_factor_);
+            }
         }
     }
 }
@@ -73,11 +84,22 @@ void Bucket::empty_heap() {
     }
     heap_head_ = std::numeric_limits<size_t>::max();
     heap_tail_ = 0;
+    num_items_ = 0;
 
     // Quickly reset all items to being free'd
     items_.clear();
 }
 
+float Bucket::rescale_func() const {
+    return 50000.f / max_cost_ / std::max(1.f, 1000.f / (max_cost_ / min_cost_));
+}
+
+void Bucket::check_conv_factor() const {
+    VTR_ASSERT(cost_to_int(min_cost_) >= 0);
+    VTR_ASSERT(cost_to_int(max_cost_) >= 0);
+    VTR_ASSERT(cost_to_int(max_cost_) < 1000000);
+}
+
 // Checks if the scaling factor for cost results in a reasonable
 // number of buckets based on the maximum cost value seen.
 //
@@ -113,11 +135,8 @@ void Bucket::check_scaling() {
         // maximum cost increases.  The underlying assumption of this scaling
         // algorithm is that the maximum cost will not result in a poor
         // scaling factor such that all precision is lost.
-        conv_factor_ = 50000.f / max_cost_ / std::max(1.f, 1000.f / (max_cost_ / min_cost_));
-
-        VTR_ASSERT(cost_to_int(min_cost_) >= 0);
-        VTR_ASSERT(cost_to_int(max_cost_) >= 0);
-        VTR_ASSERT(cost_to_int(max_cost_) < 1000000);
+        conv_factor_ = rescale_func();
+        check_conv_factor();
 
         // Reheap after adjusting scaling.
         if (heap_head_ != std::numeric_limits<size_t>::max()) {
@@ -200,6 +219,11 @@ void Bucket::push_back(t_heap* hptr) {
     if (uint_cost > heap_tail_) {
         heap_tail_ = uint_cost;
     }
+
+    num_items_ += 1;
+    if (num_items_ > prune_limit_) {
+        prune_heap();
+    }
 }
 
 t_heap* Bucket::get_heap_head() {
@@ -245,6 +269,7 @@ t_heap* Bucket::get_heap_head() {
     }
 
     outstanding_items_ += 1;
+    num_items_ -= 1;
     return &next->item;
 }
 
@@ -263,3 +288,69 @@ void Bucket::print() {
     }
     VTR_LOG("\n");
 }
+
+void Bucket::set_prune_limit(size_t max_index, size_t prune_limit) {
+    if (prune_limit != std::numeric_limits<size_t>::max()) {
+        VTR_ASSERT(max_index < prune_limit);
+    }
+    max_index_ = max_index;
+    prune_limit_ = prune_limit;
+}
+
+void Bucket::prune_heap() {
+    std::vector<BucketItem*> best_heap_item(max_index_, nullptr);
+
+    for (size_t bucket = heap_head_; bucket <= heap_tail_; ++bucket) {
+        for (BucketItem* item = heap_[bucket]; item != nullptr; item = item->next_bucket) {
+            VTR_ASSERT(static_cast<size_t>(item->item.index) < max_index_);
+            if (best_heap_item[item->item.index] == nullptr || best_heap_item[item->item.index]->item.cost > item->item.cost) {
+                best_heap_item[item->item.index] = item;
+            }
+        }
+    }
+
+    min_cost_ = std::numeric_limits<float>::max();
+    max_cost_ = std::numeric_limits<float>::min();
+    for (size_t bucket = heap_head_; bucket <= heap_tail_; ++bucket) {
+        BucketItem* item = heap_[bucket];
+        while (item != nullptr) {
+            BucketItem* next_item = item->next_bucket;
+
+            if (best_heap_item[item->item.index] != item) {
+                // This item isn't the cheapest, return it to the free list.
+                items_.free_item(item);
+            } else {
+                // Update min_cost_ and max_cost_
+                if (min_cost_ > item->item.cost) {
+                    min_cost_ = item->item.cost;
+                }
+                if (max_cost_ < item->item.cost) {
+                    max_cost_ = item->item.cost;
+                }
+            }
+
+            item = next_item;
+        }
+    }
+
+    // Rescale heap after pruning.
+    conv_factor_ = rescale_func();
+    check_conv_factor();
+
+    std::fill(heap_, heap_ + heap_size_, nullptr);
+    heap_head_ = std::numeric_limits<size_t>::max();
+    heap_tail_ = 0;
+    num_items_ = 0;
+
+    // Re-heap the pruned elements.
+    for (BucketItem* item : best_heap_item) {
+        if (item == nullptr) {
+            continue;
+        }
+
+        outstanding_items_ += 1;
+        push_back(&item->item);
+    }
+
+    verify();
+}