Merge pull request #2960 from verilog-to-routing/placement_search_range

[Place] Expand search range for sparse blocks

Author: amin1377

libs/libarchfpga/src/physical_types.cpp

@@ -230,9 +230,20 @@ bool t_logical_block_type::is_empty() const {
     return name == std::string(EMPTY_BLOCK_NAME);
 }
 
+bool t_logical_block_type::is_io() const {
+    // Iterate over all equivalent tiles and return true if any
+    // of them are IO tiles
+    for (t_physical_tile_type_ptr tile : equivalent_tiles) {
+        if (tile->is_io()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 const t_port* t_logical_block_type::get_port(std::string_view port_name) const {
     for (int i = 0; i < pb_type->num_ports; i++) {
-        auto port = pb_type->ports[i];
+        const t_port& port = pb_type->ports[i];
         if (port_name == port.name) {
             return &pb_type->ports[port.index];
         }

libs/libarchfpga/src/physical_types.h

@@ -1002,6 +1002,9 @@ struct t_logical_block_type {
     // Is this t_logical_block_type empty?
     bool is_empty() const;
 
+    // Returns true if this logical block type is an IO block
+    bool is_io() const;
+
   public:
     /**
      * @brief Returns the logical block port given the port name and the corresponding logical block type

vpr/src/base/vpr_types.h

@@ -411,6 +411,13 @@ struct t_net_power {
 /**
  * @brief Stores a 3D bounding box in terms of the minimum and
  *        maximum coordinates: x, y, layer
+ * 
+ * @var xmin: The minimum x-coordinate of the bounding box
+ * @var xmax: The maximum x-coordinate of the bounding box
+ * @var ymin: The minimum y-coordinate of the bounding box
+ * @var ymax: The maximum y-coordinate of the bounding box
+ * @var layer_min: The minimum layer of the bounding box
+ * @var layer_max: The maximum layer of the bounding box
  */
 struct t_bb {
     t_bb() = default;

vpr/src/place/initial_placement.cpp

@@ -203,7 +203,8 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
  *
  * @return true if the function can find any location near the centroid one, false otherwise.
  */
-static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
+static bool find_centroid_neighbor(ClusterBlockId block_id,
+                                   t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
                                    int r_lim,
@@ -212,7 +213,8 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
 
 /**
  * @brief  tries to place a macro at a centroid location of its placed connections.
- *
+ *  
+ *   @param block_id The block to be placed.
  *   @param pl_macro The macro to be placed.
  *   @param pr The PartitionRegion of the macro - represents its floorplanning constraints, is the size of the whole chip if the macro is not
  *   constrained.
@@ -225,7 +227,8 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
  *
  * @return true if the macro gets placed, false if not.
  */
-static bool try_centroid_placement(const t_pl_macro& pl_macro,
+static bool try_centroid_placement(ClusterBlockId block_id,
+                                   const t_pl_macro& pl_macro,
                                    const PartitionRegion& pr,
                                    t_logical_block_type_ptr block_type,
                                    e_pad_loc_type pad_loc_type,
@@ -400,7 +403,8 @@ bool find_subtile_in_location(t_pl_loc& centroid,
     return false;
 }
 
-static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
+static bool find_centroid_neighbor(ClusterBlockId block_id,
+                                   t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
                                    int rlim,
@@ -425,6 +429,18 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
 
     int delta_cx = search_range.xmax - search_range.xmin;
 
+    bool block_constrained = is_cluster_constrained(block_id);
+
+    if (block_constrained) {
+        bool intersect = intersect_range_limit_with_floorplan_constraints(block_id,
+                                                                          search_range,
+                                                                          delta_cx,
+                                                                          centroid_loc_layer_num);
+        if (!intersect) {
+            return false;
+        }
+    }
+
     //Block has not been placed yet, so the "from" coords will be (-1, -1)
     int cx_from = OPEN;
     int cy_from = OPEN;
@@ -441,7 +457,8 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                                          centroid_loc_layer_num,
                                                          search_for_empty,
                                                          blk_loc_registry,
-                                                         rng);
+                                                         rng,
+                                                         block_constrained);
 
     if (!legal) {
         return false;
@@ -832,7 +849,8 @@ static inline t_pl_loc find_nearest_compatible_loc(const t_flat_pl_loc& src_flat
     return best_loc;
 }
 
-static bool try_centroid_placement(const t_pl_macro& pl_macro,
+static bool try_centroid_placement(ClusterBlockId block_id,
+                                   const t_pl_macro& pl_macro,
                                    const PartitionRegion& pr,
                                    t_logical_block_type_ptr block_type,
                                    e_pad_loc_type pad_loc_type,
@@ -889,7 +907,7 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro,
     //centroid suggestion was either occupied or does not match block type
     //try to find a near location that meet these requirements
     if (!found_legal_subtile) {
-        bool neighbor_legal_loc = find_centroid_neighbor(centroid_loc, block_type, false, rlim, blk_loc_registry, rng);
+        bool neighbor_legal_loc = find_centroid_neighbor(block_id, centroid_loc, block_type, false, rlim, blk_loc_registry, rng);
         if (!neighbor_legal_loc) { //no neighbor candidate found
             return false;
         }
@@ -1065,6 +1083,9 @@ bool try_place_macro_randomly(const t_pl_macro& pl_macro,
 
     bool legal;
 
+    // is_fixed_range is true since even if the block is not constrained,
+    // the search range covers the entire region, so there is no need for
+    // the search range to be adjusted
     legal = find_compatible_compressed_loc_in_range(block_type,
                                                     delta_cx,
                                                     {cx_from, cy_from, selected_layer},
@@ -1076,7 +1097,8 @@ bool try_place_macro_randomly(const t_pl_macro& pl_macro,
                                                     selected_layer,
                                                     /*search_for_empty=*/false,
                                                     blk_loc_registry,
-                                                    rng);
+                                                    rng,
+                                                    /*is_range_fixed=*/true);
 
     if (!legal) {
         //No valid position found
@@ -1300,7 +1322,7 @@ static bool place_macro(int macros_max_num_tries,
 
     if (!macro_placed) {
         VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry centroid placement\n");
-        macro_placed = try_centroid_placement(pl_macro, pr, block_type, pad_loc_type, block_scores, blk_loc_registry, flat_placement_info, rng);
+        macro_placed = try_centroid_placement(blk_id, pl_macro, pr, block_type, pad_loc_type, block_scores, blk_loc_registry, flat_placement_info, rng);
     }
     VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tMacro is placed: %d\n", macro_placed);
     // If macro is not placed yet, try to place the macro randomly for the max number of random tries

vpr/src/place/move_utils.cpp

@@ -16,6 +16,24 @@
 //Note: The flag is only effective if compiled with VTR_ENABLE_DEBUG_LOGGING
 bool f_placer_breakpoint_reached = false;
 
+/**
+ * @brief Adjust the search range based on how many blocks are in the column.
+ * If the number of blocks in the column is less than MIN_NUM_BLOCKS_IN_COLUMN,
+ * expand the search range to cover the entire column.
+ * 
+ * @param block_type The type of the block to move
+ * @param compressed_column_num The compressed column to move the block to
+ * @param to_layer_num The layer that the block is moving to
+ * @param is_range_fixed Whether the search range is fixed (e.g., in case of placement constraints)
+ * @param search_range The search range to adjust
+ * 
+ */
+static void adjust_search_range(t_logical_block_type_ptr block_type,
+                                const int compressed_column_num,
+                                const int to_layer_num,
+                                const bool is_range_fixed,
+                                t_bb& search_range);
+
 //Accessor for f_placer_breakpoint_reached
 bool placer_breakpoint_reached() {
     return f_placer_breakpoint_reached;
@@ -666,10 +684,9 @@ bool find_to_loc_uniform(t_logical_block_type_ptr type,
                                                                 rlim);
     int delta_cx = search_range.xmax - search_range.xmin;
 
-    t_physical_tile_loc to_compressed_loc;
-    bool legal = false;
+    bool block_constrained = is_cluster_constrained(b_from);
 
-    if (is_cluster_constrained(b_from)) {
+    if (block_constrained) {
         bool intersect = intersect_range_limit_with_floorplan_constraints(b_from,
                                                                           search_range,
                                                                           delta_cx,
@@ -678,6 +695,9 @@ bool find_to_loc_uniform(t_logical_block_type_ptr type,
             return false;
         }
     }
+
+    t_physical_tile_loc to_compressed_loc;
+    bool legal = false;
     //TODO: For now, we only move the blocks on the same tile
     legal = find_compatible_compressed_loc_in_range(type,
                                                     delta_cx,
@@ -688,7 +708,8 @@ bool find_to_loc_uniform(t_logical_block_type_ptr type,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
                                                     blk_loc_registry,
-                                                    rng);
+                                                    rng,
+                                                    block_constrained);
 
     if (!legal) {
         //No valid position found
@@ -758,10 +779,9 @@ bool find_to_loc_median(t_logical_block_type_ptr blk_type,
                       to_layer_num,
                       to_layer_num);
 
-    t_physical_tile_loc to_compressed_loc;
-    bool legal = false;
+    bool block_constrained = is_cluster_constrained(b_from);
 
-    if (is_cluster_constrained(b_from)) {
+    if (block_constrained) {
         bool intersect = intersect_range_limit_with_floorplan_constraints(b_from,
                                                                           search_range,
                                                                           delta_cx,
@@ -771,6 +791,8 @@ bool find_to_loc_median(t_logical_block_type_ptr blk_type,
         }
     }
 
+    t_physical_tile_loc to_compressed_loc;
+    bool legal = false;
     legal = find_compatible_compressed_loc_in_range(blk_type,
                                                     delta_cx,
                                                     from_compressed_locs[to_layer_num],
@@ -780,7 +802,8 @@ bool find_to_loc_median(t_logical_block_type_ptr blk_type,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
                                                     blk_loc_registry,
-                                                    rng);
+                                                    rng,
+                                                    block_constrained);
 
     if (!legal) {
         //No valid position found
@@ -847,10 +870,9 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
     }
     delta_cx = search_range.xmax - search_range.xmin;
 
-    t_physical_tile_loc to_compressed_loc;
-    bool legal = false;
+    bool block_constrained = is_cluster_constrained(b_from);
 
-    if (is_cluster_constrained(b_from)) {
+    if (block_constrained) {
         bool intersect = intersect_range_limit_with_floorplan_constraints(b_from,
                                                                           search_range,
                                                                           delta_cx,
@@ -860,7 +882,10 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
         }
     }
 
-    //TODO: For now, we only move the blocks on the same tile
+    t_physical_tile_loc to_compressed_loc;
+    bool legal = false;
+
+    //TODO: For now, we only move the blocks on the same layer
     legal = find_compatible_compressed_loc_in_range(blk_type,
                                                     delta_cx,
                                                     from_compressed_loc[to_layer_num],
@@ -870,7 +895,8 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
                                                     blk_loc_registry,
-                                                    rng);
+                                                    rng,
+                                                    block_constrained);
 
     if (!legal) {
         //No valid position found
@@ -964,7 +990,8 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
                                              int to_layer_num,
                                              bool search_for_empty,
                                              const BlkLocRegistry& blk_loc_registry,
-                                             vtr::RngContainer& rng) {
+                                             vtr::RngContainer& rng,
+                                             const bool is_range_fixed) {
     //TODO For the time being, the blocks only moved in the same layer. This assertion should be removed after VPR is updated to move blocks between layers
     VTR_ASSERT(to_layer_num == from_loc.layer_num);
     const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[type->index];
@@ -999,28 +1026,17 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
         //The candidates are stored in a flat_map so we can efficiently find the set of valid
         //candidates with upper/lower bound.
         const auto& block_rows = compressed_block_grid.get_column_block_map(to_loc.x, to_layer_num);
+        adjust_search_range(type,
+                            to_loc.x,
+                            to_layer_num,
+                            is_range_fixed,
+                            search_range);
         auto y_lower_iter = block_rows.lower_bound(search_range.ymin);
         if (y_lower_iter == block_rows.end()) {
             continue;
         }
-
         auto y_upper_iter = block_rows.upper_bound(search_range.ymax);
 
-        if (y_lower_iter->first > search_range.ymin) {
-            //No valid blocks at this x location which are within rlim_y
-            //
-            if (type->index != 1)
-                continue;
-            else {
-                //Fall back to allow the whole y range
-                y_lower_iter = block_rows.begin();
-                y_upper_iter = block_rows.end();
-
-                search_range.ymin = y_lower_iter->first;
-                search_range.ymax = (y_upper_iter - 1)->first;
-            }
-        }
-
         int y_range = std::distance(y_lower_iter, y_upper_iter);
         VTR_ASSERT(y_range >= 0);
 
@@ -1199,6 +1215,25 @@ bool intersect_range_limit_with_floorplan_constraints(ClusterBlockId b_from,
     return true;
 }
 
+static void adjust_search_range(t_logical_block_type_ptr block_type,
+                                const int compressed_column_num,
+                                const int to_layer_num,
+                                const bool is_range_fixed,
+                                t_bb& search_range) {
+    // The value is chosen empirically to expand the search range for sparse blocks,
+    // or blocks located on the perimeter of the FPGA (e.g., IO blocks)
+    constexpr int MIN_NUM_BLOCKS_IN_COLUMN = 3;
+
+    const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[block_type->index];
+
+    size_t num_blocks_in_column = compressed_block_grid.get_column_block_map(compressed_column_num, to_layer_num).size();
+
+    if (num_blocks_in_column < MIN_NUM_BLOCKS_IN_COLUMN && !is_range_fixed) {
+        search_range.ymin = 0;
+        search_range.ymax = compressed_block_grid.get_num_rows(to_layer_num) - 1;
+    }
+}
+
 std::string e_move_result_to_string(e_move_result move_outcome) {
     switch (move_outcome) {
         case e_move_result::REJECTED:

vpr/src/place/move_utils.h

@@ -327,6 +327,7 @@ int find_empty_compatible_subtile(t_logical_block_type_ptr type,
  * is_median: true if this is called from find_to_loc_median
  * to_layer_num: the layer number of the new location (set by the caller)
  * search_for_empty: indicates that the returned location must be empty
+ * is_range_fixed: indicates that the search range is fixed and should not be adjusted
  */
 bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
                                              int delta_cx,
@@ -337,7 +338,8 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
                                              int to_layer_num,
                                              bool search_for_empty,
                                              const BlkLocRegistry& blk_loc_registry,
-                                             vtr::RngContainer& rng);
+                                             vtr::RngContainer& rng,
+                                             const bool is_range_fixed);
 
 /**
  * @brief Get the the compressed loc from the uncompressed loc (grid_loc)