add comments

Author: soheilshahrouz

vpr/src/base/vpr_context.h

@@ -520,6 +520,15 @@ struct FloorplanningContext : public Context {
      */
     vtr::vector<ClusterBlockId, PartitionRegion> cluster_constraints;
 
+    /**
+     * @brief Floorplanning constraints specified in the compressed grid coordinate system.
+     *
+     * Each clustered block has a logical type, and each logical type has a corresponding compressed grid.
+     * Compressed floorplanning constraints are computed by translating grid location of floorplanning
+     * regions to compressed locations in the corresponding compressed grid. To ensure this translation
+     * does not enlarge the floorplanning regions, the bottom left corner of the region is rounded up
+     * in compresses location approximation, while the top right corner is rounded down.
+     */
     vtr::vector<ClusterBlockId, PartitionRegion> compressed_cluster_constraints;
 
     std::vector<Region> overfull_regions;

vpr/src/place/grid_tile_lookup.cpp

@@ -54,7 +54,7 @@ void GridTileLookup::fill_type_matrix(t_logical_block_type_ptr block_type, vtr::
     max_placement_locations[block_type->index] = type_count[0][0][0];
 }
 
-int GridTileLookup::total_type_tiles(t_logical_block_type_ptr block_type) {
+int GridTileLookup::total_type_tiles(t_logical_block_type_ptr block_type) const {
     return max_placement_locations[block_type->index];
 }
 
@@ -65,7 +65,7 @@ int GridTileLookup::total_type_tiles(t_logical_block_type_ptr block_type) {
  * and subtracting four values from within/at the edge of the region.
  * The region with subtile case is taken care of by a helper routine, region_with_subtile_count().
  */
-int GridTileLookup::region_tile_count(const Region& reg, t_logical_block_type_ptr block_type) {
+int GridTileLookup::region_tile_count(const Region& reg, t_logical_block_type_ptr block_type) const {
     auto& device_ctx = g_vpr_ctx.device();
     int subtile = reg.get_sub_tile();
     int layer_num = reg.get_layer_num();
@@ -120,7 +120,7 @@ int GridTileLookup::region_tile_count(const Region& reg, t_logical_block_type_pt
  * This routine is for the subtile specified case; an O(region_size) scan needs to be done to check whether each grid
  * location in the region is compatible for the block at the subtile specified.
  */
-int GridTileLookup::region_with_subtile_count(const Region& reg, t_logical_block_type_ptr block_type) {
+int GridTileLookup::region_with_subtile_count(const Region& reg, t_logical_block_type_ptr block_type) const{
     auto& device_ctx = g_vpr_ctx.device();
     int num_sub_tiles = 0;
 
@@ -134,8 +134,8 @@ int GridTileLookup::region_with_subtile_count(const Region& reg, t_logical_block
 
     for (int i = xmax; i >= xmin; i--) {
         for (int j = ymax; j >= ymin; j--) {
-            const auto& tile = device_ctx.grid.get_physical_type({i, j, reg_coord.layer_num});
-            if (is_sub_tile_compatible(tile, block_type, subtile)) {
+            const t_physical_tile_type_ptr tile_type = device_ctx.grid.get_physical_type({i, j, reg_coord.layer_num});
+            if (is_sub_tile_compatible(tile_type, block_type, subtile)) {
                 num_sub_tiles++;
             }
         }

vpr/src/place/grid_tile_lookup.h

@@ -31,11 +31,11 @@ class GridTileLookup {
 
     void fill_type_matrix(t_logical_block_type_ptr block_type, vtr::NdMatrix<int, 3>& type_count);
 
-    int region_tile_count(const Region& reg, t_logical_block_type_ptr block_type);
+    int region_tile_count(const Region& reg, t_logical_block_type_ptr block_type) const;
 
-    int region_with_subtile_count(const Region& reg, t_logical_block_type_ptr block_type);
+    int region_with_subtile_count(const Region& reg, t_logical_block_type_ptr block_type) const;
 
-    int total_type_tiles(t_logical_block_type_ptr block_type);
+    int total_type_tiles(t_logical_block_type_ptr block_type) const;
 
   private:
     /*

vpr/src/place/initial_placement.cpp

@@ -55,7 +55,7 @@ static void clear_all_grid_locs();
  *  1) try_centroid_placement : tries to find a location based on the macro's logical connections.
  *  2) try_place_macro_randomly : if no smart location found in the centroid placement, the function tries
  *  to place it randomly for the max number of tries.
- *  3) try_place_macro_exhaustively : if neither placement alogrithms work, the function will find a location
+ *  3) try_place_macro_exhaustively : if neither placement algorithms work, the function will find a location
  *  for the macro by exhaustively searching all available locations.  
  * If first iteration failed, next iteration calls dense placement for specific block types.
  *  
@@ -92,13 +92,13 @@ static vtr::vector<ClusterBlockId, t_block_score> assign_block_scores();
 static int get_y_loc_based_on_macro_direction(t_grid_empty_locs_block_type first_macro_loc, const t_pl_macro& pl_macro);
 
 /**
- * @brief Tries to get the first available location of a specific block type that can accomodate macro blocks
+ * @brief Tries to get the first available location of a specific block type that can accommodate macro blocks
  *
  *   @param loc The first available location that can place the macro blocks.
  *   @param pl_macro The macro to be placed.
  *   @param blk_types_empty_locs_in_grid first location (lowest y) and number of remaining blocks in each column for the blk_id type 
  *
- * @return index to a column of blk_types_empty_locs_in_grid that can accomodate pl_macro and location of first available location returned by reference
+ * @return index to a column of blk_types_empty_locs_in_grid that can accommodate pl_macro and location of first available location returned by reference
  */
 static int get_blk_type_first_loc(t_pl_loc& loc, const t_pl_macro& pl_macro, std::vector<t_grid_empty_locs_block_type>* blk_types_empty_locs_in_grid);
 
@@ -144,7 +144,9 @@ static inline void fix_IO_block_types(const t_pl_macro& pl_macro, t_pl_loc loc,
  * 
  * @return True if the location is legal for the macro head member, false otherwise.
  */
-static bool is_loc_legal(t_pl_loc& loc, PartitionRegion& pr, t_logical_block_type_ptr block_type);
+static bool is_loc_legal(const t_pl_loc& loc,
+                         const PartitionRegion& pr,
+                         t_logical_block_type_ptr block_type);
 
 /**
  * @brief Calculates a centroid location for a block based on its placed connections.
@@ -180,7 +182,7 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc, t_logical_block_type_
  * @return true if the macro gets placed, false if not.
  */
 static bool try_centroid_placement(const t_pl_macro& pl_macro,
-                                   PartitionRegion& pr,
+                                   const PartitionRegion& pr,
                                    t_logical_block_type_ptr block_type,
                                    enum e_pad_loc_type pad_loc_type,
                                    vtr::vector<ClusterBlockId, t_block_score>& block_scores);
@@ -199,7 +201,7 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro,
  * @return true if the macro gets placed, false if not.
  */
 static bool try_dense_placement(const t_pl_macro& pl_macro,
-                                PartitionRegion& pr,
+                                const PartitionRegion& pr,
                                 t_logical_block_type_ptr block_type,
                                 enum e_pad_loc_type pad_loc_type,
                                 std::vector<t_grid_empty_locs_block_type>* blk_types_empty_locs_in_grid);
@@ -253,7 +255,9 @@ bool is_block_placed(ClusterBlockId blk_id) {
     return (place_ctx.block_locs[blk_id].loc.x != INVALID_X);
 }
 
-static bool is_loc_legal(t_pl_loc& loc, PartitionRegion& pr, t_logical_block_type_ptr block_type) {
+static bool is_loc_legal(const t_pl_loc& loc,
+                         const PartitionRegion& pr,
+                         t_logical_block_type_ptr block_type) {
     const auto& grid = g_vpr_ctx.device().grid;
     bool legal = false;
 
@@ -424,7 +428,11 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
     return connected_blocks_to_update;
 }
 
-static bool try_centroid_placement(const t_pl_macro& pl_macro, PartitionRegion& pr, t_logical_block_type_ptr block_type, enum e_pad_loc_type pad_loc_type, vtr::vector<ClusterBlockId, t_block_score>& block_scores) {
+static bool try_centroid_placement(const t_pl_macro& pl_macro,
+                                   const PartitionRegion& pr,
+                                   t_logical_block_type_ptr block_type,
+                                   enum e_pad_loc_type pad_loc_type,
+                                   vtr::vector<ClusterBlockId, t_block_score>& block_scores) {
     t_pl_loc centroid_loc(OPEN, OPEN, OPEN, OPEN);
     std::vector<ClusterBlockId> unplaced_blocks_to_update_their_score;
 
@@ -453,7 +461,7 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro, PartitionRegion&
     auto& device_ctx = g_vpr_ctx.device();
     //choose the location's subtile if the centroid location is legal.
     //if the location is found within the "find_centroid_neighbor", it already has a subtile
-    //we don't need to find one agian
+    //we don't need to find one again
     if (!neighbor_legal_loc) {
         const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[block_type->index];
         const auto& type = device_ctx.grid.get_physical_type({centroid_loc.x, centroid_loc.y, centroid_loc.layer});
@@ -515,7 +523,7 @@ static void update_blk_type_first_loc(int blk_type_column_index,
 static int get_blk_type_first_loc(t_pl_loc& loc,
                                   const t_pl_macro& pl_macro,
                                   std::vector<t_grid_empty_locs_block_type>* blk_types_empty_locs_in_grid) {
-    //loop over all empty locations and choose first column that can accomodate macro blocks
+    //loop over all empty locations and choose first column that can accommodate macro blocks
     for (unsigned int empty_loc_index = 0; empty_loc_index < blk_types_empty_locs_in_grid->size(); empty_loc_index++) {
         auto first_empty_loc = blk_types_empty_locs_in_grid->at(empty_loc_index);
 
@@ -743,7 +751,7 @@ bool try_place_macro_exhaustively(const t_pl_macro& pl_macro, const PartitionReg
 }
 
 static bool try_dense_placement(const t_pl_macro& pl_macro,
-                                PartitionRegion& pr,
+                                const PartitionRegion& pr,
                                 t_logical_block_type_ptr block_type,
                                 enum e_pad_loc_type pad_loc_type,
                                 std::vector<t_grid_empty_locs_block_type>* blk_types_empty_locs_in_grid) {
@@ -911,7 +919,7 @@ static vtr::vector<ClusterBlockId, t_block_score> assign_block_scores() {
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
         block_scores[blk_id].number_of_placed_connections = 0;
         if (is_cluster_constrained(blk_id)) {
-            PartitionRegion pr = floorplan_ctx.cluster_constraints[blk_id];
+            const PartitionRegion& pr = floorplan_ctx.cluster_constraints[blk_id];
             auto block_type = cluster_ctx.clb_nlist.block_type(blk_id);
             double floorplan_score = get_floorplan_score(blk_id, pr, block_type, grid_tiles);
             block_scores[blk_id].tiles_outside_of_floorplan_constraints = floorplan_score;
@@ -943,7 +951,7 @@ static void place_all_blocks([[maybe_unused]] const t_placer_opts& placer_opts,
     //keep tracks of which block types can not be placed in each iteration
     std::unordered_set<int> unplaced_blk_type_in_curr_itr;
 
-    auto criteria = [&block_scores, &cluster_ctx](const ClusterBlockId& lhs, const ClusterBlockId& rhs) {
+    auto criteria = [&block_scores, &cluster_ctx](ClusterBlockId lhs, ClusterBlockId rhs) {
         int lhs_score = block_scores[lhs].macro_size + block_scores[lhs].number_of_placed_connections + SORT_WEIGHT_PER_TILES_OUTSIDE_OF_PR * block_scores[lhs].tiles_outside_of_floorplan_constraints + SORT_WEIGHT_PER_FAILED_BLOCK * block_scores[lhs].failed_to_place_in_prev_attempts;
         int rhs_score = block_scores[rhs].macro_size + block_scores[rhs].number_of_placed_connections + SORT_WEIGHT_PER_TILES_OUTSIDE_OF_PR * block_scores[rhs].tiles_outside_of_floorplan_constraints + SORT_WEIGHT_PER_FAILED_BLOCK * block_scores[rhs].failed_to_place_in_prev_attempts;
 
@@ -1146,6 +1154,7 @@ 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();
 
+    // Compute and store compressed floorplanning constraints
     alloc_and_load_compressed_cluster_constraints();
 
 

vpr/src/place/move_utils.cpp

@@ -1263,30 +1263,30 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
                                                       int layer_num) {
     const auto& floorplanning_ctx = g_vpr_ctx.floorplanning();
 
-    const PartitionRegion& pr = floorplanning_ctx.compressed_cluster_constraints[b_from];
-    const std::vector<Region>& regions = pr.get_regions();
-    Region intersect_reg;
+    // get the block floorplanning constraints specified in the compressed grid
+    const PartitionRegion& compressed_pr = floorplanning_ctx.compressed_cluster_constraints[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.
      * In this case, we return true (i.e. the range limit intersects with
      * the floorplan constraints) to simplify the problem. This simplification can be done because
      * this routine is done for cpu time optimization, so we do not have to necessarily check each
      * complicated case to get correct functionality during place moves.
      */
-    if (regions.size() == 1) {
+    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});
 
-        intersect_reg = intersection(regions[0], range_reg);
+        Region compressed_intersect_reg = intersection(compressed_regions[0], range_reg);
 
-        if (intersect_reg.empty()) {
+        if (compressed_intersect_reg.empty()) {
             VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug,
                            "\tCouldn't find an intersection between floorplan constraints and search region\n");
             return false;
         } else {
-            const auto intersect_coord = intersect_reg.get_region_rect();
+            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;

vpr/src/place/place_constraints.cpp

@@ -480,7 +480,9 @@ bool is_pr_size_one(PartitionRegion& pr, t_logical_block_type_ptr block_type, t_
     return pr_size_one;
 }
 
-int get_part_reg_size(PartitionRegion& pr, t_logical_block_type_ptr block_type, GridTileLookup& grid_tiles) {
+int get_part_reg_size(const PartitionRegion& pr,
+                      t_logical_block_type_ptr block_type,
+                      const GridTileLookup& grid_tiles) {
     const std::vector<Region>& regions = pr.get_regions();
     int num_tiles = 0;
 
@@ -491,7 +493,10 @@ int get_part_reg_size(PartitionRegion& pr, t_logical_block_type_ptr block_type,
     return num_tiles;
 }
 
-double get_floorplan_score(ClusterBlockId blk_id, PartitionRegion& pr, t_logical_block_type_ptr block_type, GridTileLookup& grid_tiles) {
+double get_floorplan_score(ClusterBlockId blk_id,
+                           const PartitionRegion& pr,
+                           t_logical_block_type_ptr block_type,
+                           const GridTileLookup& grid_tiles) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     int num_pr_tiles = get_part_reg_size(pr, block_type, grid_tiles);

vpr/src/place/place_constraints.h

@@ -1,3 +1,6 @@
+#ifndef VPR_SRC_PLACE_PLACE_CONSTRAINTS_H_
+#define VPR_SRC_PLACE_PLACE_CONSTRAINTS_H_
+
 /*
  * place_constraints.h
  *
@@ -12,9 +15,6 @@
 #include "place_macro.h"
 #include "grid_tile_lookup.h"
 
-#ifndef VPR_SRC_PLACE_PLACE_CONSTRAINTS_H_
-#    define VPR_SRC_PLACE_PLACE_CONSTRAINTS_H_
-
 /*
  * Check that placement of each block is within the floorplan constraint region of that block (if the block has any constraints).
  * Returns the number of errors (inconsistencies in adherence to floorplanning constraints).
@@ -131,14 +131,19 @@ bool is_pr_size_one(PartitionRegion& pr, t_logical_block_type_ptr block_type, t_
  * Used prior to initial placement to help sort blocks based on how difficult they
  * are to place.
  */
-int get_part_reg_size(PartitionRegion& pr, t_logical_block_type_ptr block_type, GridTileLookup& grid_tiles);
+int get_part_reg_size(const PartitionRegion& pr,
+                      t_logical_block_type_ptr block_type,
+                      const GridTileLookup& grid_tiles);
 
 /*
  * Return the floorplan score that will be used for sorting blocks during initial placement. This score is the
  * total number of subtiles for the block type in the grid, minus the number of subtiles in the block's floorplan PartitionRegion.
  * The resulting number is the number of tiles outside the block's floorplan region, meaning the higher
  * it is, the more difficult the block is to place.
  */
-double get_floorplan_score(ClusterBlockId blk_id, PartitionRegion& pr, t_logical_block_type_ptr block_type, GridTileLookup& grid_tiles);
+double get_floorplan_score(ClusterBlockId blk_id,
+                           const PartitionRegion& pr,
+                           t_logical_block_type_ptr block_type,
+                           const GridTileLookup& grid_tiles);
 
 #endif /* VPR_SRC_PLACE_PLACE_CONSTRAINTS_H_ */