Merge remote-tracking branches 'upstream/optimize_ndmatrix', 'upstream/fix_rr_reader', 'upstream/refactor_heap2' and 'upstream/fix_log_type' into master+wip

Author: litghost

libs/libvtrutil/src/vtr_ndmatrix.h

@@ -28,27 +28,21 @@ class NdMatrixProxy {
     //  idim: The dimension associated with this proxy
     //  dim_stride: The stride of this dimension (i.e. how many element in memory between indicies of this dimension)
     //  start: Pointer to the start of the sub-matrix this proxy represents
-    NdMatrixProxy<T, N>(const size_t* dim_sizes, size_t idim, size_t dim_stride, T* start)
+    NdMatrixProxy<T, N>(const size_t* dim_sizes, const size_t* dim_strides, T* start)
         : dim_sizes_(dim_sizes)
-        , idim_(idim)
-        , dim_stride_(dim_stride)
+        , dim_strides_(dim_strides)
         , start_(start) {}
 
     const NdMatrixProxy<T, N - 1> operator[](size_t index) const {
         VTR_ASSERT_SAFE_MSG(index >= 0, "Index out of range (below dimension minimum)");
-        VTR_ASSERT_SAFE_MSG(index < dim_sizes_[idim_], "Index out of range (above dimension maximum)");
-
-        size_t next_dim_size = dim_sizes_[idim_ + 1];
-        VTR_ASSERT_SAFE_MSG(next_dim_size > 0, "Can not index into zero-sized dimension");
-
-        //Determine the stride of the next dimension
-        size_t next_dim_stride = dim_stride_ / next_dim_size;
+        VTR_ASSERT_SAFE_MSG(index < dim_sizes_[0], "Index out of range (above dimension maximum)");
+        VTR_ASSERT_SAFE_MSG(dim_sizes_[1] > 0, "Can not index into zero-sized dimension");
 
         //Strip off one dimension
-        return NdMatrixProxy<T, N - 1>(dim_sizes_,                    //Pass the dimension information
-                                       idim_ + 1,                     //Pass the next dimension
-                                       next_dim_stride,               //Pass the stride for the next dimension
-                                       start_ + dim_stride_ * index); //Advance to index in this dimension
+        return NdMatrixProxy<T, N - 1>(
+            dim_sizes_ + 1,                    //Pass the dimension information
+            dim_strides_ + 1,                  //Pass the stride for the next dimension
+            start_ + dim_strides_[0] * index); //Advance to index in this dimension
     }
 
     NdMatrixProxy<T, N - 1> operator[](size_t index) {
@@ -58,25 +52,23 @@ class NdMatrixProxy {
 
   private:
     const size_t* dim_sizes_;
-    const size_t idim_;
-    const size_t dim_stride_;
+    const size_t* dim_strides_;
     T* start_;
 };
 
 //Base case: 1-dimensional array
 template<typename T>
 class NdMatrixProxy<T, 1> {
   public:
-    NdMatrixProxy<T, 1>(const size_t* dim_sizes, size_t idim, size_t dim_stride, T* start)
+    NdMatrixProxy<T, 1>(const size_t* dim_sizes, const size_t* dim_stride, T* start)
         : dim_sizes_(dim_sizes)
-        , idim_(idim)
-        , dim_stride_(dim_stride)
+        , dim_strides_(dim_stride)
         , start_(start) {}
 
     const T& operator[](size_t index) const {
-        VTR_ASSERT_SAFE_MSG(dim_stride_ == 1, "Final dimension must have stride 1");
+        VTR_ASSERT_SAFE_MSG(dim_strides_[0] == 1, "Final dimension must have stride 1");
         VTR_ASSERT_SAFE_MSG(index >= 0, "Index out of range (below dimension minimum)");
-        VTR_ASSERT_SAFE_MSG(index < dim_sizes_[idim_], "Index out of range (above dimension maximum)");
+        VTR_ASSERT_SAFE_MSG(index < dim_sizes_[0], "Index out of range (above dimension maximum)");
 
         //Base case
         return start_[index];
@@ -103,8 +95,7 @@ class NdMatrixProxy<T, 1> {
 
   private:
     const size_t* dim_sizes_;
-    const size_t idim_;
-    const size_t dim_stride_;
+    const size_t* dim_strides_;
     T* start_;
 };
 
@@ -207,12 +198,21 @@ class NdMatrixBase {
         size_ = calc_size();
         alloc();
         fill(value);
+        if (size_ > 0) {
+            dim_strides_[0] = size_ / dim_sizes_[0];
+            for (size_t dim = 1; dim < N; ++dim) {
+                dim_strides_[dim] = dim_strides_[dim - 1] / dim_sizes_[dim];
+            }
+        } else {
+            dim_strides_.fill(0);
+        }
     }
 
     //Reset the matrix to size zero
     void clear() {
         data_.reset(nullptr);
         dim_sizes_.fill(0);
+        dim_strides_.fill(0);
         size_ = 0;
     }
 
@@ -242,6 +242,7 @@ class NdMatrixBase {
         using std::swap;
         swap(m1.size_, m2.size_);
         swap(m1.dim_sizes_, m2.dim_sizes_);
+        swap(m1.dim_strides_, m2.dim_strides_);
         swap(m1.data_, m2.data_);
     }
 
@@ -265,6 +266,7 @@ class NdMatrixBase {
   protected:
     size_t size_ = 0;
     std::array<size_t, N> dim_sizes_;
+    std::array<size_t, N> dim_strides_;
     std::unique_ptr<T[]> data_ = nullptr;
 };
 
@@ -316,17 +318,11 @@ class NdMatrix : public NdMatrixBase<T, N> {
         VTR_ASSERT_SAFE_MSG(index >= 0, "Index out of range (below dimension minimum)");
         VTR_ASSERT_SAFE_MSG(index < this->dim_sizes_[0], "Index out of range (above dimension maximum)");
 
-        //Calculate the stride for the current dimension
-        size_t dim_stride = this->size() / this->dim_size(0);
-
-        //Calculate the stride for the next dimension
-        size_t next_dim_stride = dim_stride / this->dim_size(1);
-
         //Peel off the first dimension
-        return NdMatrixProxy<T, N - 1>(this->dim_sizes_.data(),                 //Pass the dimension information
-                                       1,                                       //Pass the next dimension
-                                       next_dim_stride,                         //Pass the stride for the next dimension
-                                       this->data_.get() + dim_stride * index); //Advance to index in this dimension
+        return NdMatrixProxy<T, N - 1>(
+            this->dim_sizes_.data() + 1,                        //Pass the dimension information
+            this->dim_strides_.data() + 1,                      //Pass the stride for the next dimension
+            this->data_.get() + this->dim_strides_[0] * index); //Advance to index in this dimension
     }
 
     //Access an element

vpr/src/place/place.cpp

@@ -278,8 +278,8 @@ std::unique_ptr<FILE, decltype(&vtr::fclose)> f_move_stats_file(nullptr, vtr::fc
                 t_pl_loc to = affected_blocks.moved_blocks[0].new_loc;                         \
                 ClusterBlockId b_to = place_ctx.grid_blocks[to.x][to.y].blocks[to.z];          \
                                                                                                \
-                t_physical_tile_type_ptr from_type = cluster_ctx.clb_nlist.block_type(b_from); \
-                t_physical_tile_type_ptr to_type = nullptr;                                    \
+                t_logical_block_type_ptr from_type = cluster_ctx.clb_nlist.block_type(b_from); \
+                t_logical_block_type_ptr to_type = nullptr;                                    \
                 if (b_to) {                                                                    \
                     to_type = cluster_ctx.clb_nlist.block_type(b_to);                          \
                 }                                                                              \

vpr/src/route/bucket.cpp

@@ -0,0 +1,213 @@
+#include "bucket.h"
+
+std::vector<t_heap*> BucketItems::heap_items_;
+size_t BucketItems::alloced_items_ = 0;
+int BucketItems::num_heap_allocated_ = 0;
+t_heap* BucketItems::heap_free_head_ = nullptr;
+vtr::t_chunk BucketItems::heap_ch_;
+
+void Bucket::init(const DeviceGrid& grid) {
+    vtr::free(heap_);
+    heap_ = nullptr;
+
+    heap_size_ = (grid.width() - 1) * (grid.height() - 1);
+    heap_ = (t_heap**)vtr::malloc(heap_size_ * sizeof(t_heap*));
+    memset(heap_, 0, heap_size_ * sizeof(t_heap*));
+
+    heap_head_ = std::numeric_limits<size_t>::max();
+    heap_tail_ = 0;
+
+    conv_factor_ = kDefaultConvFactor;
+
+    min_cost_ = std::numeric_limits<float>::max();
+    max_cost_ = std::numeric_limits<float>::min();
+}
+
+void Bucket::free() {
+    vtr::free(heap_);
+    heap_ = nullptr;
+}
+
+void Bucket::expand(size_t required_number_of_buckets) {
+    auto old_size = heap_size_;
+    heap_size_ = required_number_of_buckets * 2;
+
+    heap_ = (t_heap**)vtr::realloc((void*)(heap_),
+                                   heap_size_ * sizeof(t_heap*));
+    std::fill(heap_ + old_size, heap_ + heap_size_, nullptr);
+}
+
+void Bucket::verify() {
+    for (size_t bucket = heap_head_; bucket <= heap_tail_; ++bucket) {
+        for (t_heap* data = heap_[bucket]; data != nullptr;
+             data = data->next_bucket) {
+            VTR_ASSERT(data->cost > 0 && ((size_t)cost_to_int(data->cost)) == bucket);
+        }
+    }
+}
+
+size_t Bucket::seed_ = 1231;
+t_heap** Bucket::heap_ = nullptr;
+size_t Bucket::heap_size_ = 0;
+size_t Bucket::heap_head_ = std::numeric_limits<size_t>::max();
+size_t Bucket::heap_tail_ = 0;
+float Bucket::min_cost_ = 0.f;
+float Bucket::max_cost_ = 0.f;
+float Bucket::conv_factor_ = 0.f;
+
+void Bucket::clear() {
+    if (heap_head_ != std::numeric_limits<size_t>::max()) {
+        std::fill(heap_ + heap_head_, heap_ + heap_tail_ + 1, nullptr);
+    }
+    heap_head_ = std::numeric_limits<size_t>::max();
+    heap_tail_ = 0;
+}
+
+void Bucket::check_scaling() {
+    float min_cost = min_cost_;
+    float max_cost = max_cost_;
+    VTR_ASSERT(max_cost != std::numeric_limits<float>::min());
+    if (min_cost == std::numeric_limits<float>::max()) {
+        min_cost = max_cost;
+    }
+    auto min_bucket = cost_to_int(min_cost);
+    auto max_bucket = cost_to_int(max_cost);
+
+    if (min_bucket < 0 || max_bucket < 0 || max_bucket > 1000000) {
+        // If min and max are close to each other, assume 3 orders of
+        // magnitude between min and max.
+        //
+        // If min and max are at least 3 orders of magnitude apart, scale
+        // soley based on max cost.
+        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);
+
+        // Reheap after adjusting scaling.
+        if (heap_head_ != std::numeric_limits<size_t>::max()) {
+            std::vector<t_heap*> reheap;
+            for (size_t bucket = heap_head_; bucket <= heap_tail_; ++bucket) {
+                for (t_heap* item = heap_[bucket]; item != nullptr; item = item->next_bucket) {
+                    reheap.push_back(item);
+                }
+            }
+
+            std::fill(heap_ + heap_head_, heap_ + heap_tail_ + 1, nullptr);
+            heap_head_ = std::numeric_limits<size_t>::max();
+            heap_tail_ = 0;
+
+            for (t_heap* item : reheap) {
+                push(item);
+            }
+        }
+    }
+}
+
+void Bucket::push(t_heap* hptr) {
+    float cost = hptr->cost;
+    if (!std::isfinite(cost)) {
+        return;
+    }
+
+    bool check_scale = false;
+    // Exclude 0 cost from min_cost to provide useful scaling factor.
+    if (cost < min_cost_ && cost > 0) {
+        min_cost_ = cost;
+        check_scale = true;
+    }
+    if (cost > max_cost_) {
+        max_cost_ = cost;
+        check_scale = true;
+    }
+
+    if (check_scale) {
+        check_scaling();
+    }
+
+    // Which bucket should this go into?
+    auto int_cost = cost_to_int(cost);
+
+    if (int_cost < 0) {
+        VTR_LOG_WARN("Cost is negative? cost = %g, bucket = %d\n", cost, int_cost);
+        int_cost = 0;
+    }
+
+    size_t uint_cost = int_cost;
+
+    // Is that bucket allocated?
+    if (uint_cost >= heap_size_) {
+        // Not enough buckets!
+        expand(uint_cost);
+    }
+
+    // Insert into bucket
+    auto* prev = heap_[uint_cost];
+    hptr->next_bucket = prev;
+    heap_[uint_cost] = hptr;
+
+    if (uint_cost < heap_head_) {
+        heap_head_ = uint_cost;
+    }
+    if (uint_cost > heap_tail_) {
+        heap_tail_ = uint_cost;
+    }
+}
+
+t_heap* Bucket::pop() {
+    auto heap_head = heap_head_;
+    auto heap_tail = heap_tail_;
+    t_heap** heap = heap_;
+
+    // Check empty
+    if (heap_head == std::numeric_limits<size_t>::max()) {
+        return nullptr;
+    }
+
+    // Find first non-empty bucket
+
+    // Randomly remove element
+    size_t count = fast_rand() % 4;
+
+    t_heap* prev = nullptr;
+    t_heap* next = heap[heap_head];
+    for (size_t i = 0; i < count && next->next_bucket != nullptr; ++i) {
+        prev = next;
+        next = prev->next_bucket;
+    }
+
+    if (prev == nullptr) {
+        heap[heap_head] = next->next_bucket;
+    } else {
+        prev->next_bucket = next->next_bucket;
+    }
+
+    // Update first non-empty bucket if bucket is now empty
+    if (heap[heap_head] == nullptr) {
+        heap_head += 1;
+        while (heap_head <= heap_tail && heap[heap_head] == nullptr) {
+            heap_head += 1;
+        }
+
+        if (heap_head > heap_tail) {
+            heap_head = std::numeric_limits<size_t>::max();
+        }
+
+        heap_head_ = heap_head;
+    }
+
+    return next;
+}
+
+void Bucket::print() {
+    for (size_t i = heap_head_; i < heap_tail_; ++i) {
+        if (heap_[heap_head_] != nullptr) {
+            VTR_LOG("B:%d ", i);
+            for (auto* item = heap_[i]; item != nullptr; item = item->next_bucket) {
+                VTR_LOG(" %e", item->cost);
+            }
+        }
+    }
+    VTR_LOG("\n");
+}