verilog-to-routing · amin1377 · Apr 1, 2025 · Apr 1, 2025 · Apr 1, 2025 · Apr 1, 2025
diff --git a/libs/libarchfpga/src/physical_types_util.cpp b/libs/libarchfpga/src/physical_types_util.cpp
@@ -652,6 +652,11 @@ bool is_io_type(t_physical_tile_type_ptr type) {
            || is_output_type(type);
 }
 
+bool is_io_type(t_logical_block_type_ptr type) {
+    auto physical_tile = pick_physical_type(type);
+    return is_io_type(physical_tile);
+}
+
 std::string block_type_pin_index_to_name(t_physical_tile_type_ptr type, int pin_physical_num, bool is_flat) {
     int max_ptc = get_tile_pin_max_ptc(type, is_flat);
     VTR_ASSERT(pin_physical_num < max_ptc);

diff --git a/libs/libarchfpga/src/physical_types_util.h b/libs/libarchfpga/src/physical_types_util.h
@@ -127,6 +127,9 @@ bool is_output_type(t_physical_tile_type_ptr type);
 ///@brief Returns true if the given physical tile type can implement either a .input or .output block type
 bool is_io_type(t_physical_tile_type_ptr type);
 
+///@brief Returns true if the given logical block type is an IO block
+bool is_io_type(t_logical_block_type_ptr type);
+
 /**
  * @brief Returns the corresponding physical pin based on the input parameters:
  *

diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -421,6 +421,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;

diff --git a/vpr/src/place/initial_noc_placement.cpp b/vpr/src/place/initial_noc_placement.cpp
@@ -126,7 +126,13 @@ static void place_constrained_noc_router(ClusterBlockId router_blk_id,
 
     bool macro_placed = false;
     for (int i_try = 0; i_try < MAX_NUM_TRIES_TO_PLACE_MACROS_RANDOMLY && !macro_placed; i_try++) {
-        macro_placed = try_place_macro_randomly(pl_macro, pr, block_type, e_pad_loc_type::FREE, blk_loc_registry, rng);
+        macro_placed = try_place_macro_randomly(pl_macro,
+                                                pr,
+                                                /*block_constrained*/ true,
+                                                block_type,
+                                                e_pad_loc_type::FREE,
+                                                blk_loc_registry,
+                                                rng);
     }
 
     if (!macro_placed) {

diff --git a/vpr/src/place/initial_placement.cpp b/vpr/src/place/initial_placement.cpp
@@ -206,6 +206,7 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
 static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
+                                   bool block_constrained,
                                    int r_lim,
                                    const BlkLocRegistry& blk_loc_registry,
                                    vtr::RngContainer& rng);
@@ -227,6 +228,7 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
  */
 static bool try_centroid_placement(const t_pl_macro& pl_macro,
                                    const PartitionRegion& pr,
+                                   bool block_constrained,
                                    t_logical_block_type_ptr block_type,
                                    e_pad_loc_type pad_loc_type,
                                    vtr::vector<ClusterBlockId, t_block_score>& block_scores,
@@ -403,6 +405,7 @@ bool find_subtile_in_location(t_pl_loc& centroid,
 static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
+                                   bool block_constrained,
                                    int rlim,
                                    const BlkLocRegistry& blk_loc_registry,
                                    vtr::RngContainer& rng) {
@@ -440,6 +443,7 @@ static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                                          /*is_median=*/false,
                                                          centroid_loc_layer_num,
                                                          search_for_empty,
+                                                         block_constrained,
                                                          blk_loc_registry,
                                                          rng);
 
@@ -834,6 +838,7 @@ static inline t_pl_loc find_nearest_compatible_loc(const t_flat_pl_loc& src_flat
 
 static bool try_centroid_placement(const t_pl_macro& pl_macro,
                                    const PartitionRegion& pr,
+                                   bool block_constrained,
                                    t_logical_block_type_ptr block_type,
                                    e_pad_loc_type pad_loc_type,
                                    vtr::vector<ClusterBlockId, t_block_score>& block_scores,
@@ -889,7 +894,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(centroid_loc, block_type, false, block_constrained, rlim, blk_loc_registry, rng);
         if (!neighbor_legal_loc) { //no neighbor candidate found
             return false;
         }
@@ -1024,6 +1029,7 @@ static inline void fix_IO_block_types(const t_pl_macro& pl_macro,
 
 bool try_place_macro_randomly(const t_pl_macro& pl_macro,
                               const PartitionRegion& pr,
+                              bool block_constrained,
                               t_logical_block_type_ptr block_type,
                               e_pad_loc_type pad_loc_type,
                               BlkLocRegistry& blk_loc_registry,
@@ -1075,6 +1081,7 @@ bool try_place_macro_randomly(const t_pl_macro& pl_macro,
                                                     /*is_median=*/false,
                                                     selected_layer,
                                                     /*search_for_empty=*/false,
+                                                    block_constrained,
                                                     blk_loc_registry,
                                                     rng);
 
@@ -1282,13 +1289,13 @@ static bool place_macro(int macros_max_num_tries,
 
     // Assume that all the blocks in the macro are of the same type
     auto block_type = cluster_ctx.clb_nlist.block_type(blk_id);
-
-    const PartitionRegion& pr = (is_cluster_constrained(blk_id)) ? floorplanning_ctx.cluster_constraints[blk_id]
-                                                                 : get_device_partition_region();
+    auto block_constrained = is_cluster_constrained(blk_id);
+    const PartitionRegion& pr = block_constrained ? floorplanning_ctx.cluster_constraints[blk_id]
+                                                  : get_device_partition_region();
 
     //Enough to check head member of macro to see if its constrained because
     //constraints propagation was done earlier in initial placement.
-    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug && is_cluster_constrained(blk_id),
+    VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug && block_constrained,
                    "\t\t\tMacro's head is constrained\n");
 
     //If blk_types_empty_locs_in_grid is not NULL, means that initial placement has been failed in first iteration for this block type
@@ -1300,13 +1307,13 @@ 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(pl_macro, pr, block_constrained, 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
     for (int itry = 0; itry < macros_max_num_tries && !macro_placed; itry++) {
         VTR_LOGV_DEBUG(g_vpr_ctx.placement().f_placer_debug, "\t\t\tTry random place iter: %d\n", itry);
-        macro_placed = try_place_macro_randomly(pl_macro, pr, block_type, pad_loc_type, blk_loc_registry, rng);
+        macro_placed = try_place_macro_randomly(pl_macro, pr, block_constrained, block_type, pad_loc_type, blk_loc_registry, rng);
     } // Finished all tries
 
     if (!macro_placed) {

diff --git a/vpr/src/place/initial_placement.h b/vpr/src/place/initial_placement.h
@@ -74,6 +74,7 @@ struct t_grid_empty_locs_block_type {
  */
 bool try_place_macro_randomly(const t_pl_macro& pl_macro,
                               const PartitionRegion& pr,
+                              bool block_constrained,
                               t_logical_block_type_ptr block_type,
                               e_pad_loc_type pad_loc_type,
                               BlkLocRegistry& blk_loc_registry,

diff --git a/vpr/src/place/move_utils.cpp b/vpr/src/place/move_utils.cpp
@@ -19,6 +19,8 @@
 //Note: The flag is only effective if compiled with VTR_ENABLE_DEBUG_LOGGING
 bool f_placer_breakpoint_reached = false;
 
+constexpr int MIN_NUMBER_OF_BLOCK_PER_COLUMN = 3;
+
 //Accessor for f_placer_breakpoint_reached
 bool placer_breakpoint_reached() {
     return f_placer_breakpoint_reached;
@@ -669,10 +671,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;
+    auto 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,
@@ -681,6 +682,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,
@@ -690,6 +694,7 @@ bool find_to_loc_uniform(t_logical_block_type_ptr type,
                                                     /*is_median=*/false,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
+                                                    block_constrained,
                                                     blk_loc_registry,
                                                     rng);
 
@@ -761,10 +766,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;
+    auto 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,
@@ -774,6 +778,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],
@@ -782,6 +788,7 @@ bool find_to_loc_median(t_logical_block_type_ptr blk_type,
                                                     /*is_median=*/true,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
+                                                    block_constrained,
                                                     blk_loc_registry,
                                                     rng);
 
@@ -850,10 +857,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;
+    auto 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,
@@ -863,7 +869,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],
@@ -872,6 +881,7 @@ bool find_to_loc_centroid(t_logical_block_type_ptr blk_type,
                                                     /*is_median=*/false,
                                                     to_layer_num,
                                                     /*search_for_empty=*/false,
+                                                    block_constrained,
                                                     blk_loc_registry,
                                                     rng);
 
@@ -966,6 +976,7 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
                                              bool is_median,
                                              int to_layer_num,
                                              bool search_for_empty,
+                                             bool block_constrained,
                                              const BlkLocRegistry& blk_loc_registry,
                                              vtr::RngContainer& rng) {
     //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
@@ -1006,22 +1017,15 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
         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;
-            }
+        if (block_rows.size() < MIN_NUMBER_OF_BLOCK_PER_COLUMN && !block_constrained) {
+            //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);

diff --git a/vpr/src/place/move_utils.h b/vpr/src/place/move_utils.h
@@ -328,6 +328,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
+ * fixed_search_range: 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,6 +338,7 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
                                              bool is_median,
                                              int to_layer_num,
                                              bool search_for_empty,
+                                             bool block_constrained,
                                              const BlkLocRegistry& blk_loc_registry,
                                              vtr::RngContainer& rng);