[AP][InitialPlacement] Improved Initial Placement

Found that the Initial Placer stage of the AP flow (after APPack, but
before Detailed Placement) was not working as expected. The intention
was that clusters would be placed at their centroid location accordin to
the flat placement, and if that site was illegal or taken it would take
a nearby point instead (falling back on the original initial placer if
nothing can be found).

To achieve this, I was using a method called find_centroid_neighbor
which I thought would return the nearest legal location to the given
location. This was not correct. This method just creates a bounding-box
and tries to find a random point in that box around the given point.
This was causing our AP flow to move clusters WAY farther than they
wanted, which moved them into places other clusters wanted to go. This
was also not exhaustive, so it was often falling back on the original
approach which was putting clusters in practically random locations. All
of this was causing the post-FL placement from the AP flow to actually
have worse quality than the default AP flow!

To resolve this, I wrote the actual method I was intending. It performs
a BFS-style search from the src location to all legal locations and
returns the closest one. By doing this BFS on the compressed grid, I
found that this is actually quite efficient. With these changes, I found
that the quality of the post-FL placement more than doubled and the
average atom displacement from the GP solution decrease dramatically.

Author: AlexandreSinger

vpr/src/base/flat_placement_types.h

@@ -35,6 +35,16 @@ struct t_flat_pl_loc {
         return *this;
     }
 
+    /**
+     * @brief Subtracts the coordinates of another t_flat_pl_loc to this one.
+     */
+    t_flat_pl_loc& operator-=(const t_flat_pl_loc& other) {
+        x -= other.x;
+        y -= other.y;
+        layer -= other.layer;
+        return *this;
+    }
+
     /**
      * @brief Divides the coordinates of this t_flat_pl_loc by a divisor.
      *

vpr/src/place/initial_placement.cpp

@@ -2,6 +2,7 @@
 #include "atom_netlist_fwd.h"
 #include "physical_types_util.h"
 #include "place_macro.h"
+#include "vtr_ndmatrix.h"
 #include "vtr_random.h"
 #include "vtr_time.h"
 #include "vpr_types.h"
@@ -19,7 +20,9 @@
 
 #include <cmath>
 #include <iterator>
+#include <limits>
 #include <optional>
+#include <queue>
 
 #ifdef VERBOSE
 void print_clb_placement(const char* fname);
@@ -38,11 +41,6 @@ static constexpr int SORT_WEIGHT_PER_TILES_OUTSIDE_OF_PR = 100;
 // The neighbor location should be within the defined range to the calculated centroid location.
 static constexpr int CENTROID_NEIGHBOR_SEARCH_RLIM = 15;
 
-// The range limit to be used when searcing for a neighbor in the centroid placement when AP is used.
-// Since AP is assumed to have a better idea of where clusters should be placed, we want to search more
-// places to place a cluster near its solved position before giving up.
-static constexpr int CENTROID_NEIGHBOR_SEARCH_RLIM_AP = 60;
-
 /**
  * @brief Control routine for placing a macro.
  * First iteration of place_marco performs the following steps to place a macro:
@@ -549,47 +547,200 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
 }
 
 // TODO: Should this return the unplaced_blocks_to_update_their_score?
-static void find_centroid_loc_from_flat_placement(const t_pl_macro& pl_macro,
-                                                  t_pl_loc& centroid,
-                                                  const FlatPlacementInfo& flat_placement_info) {
+static t_flat_pl_loc find_centroid_loc_from_flat_placement(const t_pl_macro& pl_macro,
+                                                           int& sub_tile,
+                                                           const FlatPlacementInfo& flat_placement_info) {
     // Use the flat placement to compute the centroid of the given macro.
     // TODO: Instead of averaging, maybe use MODE (most frequently placed location).
     float acc_weight = 0.f;
-    float acc_x = 0.f;
-    float acc_y = 0.f;
-    float acc_layer = 0.f;
     float acc_sub_tile = 0.f;
+    t_flat_pl_loc centroid({0.0f, 0.0f, 0.0f});
     for (const t_pl_macro_member& member : pl_macro.members) {
         const auto& cluster_atoms = g_vpr_ctx.clustering().atoms_lookup[member.blk_index];
         for (AtomBlockId atom_blk_id : cluster_atoms) {
             // TODO: We can get away with using less information.
             VTR_ASSERT(flat_placement_info.blk_x_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS && flat_placement_info.blk_y_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS && flat_placement_info.blk_layer[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS && flat_placement_info.blk_sub_tile[atom_blk_id] != FlatPlacementInfo::UNDEFINED_SUB_TILE);
-            // TODO: Make this a debug print.
-            // VTR_LOG("%s ", g_vpr_ctx.atom().netlist().block_name(atom_blk_id).c_str());
 
             // Accumulate the x, y, layer, and sub_tile for each atom in each
             // member of the macro. Remove the offset so the centroid would be
             // where the head macro should be placed to put the members in the
             // correct place.
-            acc_x += flat_placement_info.blk_x_pos[atom_blk_id] - member.offset.x;
-            acc_y += flat_placement_info.blk_y_pos[atom_blk_id] - member.offset.y;
-            acc_layer += flat_placement_info.blk_layer[atom_blk_id] - member.offset.layer;
+            t_flat_pl_loc cluster_offset({(float)member.offset.x,
+                                          (float)member.offset.y,
+                                          (float)member.offset.layer});
+            centroid += flat_placement_info.get_pos(atom_blk_id);
+            centroid -= cluster_offset;
+
             acc_sub_tile += flat_placement_info.blk_sub_tile[atom_blk_id] - member.offset.sub_tile;
             acc_weight++;
         }
     }
     if (acc_weight > 0.f) {
-        // NOTE: We add an offset of 0.5 to prevent us from moving to the tile
-        //       below / to the left due to tiny numerical changes (this
-        //       pretends that each atom is in the center of the tile).
-        centroid.x = std::floor(acc_x / acc_weight);
-        centroid.y = std::floor(acc_y / acc_weight);
-        centroid.layer = std::floor(acc_layer / acc_weight);
-        centroid.sub_tile = std::floor(acc_sub_tile / acc_weight);
-
-        // TODO: Make this a debug print.
-        // VTR_LOG("\n\t(%d, %d, %d, %d)\n", centroid.x, centroid.y, centroid.layer, centroid.sub_tile);
+        centroid /= acc_weight;
+        sub_tile = std::floor(acc_sub_tile / acc_weight);
     }
+    return centroid;
+}
+
+/**
+ * @brief Find the nearest compatible location for the given macro as close to
+ *        the src_flat_loc as possible.
+ *
+ * This method uses a BFS to find the closest legal location for the macro.
+ *
+ *  @param src_flat_loc
+ *          The start location of the BFS. This is given as a flat placement to
+ *          allow the search to trade-off different location options. For example,
+ *          if src_loc was (1.6, 1.5), this tells the search that the cluster
+ *          would prefer to be at tile (1, 1), but if it cannot go there and
+ *          it had to go to one of the neighbors, it would prefer to be on the
+ *          right.
+ *  @param src_loc_sub_tile
+ *          The expected sub_tile of the src location. Flat locations do not
+ *          have subtile information, so this gets passed in as well.
+ *  @param block_type
+ *          The logical block type of the macro.
+ *  @param macro
+ *          The macro to place in the location.
+ *  @param blk_loc_registry
+ *
+ *  @return Returns the closest legal location found. All of the dimensions will
+ *          be OPEN if a locations could not be found.
+ */
+static inline t_pl_loc find_nearest_compatible_loc(t_flat_pl_loc& src_flat_loc,
+                                                   int src_loc_sub_tile,
+                                                   t_logical_block_type_ptr block_type,
+                                                   const t_pl_macro& pl_macro,
+                                                   const BlkLocRegistry& blk_loc_registry) {
+    // This method performs a BFS over the compressed grid. This avoids searching
+    // locations which obviously cannot implement this macro.
+    const auto& compressed_block_grid = g_vpr_ctx.placement().compressed_block_grids[block_type->index];
+    const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
+    // This method does not support 3D FPGAs yet. The search performed will only
+    // traverse the same layer as the src_loc.
+    VTR_ASSERT(num_layers == 1);
+
+    // Get the closest (approximately) compressed location to the src location.
+    // This does not need to be perfect (in fact I do not think it is), but the
+    // closer it is, the faster the BFS will find the best solution.
+    t_pl_loc src_loc(src_flat_loc.x, src_flat_loc.y, src_loc_sub_tile, src_flat_loc.layer);
+    auto compressed_src_locs = get_compressed_loc_approx(compressed_block_grid,
+                                                         src_loc,
+                                                         num_layers);
+    const t_physical_tile_loc compressed_src_loc = compressed_block_grid.grid_loc_to_compressed_loc_approx({src_loc.x, src_loc.y, src_loc.layer});
+
+    // Weighted-BFS search the compressed grid for an empty compatible subtile.
+    size_t num_rows = compressed_block_grid.get_num_rows(0);
+    size_t num_cols = compressed_block_grid.get_num_columns(0);
+    vtr::NdMatrix<bool, 2> visited({num_cols, num_rows}, false);
+    float best_dist = std::numeric_limits<float>::max();
+    t_pl_loc best_loc(OPEN, OPEN, OPEN, OPEN);
+
+    std::queue<t_physical_tile_loc> loc_queue;
+    loc_queue.push(compressed_src_loc);
+    while (!loc_queue.empty()) {
+        // Pop the top element off the queue.
+        t_physical_tile_loc loc = loc_queue.front();
+        loc_queue.pop();
+
+        // If this location has already been visited, skip it.
+        if (visited[loc.x][loc.y])
+            continue;
+        visited[loc.x][loc.y] = true;
+
+        // Get the distance from this loc to the src_loc in grid space
+        // Note: In compressed space, distances are not what they appear. We are
+        //       using the true grid positions to get the truly closest loc.
+        //       Here, we use the flat centroid of the macro and measure its
+        //       distance from the center of this grid loc (hence the 0.5 offset).
+        auto grid_loc = compressed_block_grid.compressed_loc_to_grid_loc(loc);
+        float grid_dx = std::abs((float)grid_loc.x + 0.5f - src_flat_loc.x);
+        float grid_dy = std::abs((float)grid_loc.y + 0.5f - src_flat_loc.y);
+        float grid_dist = grid_dx + grid_dy;
+        // If this distance is worst than the best we have seen or is outside
+        // of the search distance, do not explore it or its neighbors.
+        // NOTE: This prune is always safe (i.e. it will never remove a better
+        //       solution) since this is a spatial graph and our objective is
+        //       positional distance. The un-visitied neighbors of a node should
+        //       have a higher distance than the current node.
+        if (grid_dist >= best_dist)
+            continue;
+
+        // In order to ensure our BFS finds the closest compatible location, we
+        // traverse compressed grid locations which may not actually be valid
+        // (i.e. no tile exists there). This is fine, we just need to check for
+        // them to ensure we never try to put a cluster there.
+        bool is_valid_compressed_loc = false;
+        const auto& compressed_col_blk_map = compressed_block_grid.get_column_block_map(loc.x, 0);
+        if (compressed_col_blk_map.count(loc.y) != 0)
+            is_valid_compressed_loc = true;
+
+        // If this distance is better than the best we have seen so far, try
+        // to see if this is a better solution.
+        if (is_valid_compressed_loc) {
+            // Check if a sub-tile is available at this location.
+            const t_physical_tile_type_ptr phy_type = g_vpr_ctx.device().grid.get_physical_type(grid_loc);
+            const auto& compatible_sub_tiles = compressed_block_grid.compatible_sub_tile_num(phy_type->index);
+            int new_sub_tile = -1;
+            for (int sub_tile : compatible_sub_tiles) {
+                if (blk_loc_registry.grid_blocks().is_sub_tile_empty(grid_loc, sub_tile)) {
+                    new_sub_tile = sub_tile;
+                    break;
+                }
+            }
+            if (new_sub_tile != -1) {
+                // If a sub-tile is available, set this to be the first sub-tile
+                // available and check if this site is legal for this macro.
+                // TODO: Should we pick a random sub-tile instead?
+                // Note: We are usin the fully legality check here to check for
+                //       floorplanning constraints and compatibility for all
+                //       members of the macro. This prevents some macros being
+                //       placed where they obviously cannot be implemented.
+                t_pl_loc new_loc = t_pl_loc(grid_loc.x, grid_loc.y, new_sub_tile, grid_loc.layer_num);
+                bool site_legal_for_macro = macro_can_be_placed(pl_macro,
+                                                                new_loc,
+                                                                true /*check_all_legality*/,
+                                                                blk_loc_registry);
+                if (site_legal_for_macro) {
+                    // Update the best solition.
+                    // Note: We need to keep searching since the compressed grid
+                    //       may present a location which is closer in compressed
+                    //       space earlier than a location which is closer in
+                    //       grid space.
+                    best_dist = grid_dist;
+                    best_loc = new_loc;
+                }
+            }
+        }
+
+        // Push the neighbors (in the compressed grid) onto the queue.
+        if (loc.x > 0) {
+            t_physical_tile_loc new_loc = t_physical_tile_loc(loc.x - 1,
+                                                              loc.y,
+                                                              loc.layer_num);
+            loc_queue.push(new_loc);
+        }
+        if (loc.x < (int)num_cols - 1) {
+            t_physical_tile_loc new_loc = t_physical_tile_loc(loc.x + 1,
+                                                              loc.y,
+                                                              loc.layer_num);
+            loc_queue.push(new_loc);
+        }
+        if (loc.y > 0) {
+            t_physical_tile_loc new_loc = t_physical_tile_loc(loc.x,
+                                                              loc.y - 1,
+                                                              loc.layer_num);
+            loc_queue.push(new_loc);
+        }
+        if (loc.y < (int)num_rows - 1) {
+            t_physical_tile_loc new_loc = t_physical_tile_loc(loc.x,
+                                                              loc.y + 1,
+                                                              loc.layer_num);
+            loc_queue.push(new_loc);
+        }
+    }
+
+    return best_loc;
 }
 
 static bool try_centroid_placement(const t_pl_macro& pl_macro,
@@ -614,46 +765,26 @@ static bool try_centroid_placement(const t_pl_macro& pl_macro,
         unplaced_blocks_to_update_their_score = find_centroid_loc(pl_macro, centroid_loc, blk_loc_registry);
         found_legal_subtile = find_subtile_in_location(centroid_loc, block_type, blk_loc_registry, pr, rng);
     } else {
-        // Note: AP uses a different rlim than non-AP
-        rlim = CENTROID_NEIGHBOR_SEARCH_RLIM_AP;
         // If a flat placement is provided, use the flat placement to get the
-        // centroid.
-        find_centroid_loc_from_flat_placement(pl_macro, centroid_loc, flat_placement_info);
-        if (!is_loc_on_chip({centroid_loc.x, centroid_loc.y, centroid_loc.layer}) || !is_loc_legal(centroid_loc, pr, block_type)) {
-            // If the centroid is not legal, check for a neighboring block we
-            // can use instead.
-            bool neighbor_legal_loc = find_centroid_neighbor(centroid_loc,
-                                                             block_type,
-                                                             false,
-                                                             rlim,
-                                                             blk_loc_registry,
-                                                             rng);
-            if (!neighbor_legal_loc) {
-                // If we cannot find a neighboring block, fall back on the
-                // original find_centroid_loc function.
-                // FIXME: We should really just skip this block and come back
-                //        to it later. We do not want it taking space from
-                //        someone else!
-                unplaced_blocks_to_update_their_score = find_centroid_loc(pl_macro, centroid_loc, blk_loc_registry);
-                found_legal_subtile = find_subtile_in_location(centroid_loc, block_type, blk_loc_registry, pr, rng);
-            } else {
-                found_legal_subtile = true;
-            }
+        // centroid location of the macro.
+        int centroid_sub_tile = OPEN;
+        t_flat_pl_loc centroid_flat_loc = find_centroid_loc_from_flat_placement(pl_macro, centroid_sub_tile, flat_placement_info);
+        // Then find the nearest legal location to this centroid for this macro.
+        centroid_loc = find_nearest_compatible_loc(centroid_flat_loc,
+                                                   centroid_sub_tile,
+                                                   block_type,
+                                                   pl_macro,
+                                                   blk_loc_registry);
+        if (centroid_loc.x == OPEN) {
+            // If we cannot find a nearest block, fall back on the original
+            // find_centroid_loc function.
+            // FIXME: We should really just skip this block and come back
+            //        to it later. We do not want it taking space from
+            //        someone else!
+            unplaced_blocks_to_update_their_score = find_centroid_loc(pl_macro, centroid_loc, blk_loc_registry);
+            found_legal_subtile = find_subtile_in_location(centroid_loc, block_type, blk_loc_registry, pr, rng);
         } else {
-            // If this is a legal location for this block, check if any other
-            // blocks are at this subtile location.
-            const GridBlock& grid_blocks = blk_loc_registry.grid_blocks();
-            if (grid_blocks.block_at_location(centroid_loc)) {
-                // If there is a block at this subtile, try to find another
-                // subtile at this location to be placed in.
-                found_legal_subtile = find_subtile_in_location(centroid_loc,
-                                                               block_type,
-                                                               blk_loc_registry,
-                                                               pr,
-                                                               rng);
-            } else {
-                found_legal_subtile = true;
-            }
+            found_legal_subtile = true;
         }
     }