add compressed_cluster_constraints

Author: soheilshahrouz

vpr/src/base/vpr_context.h

@@ -520,6 +520,8 @@ struct FloorplanningContext : public Context {
      */
     vtr::vector<ClusterBlockId, PartitionRegion> cluster_constraints;
 
+    vtr::vector<ClusterBlockId, PartitionRegion> compressed_cluster_constraints;
+
     std::vector<Region> overfull_regions;
 };
 

vpr/src/place/compressed_grid.h

@@ -55,6 +55,46 @@ struct t_compressed_block_grid {
         return {cx, cy, layer_num};
     }
 
+    inline t_physical_tile_loc grid_loc_to_compressed_loc_approx_round_up(t_physical_tile_loc grid_loc) const {
+        int cx = OPEN;
+        int cy = OPEN;
+        int layer_num = grid_loc.layer_num;
+
+        auto itr_x = std::upper_bound(compressed_to_grid_x[layer_num].begin(), compressed_to_grid_x[layer_num].end(), grid_loc.x);
+        if (itr_x == compressed_to_grid_x[layer_num].begin())
+            cx = 0;
+        else
+            cx = std::distance(compressed_to_grid_x[layer_num].begin(), itr_x - 1);
+
+        auto itr_y = std::upper_bound(compressed_to_grid_y[layer_num].begin(), compressed_to_grid_y[layer_num].end(), grid_loc.y);
+        if (itr_y == compressed_to_grid_y[layer_num].begin())
+            cy = 0;
+        else
+            cy = std::distance(compressed_to_grid_y[layer_num].begin(), itr_y - 1);
+
+        return {cx, cy, layer_num};
+    }
+
+    inline t_physical_tile_loc grid_loc_to_compressed_loc_approx_round_down(t_physical_tile_loc grid_loc) const {
+        int cx = OPEN;
+        int cy = OPEN;
+        int layer_num = grid_loc.layer_num;
+
+        auto itr_x = std::lower_bound(compressed_to_grid_x[layer_num].begin(), compressed_to_grid_x[layer_num].end(), grid_loc.x);
+        if (itr_x == compressed_to_grid_x[layer_num].end())
+            cx = std::distance(compressed_to_grid_x[layer_num].begin(), itr_x - 1);
+        else
+            cx = std::distance(compressed_to_grid_x[layer_num].begin(), itr_x);
+
+        auto itr_y = std::lower_bound(compressed_to_grid_y[layer_num].begin(), compressed_to_grid_y[layer_num].end(), grid_loc.y);
+        if (itr_y == compressed_to_grid_y[layer_num].end())
+            cy = std::distance(compressed_to_grid_y[layer_num].begin(), itr_y - 1);
+        else
+            cy = std::distance(compressed_to_grid_y[layer_num].begin(), itr_y);
+
+        return {cx, cy, layer_num};
+    }
+
     /**
      * @brief  find the nearest location in the compressed grid.
      *

vpr/src/place/initial_placement.cpp

@@ -1146,6 +1146,8 @@ void initial_placement(const t_placer_opts& placer_opts,
      * as fixed so they do not get moved during initial placement or later during the simulated annealing stage of placement*/
     mark_fixed_blocks();
 
+    alloc_and_load_compressed_cluster_constraints();
+
 
     // read the constraint file and place fixed blocks
     if (strlen(constraints_file) != 0) {

vpr/src/place/place_constraints.cpp

@@ -297,6 +297,49 @@ void mark_fixed_blocks() {
     }
 }
 
+void alloc_and_load_compressed_cluster_constraints() {
+    auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    // used to access the compressed grid
+    const auto& place_ctx = g_vpr_ctx.placement();
+
+    floorplanning_ctx.compressed_cluster_constraints.resize(cluster_ctx.clb_nlist.blocks().size());
+
+    for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
+        if (!is_cluster_constrained(blk_id)) {
+            continue;
+        }
+
+        const PartitionRegion& pr = floorplanning_ctx.cluster_constraints[blk_id];
+        auto block_type = cluster_ctx.clb_nlist.block_type(blk_id);
+        // Get the compressed grid for NoC
+        const auto& compressed_grid = place_ctx.compressed_block_grids[block_type->index];
+
+        PartitionRegion compressed_pr;
+
+        for (const Region& region : pr.get_regions()) {
+            RegionRectCoord rect = region.get_region_rect();
+            t_physical_tile_loc min_loc{rect.xmin, rect.ymin, rect.layer_num};
+            t_physical_tile_loc max_loc{rect.xmax, rect.ymax, rect.layer_num};
+            t_physical_tile_loc compressed_min_loc = compressed_grid.grid_loc_to_compressed_loc_approx_round_up(min_loc);
+            t_physical_tile_loc compressed_max_loc = compressed_grid.grid_loc_to_compressed_loc_approx_round_down(max_loc);
+
+            RegionRectCoord compressed_rect{compressed_min_loc.x, compressed_min_loc.y,
+                                            compressed_max_loc.x, compressed_max_loc.y,
+                                            rect.layer_num};
+
+            Region compressed_region;
+            compressed_region.set_region_rect(compressed_rect);
+            compressed_region.set_sub_tile(region.get_sub_tile());
+
+            compressed_pr.add_to_part_region(compressed_region);
+        }
+
+        floorplanning_ctx.compressed_cluster_constraints[blk_id] = compressed_pr;
+    }
+
+}
+
 /*
  * Returns 0, 1, or 2 depending on the number of tiles covered.
  * Will not return a value above 2 because as soon as num_tiles is above 1,

vpr/src/place/place_constraints.h

@@ -96,6 +96,8 @@ void load_cluster_constraints();
  */
 void mark_fixed_blocks();
 
+void alloc_and_load_compressed_cluster_constraints();
+
 /*
  * Returns the number of tiles covered by a floorplan region.
  * The return value of this routine will either be 0, 1, or 2. This