updated the helper find_subtile_in_location structure and comments.

Author: haydar-c

vpr/src/place/initial_placement.cpp

@@ -147,6 +147,23 @@ static bool is_loc_legal(const t_pl_loc& loc,
                          const PartitionRegion& pr,
                          t_logical_block_type_ptr block_type);
 
+/**
+ * @brief  Helper function to choose a subtile in specified location if compatible and available one exits.
+ *  
+ *   @param centroid The centroid location at which the subtile will be selected using its x,y, and layer.
+ *   @param block_type Logical block type of the macro head member.  
+ *   @param block_loc_registry Placement block location information. To be filled with the location
+ *   where pl_macro is placed.
+ *   @param pr The PartitionRegion of the macro head member - represents its floorplanning constraints, is the size of
+ *   the whole chip if the macro is not constrained.
+ *   @param rng A random number generator to select subtile from available and compatible ones.
+ */
+static void find_subtile_in_location(t_pl_loc& centroid, 
+                             t_logical_block_type_ptr block_type,
+                             const BlkLocRegistry& blk_loc_registry,
+                             const PartitionRegion& pr,
+                             vtr::RngContainer& rng);
+
 /**
  * @brief Calculates a centroid location for a block based on its placed connections.
  *
@@ -342,6 +359,37 @@ static bool is_loc_legal(const t_pl_loc& loc,
     return legal;
 }
 
+void find_subtile_in_location(t_pl_loc& centroid, 
+                             t_logical_block_type_ptr block_type,
+                             const BlkLocRegistry& blk_loc_registry,
+                             const PartitionRegion& pr,
+                             vtr::RngContainer& rng) {
+    //check if the location is on chip and legal, if yes try to update subtile
+    if (is_loc_on_chip({centroid.x, centroid.y, centroid.layer}) &&  is_loc_legal(centroid, pr, block_type)) {
+        //finding the subtile location
+        auto& device_ctx = g_vpr_ctx.device();
+        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.x, centroid.y, centroid.layer});
+        const auto& compatible_sub_tiles = compressed_block_grid.compatible_sub_tile_num(type->index);
+        
+        //filter out occupied subtiles
+        const GridBlock& grid_blocks = blk_loc_registry.grid_blocks();
+        std::vector<int> available_sub_tiles;
+        for (int sub_tile : compatible_sub_tiles) {
+            t_pl_loc pos = {centroid.x, centroid.y, sub_tile, centroid.layer};
+            if (!grid_blocks.block_at_location(pos)) {
+                available_sub_tiles.push_back(sub_tile);
+            }
+        }
+
+        //if there is at least one available subtile, update the centroid and do not change otherwise
+        if (!available_sub_tiles.empty()) {
+            centroid.sub_tile = available_sub_tiles[rng.irand((int)available_sub_tiles.size() - 1)];
+        }
+    }
+}
+
+
 static bool find_centroid_neighbor(t_pl_loc& centroid_loc,
                                    t_logical_block_type_ptr block_type,
                                    bool search_for_empty,
@@ -491,30 +539,8 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
         } else {
             centroid.layer = head_layer_num;
         }
-        if (is_loc_on_chip({centroid.x, centroid.y, centroid.layer}) &&  is_loc_legal(centroid, pr, block_type)) {
-            //finding the subtile location
-            auto& device_ctx = g_vpr_ctx.device();
-            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.x, centroid.y, centroid.layer});
-            const auto& compatible_sub_tiles = compressed_block_grid.compatible_sub_tile_num(type->index);
-            //centroid.sub_tile = compatible_sub_tiles[rng.irand((int)compatible_sub_tiles.size() - 1)]; // for testing previous functionality.
-            //filter out occupied subtiles to prevent falling to try_place_macro_randomly while we have available subtiles already.
-            const GridBlock& grid_blocks = blk_loc_registry.grid_blocks();
-            std::vector<int> available_sub_tiles;
-            for (int sub_tile : compatible_sub_tiles) {
-                t_pl_loc pos = {centroid.x, centroid.y, sub_tile, centroid.layer};
-                if (!grid_blocks.block_at_location(pos)) {
-                    available_sub_tiles.push_back(sub_tile);
-                }
-            }
-
-            //if no available subtile is found, we don't need to try_place_macro.
-            if (available_sub_tiles.empty()) {
-                centroid.sub_tile = -1; //set to default
-            } else {
-                centroid.sub_tile = available_sub_tiles[rng.irand((int)available_sub_tiles.size() - 1)];
-            }
-        }
+        //try to find an available and compatible subtile in that location
+        find_subtile_in_location(centroid, block_type, blk_loc_registry, pr, rng);
     }
 
     return connected_blocks_to_update;
@@ -620,32 +646,6 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro,
     }
 
     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 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});
-    //     const auto& compatible_sub_tiles = compressed_block_grid.compatible_sub_tile_num(type->index);
-        
-    //     // //filter out occupied subtiles to prevent falling to try_place_macro_randomly while we have available subtiles already.
-    //     // const GridBlock& grid_blocks = blk_loc_registry.grid_blocks();
-    //     // std::vector<int> available_sub_tiles;
-    //     // for (int sub_tile : compatible_sub_tiles) {
-    //     //     t_pl_loc pos = {centroid_loc.x, centroid_loc.y, sub_tile, centroid_loc.layer};
-    //     //     if (!grid_blocks.block_at_location(pos)) {
-    //     //         available_sub_tiles.push_back(sub_tile);
-    //     //     }
-    //     // }
-
-    //     // //if no available subtile is found, we don't need to try_place_macro.
-    //     // if (available_sub_tiles.empty()) {
-    //     //     return false;
-    //     // }
-
-    //     // centroid_loc.sub_tile = available_sub_tiles[rng.irand((int)available_sub_tiles.size() - 1)];
-    //     centroid_loc.sub_tile = compatible_sub_tiles[rng.irand((int)compatible_sub_tiles.size() - 1)]; // for testing previous functionality.
-    // }
     int width_offset = device_ctx.grid.get_width_offset({centroid_loc.x, centroid_loc.y, centroid_loc.layer});
     int height_offset = device_ctx.grid.get_height_offset({centroid_loc.x, centroid_loc.y, centroid_loc.layer});
     VTR_ASSERT(width_offset == 0);