update place_constraints.cpp to support layer range

Author: soheilshahrouz

libs/libvtrutil/src/vtr_geometry.h

@@ -92,11 +92,18 @@ class Point {
     ///@brief Swap x and y values
     void swap();
 
+    /// @brief += operator
+    Point<T>& operator+= (const Point<T>& rhs);
+
+    /// @brief += operator
+    Point<T>& operator-= (const Point<T>& rhs);
+
   private:
     T x_;
     T y_;
 };
 
+
 /**
  * @brief A 2D rectangle
  *
@@ -193,6 +200,11 @@ class Rect {
     ///@brief set ymax to a point
     void set_ymax(T ymax_val);
 
+    /// @brief += operator
+    Rect<T>& operator+= (const Point<T>& rhs);
+
+    Rect<T>& operator-= (const Point<T>& rhs);
+
     ///@brief Equivalent to `*this = bounding_box(*this, other)`
     Rect<T>& expand_bounding_box(const Rect<T>& other);
 

libs/libvtrutil/src/vtr_geometry.tpp

@@ -58,6 +58,20 @@ void Point<T>::swap() {
     std::swap(x_, y_);
 }
 
+template<class T>
+Point<T>& Point<T>::operator+=(const Point<T>& rhs) {
+    x_ += rhs.x_;
+    y_ += rhs.y_;
+    return *this;
+}
+
+template<class T>
+Point<T>& Point<T>::operator-=(const Point<T>& rhs) {
+    x_ -= rhs.x_;
+    y_ -= rhs.y_;
+    return *this;
+}
+
 /*
  * Rect
  */
@@ -229,6 +243,20 @@ void Rect<T>::set_ymax(T ymax_val) {
     top_right_.set_y(ymax_val);
 }
 
+template<class T>
+Rect<T>& Rect<T>::operator+=(const Point<T>& rhs) {
+    bottom_left_ += rhs;
+    top_right_ += rhs;
+    return *this;
+}
+
+template<class T>
+Rect<T>& Rect<T>::operator-=(const Point<T>& rhs) {
+    bottom_left_ -= rhs;
+    top_right_ -= rhs;
+    return *this;
+}
+
 template<class T>
 Rect<T>& Rect<T>::expand_bounding_box(const Rect<T>& other) {
     *this = bounding_box(*this, other);

vpr/src/base/region.cpp

@@ -120,7 +120,7 @@ Region intersection(const Region& r1, const Region& r2) {
     auto [r2_layer_begin, r2_layer_end] = r2.get_region_bounds().get_layer_range();
 
     auto [intersect_layer_begin, intersect_layer_end] = std::make_pair(std::max(r1_layer_begin, r2_layer_begin),
-                                                                                std::min(r1_layer_end, r2_layer_begin));
+                                                                                std::min(r1_layer_end, r2_layer_end));
 
     if (intersect_layer_begin > intersect_layer_end || intersect_layer_begin < 0 || intersect_layer_end < 0) {
         return {};

vpr/src/base/vpr_context.h

@@ -529,7 +529,7 @@ struct FloorplanningContext : public Context {
      * - The bottom left corner is rounded up to the nearest compressed location.
      * - The top right corner is rounded down to the nearest compressed location.
      */
-    vtr::vector<ClusterBlockId, PartitionRegion> compressed_cluster_constraints;
+    std::vector<vtr::vector<ClusterBlockId, PartitionRegion>> compressed_cluster_constraints;
 
     std::vector<Region> overfull_regions;
 };

vpr/src/place/initial_placement.cpp

@@ -837,7 +837,6 @@ static bool place_macro(int macros_max_num_tries,
     bool macro_placed = false;
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
-    auto& device_ctx = g_vpr_ctx.device();
 
     // Assume that all the blocks in the macro are of the same type
     auto block_type = cluster_ctx.clb_nlist.block_type(blk_id);

vpr/src/place/move_utils.cpp

@@ -1264,7 +1264,7 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
     const auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
 
     // get the block floorplanning constraints specified in the compressed grid
-    const PartitionRegion& compressed_pr = floorplanning_ctx.compressed_cluster_constraints[b_from];
+    const PartitionRegion& compressed_pr = floorplanning_ctx.compressed_cluster_constraints[layer_num][b_from];
     const std::vector<Region>& compressed_regions = compressed_pr.get_regions();
     /*
      * If region size is greater than 1, the block is constrained to more than one rectangular region.
@@ -1275,9 +1275,9 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
      */
     if (compressed_regions.size() == 1) {
         Region range_reg;
-        range_reg.set_region_rect({search_range.xmin, search_range.ymin,
-                                   search_range.xmax, search_range.ymax,
-                                   layer_num});
+        range_reg.set_region_bounds({search_range.xmin, search_range.ymin,
+                                     search_range.xmax, search_range.ymax,
+                                     layer_num});
 
         Region compressed_intersect_reg = intersection(compressed_regions[0], range_reg);
 
@@ -1286,15 +1286,15 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
                            "\tCouldn't find an intersection between floorplan constraints and search region\n");
             return false;
         } else {
-            const auto intersect_coord = compressed_intersect_reg.get_region_rect();
-            VTR_ASSERT(intersect_coord.layer_num == layer_num);
-
-            delta_cx = intersect_coord.xmax -  intersect_coord.xmin;
-            search_range.xmin = intersect_coord.xmin;
-            search_range.ymin = intersect_coord.ymin;
-            search_range.xmax = intersect_coord.xmax;
-            search_range.ymax = intersect_coord.ymax;
-            search_range.layer_max = search_range.layer_min = layer_num;
+            const vtr::Rect<int>& intersect_rect = compressed_intersect_reg.get_region_bounds().get_rect();
+            const auto [layer_low, layer_high] = compressed_intersect_reg.get_region_bounds().get_layer_range();
+            VTR_ASSERT(layer_low == layer_num && layer_high == layer_num);
+
+            delta_cx = intersect_rect.xmax() -  intersect_rect.xmin();
+            std::tie(search_range.xmin, search_range.ymin,
+                     search_range.xmax, search_range.ymax) = intersect_rect.coordinates();
+            search_range.layer_min = layer_low;
+            search_range.layer_max = layer_high;
         }
     }