Merge pull request #3224 from AlexandreSinger/feature-appack-placer-fallback

[APPack] Initial Placement Fallback

Author: amin1377

vpr/src/place/initial_placement.cpp

@@ -571,12 +571,42 @@ static std::vector<ClusterBlockId> find_centroid_loc(const t_pl_macro& pl_macro,
     return connected_blocks_to_update;
 }
 
+/**
+ * @brief Helper method for getting the flat position of an atom relative to a
+ *        given offset.
+ *
+ * This method is useful for chained blocks where an atom may be a member of a
+ * chain with the given offset. This gives the atom's position relative to the
+ * head macro's tile location.
+ */
+static t_flat_pl_loc get_atom_relative_flat_loc(AtomBlockId atom_blk_id,
+                                                const t_pl_offset& offset,
+                                                const FlatPlacementInfo& flat_placement_info,
+                                                const DeviceGrid& device_grid) {
+    // Get the flat location of the atom and the offset.
+    t_flat_pl_loc atom_pos = flat_placement_info.get_pos(atom_blk_id);
+    t_flat_pl_loc flat_offset = t_flat_pl_loc((float)offset.x,
+                                              (float)offset.y,
+                                              (float)offset.layer);
+    // Get the position of the head macro of the chain that this atom is a part of.
+    atom_pos -= flat_offset;
+
+    // This may put the atom off device (due to the flat placement not being fully
+    // legal), so we clamp this to be within the device.
+    atom_pos.x = std::clamp(atom_pos.x, 0.0f, (float)device_grid.width() - 0.001f);
+    atom_pos.y = std::clamp(atom_pos.y, 0.0f, (float)device_grid.height() - 0.001f);
+    atom_pos.layer = std::clamp(atom_pos.layer, 0.0f, (float)device_grid.get_num_layers() - 0.001f);
+
+    return atom_pos;
+}
+
 // TODO: Should this return the unplaced_blocks_to_update_their_score?
 static t_flat_pl_loc find_centroid_loc_from_flat_placement(const t_pl_macro& pl_macro,
                                                            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;
+    const DeviceGrid& device_grid = g_vpr_ctx.device().grid;
+    unsigned acc_weight = 0;
     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];
@@ -585,19 +615,19 @@ static t_flat_pl_loc find_centroid_loc_from_flat_placement(const t_pl_macro& pl_
             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);
 
             // 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.
-            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;
+            // member of the macro. The position should be relative to the head
+            // macro's position such that the centroid is where all blocks think
+            // the head macro should be.
+            t_flat_pl_loc atom_pos = get_atom_relative_flat_loc(atom_blk_id,
+                                                                member.offset,
+                                                                flat_placement_info,
+                                                                device_grid);
+            centroid += atom_pos;
             acc_weight++;
         }
     }
-    if (acc_weight > 0.f) {
-        centroid /= acc_weight;
+    if (acc_weight > 0) {
+        centroid /= static_cast<float>(acc_weight);
     }
 
     // If the root cluster is constrained, project the centroid onto its
@@ -1532,26 +1562,28 @@ bool place_one_block(const ClusterBlockId blk_id,
 static inline float get_flat_variance(const t_pl_macro& macro,
                                       const FlatPlacementInfo& flat_placement_info) {
 
+    const DeviceGrid& device_grid = g_vpr_ctx.device().grid;
+
     // Find the flat centroid location of this macro. Then find the grid location
     // that this would be.
     t_flat_pl_loc centroid_flat_loc = find_centroid_loc_from_flat_placement(macro, flat_placement_info);
     t_physical_tile_loc centroid_grid_loc(centroid_flat_loc.x,
                                           centroid_flat_loc.y,
                                           centroid_flat_loc.layer);
+    VTR_ASSERT(is_loc_on_chip(centroid_grid_loc));
 
     // Compute the variance.
-    float num_atoms = 0;
+    unsigned num_atoms = 0;
     float variance = 0.0f;
     for (const t_pl_macro_member& member : macro.members) {
         const auto& cluster_atoms = g_vpr_ctx.clustering().atoms_lookup[member.blk_index];
         for (AtomBlockId atom_blk_id : cluster_atoms) {
             // Get the atom position, offset by the member offset. This translates
             // all atoms to be as if they are in the head position of the macro.
-            t_flat_pl_loc atom_pos = flat_placement_info.get_pos(atom_blk_id);
-            t_flat_pl_loc cluster_offset({(float)member.offset.x,
-                                          (float)member.offset.y,
-                                          (float)member.offset.layer});
-            atom_pos -= cluster_offset;
+            t_flat_pl_loc atom_pos = get_atom_relative_flat_loc(atom_blk_id,
+                                                                member.offset,
+                                                                flat_placement_info,
+                                                                device_grid);
 
             // Get the amount this atom needs to be displaced in order to be
             // within the same tile as the centroid.
@@ -1564,8 +1596,8 @@ static inline float get_flat_variance(const t_pl_macro& macro,
             num_atoms++;
         }
     }
-    if (num_atoms > 0.f) {
-        variance /= num_atoms;
+    if (num_atoms > 0) {
+        variance /= static_cast<float>(num_atoms);
     }
     return variance;
 }
@@ -1676,8 +1708,9 @@ static inline std::vector<ClusterBlockId> get_sorted_clusters_to_place(
         // first.
         // TODO: The cluster constrained area can be incorperated into the cost
         //       somehow.
-        if (is_cluster_constrained(blk_id)) {
-            const PartitionRegion& pr = cluster_constraints[blk_id];
+        ClusterBlockId macro_head_blk = pl_macro.members[0].blk_index;
+        if (is_cluster_constrained(macro_head_blk)) {
+            const PartitionRegion& pr = cluster_constraints[macro_head_blk];
             float area = 0.0f;
             for (const Region& region : pr.get_regions()) {
                 const vtr::Rect<int> region_rect = region.get_rect();
@@ -1705,6 +1738,7 @@ static inline std::vector<ClusterBlockId> get_sorted_clusters_to_place(
 /**
  * @brief Tries to place all of the given clusters as closed to their flat
  *        placement as possible (minimum displacement from flat placement).
+ *        Returns false if any clusters could not be placed.
  *
  * This function will place clusters in passes. In the first pass, it will try
  * to place clusters exactly where their global placement is (according to the
@@ -1713,7 +1747,7 @@ static inline std::vector<ClusterBlockId> get_sorted_clusters_to_place(
  * Subsequent passes will then try to place clusters at exponentially farther
  * distances.
  */
-static inline void place_blocks_min_displacement(std::vector<ClusterBlockId>& clusters_to_place,
+static inline bool place_blocks_min_displacement(std::vector<ClusterBlockId>& clusters_to_place,
                                                  enum e_pad_loc_type pad_loc_type,
                                                  BlkLocRegistry& blk_loc_registry,
                                                  const PlaceMacros& place_macros,
@@ -1841,28 +1875,30 @@ static inline void place_blocks_min_displacement(std::vector<ClusterBlockId>& cl
     if (clusters_to_place.size() > 0) {
         VTR_LOG("Unable to place all clusters.\n");
         VTR_LOG("Clusters left unplaced:\n");
+        // TODO: Increase the log verbosity of this.
         for (ClusterBlockId blk_id : clusters_to_place) {
             VTR_LOG("\t%s\n", cluster_netlist.block_name(blk_id).c_str());
         }
     }
 
-    // Check if anything has not been placed, if so just crash for now.
-    // TODO: Should fall back on the original initial placer. Unless there is a
-    //       bug in the code above, it could be that it is challenging to place
-    //       for this circuit.
-    VTR_ASSERT(clusters_to_place.size() == 0);
+    // Check if anything has not been placed, if so, signal to the calling function.
+    if (clusters_to_place.size() > 0)
+        return false;
+
+    return true;
 }
 
 /**
  * @brief Places all blocks in the clustered netlist as close to the global
- *        placement produced by the AP flow.
+ *        placement produced by the AP flow. Returns false if any blocks could
+ *        not be placed.
  *
  * This function places the blocks in stages. The goal of this stage-based
  * approach is to place clusters which are challenging to place first. Within
  * each stage, the clusters are ordered based on heuristics such that the most
  * impactful clusters get first dibs on placement.
  */
-static inline void place_all_blocks_ap(enum e_pad_loc_type pad_loc_type,
+static inline bool place_all_blocks_ap(enum e_pad_loc_type pad_loc_type,
                                        BlkLocRegistry& blk_loc_registry,
                                        const PlaceMacros& place_macros,
                                        const FlatPlacementInfo& flat_placement_info) {
@@ -1892,13 +1928,17 @@ static inline void place_all_blocks_ap(enum e_pad_loc_type pad_loc_type,
 
     if (constrained_clusters.size() > 0) {
         VTR_LOG("Placing constrained clusters...\n");
-        place_blocks_min_displacement(constrained_clusters,
+        bool all_clusters_placed = place_blocks_min_displacement(constrained_clusters,
                                       pad_loc_type,
                                       blk_loc_registry,
                                       place_macros,
                                       cluster_netlist,
                                       flat_placement_info);
         VTR_LOG("\n");
+        if (!all_clusters_placed) {
+            VTR_LOG("Could not place all constrained clusters, falling back on the non-AP initial placement.\n");
+            return false;
+        }
     }
 
     // 2. Get all of the large macros and place them next. Large macros have a
@@ -1924,13 +1964,17 @@ static inline void place_all_blocks_ap(enum e_pad_loc_type pad_loc_type,
 
     if (large_macro_clusters.size() > 0) {
         VTR_LOG("Placing clusters that are part of larger macros...\n");
-        place_blocks_min_displacement(large_macro_clusters,
+        bool all_clusters_placed = place_blocks_min_displacement(large_macro_clusters,
                                       pad_loc_type,
                                       blk_loc_registry,
                                       place_macros,
                                       cluster_netlist,
                                       flat_placement_info);
         VTR_LOG("\n");
+        if (!all_clusters_placed) {
+            VTR_LOG("Could not place all large macros, falling back on the non-AP initial placement.\n");
+            return false;
+        }
     }
 
     // 3. Place the rest of the clusters. These clusters will be unconstrained
@@ -1948,14 +1992,20 @@ static inline void place_all_blocks_ap(enum e_pad_loc_type pad_loc_type,
 
     if (clusters_to_place.size() > 0) {
         VTR_LOG("Placing general clusters...\n");
-        place_blocks_min_displacement(clusters_to_place,
+        bool all_clusters_placed = place_blocks_min_displacement(clusters_to_place,
                                       pad_loc_type,
                                       blk_loc_registry,
                                       place_macros,
                                       cluster_netlist,
                                       flat_placement_info);
         VTR_LOG("\n");
+        if (!all_clusters_placed) {
+            VTR_LOG("Could not place all clusters, falling back on the non-AP initial placement.\n");
+            return false;
+        }
     }
+
+    return true;
 }
 
 void initial_placement(const t_placer_opts& placer_opts,
@@ -1991,13 +2041,29 @@ void initial_placement(const t_placer_opts& placer_opts,
         }
 
         //Place all blocks
+        bool all_blocks_placed = false;
+
+        // First try to place all of the blocks using AP
         if (flat_placement_info.valid) {
-            place_all_blocks_ap(placer_opts.pad_loc_type,
-                                blk_loc_registry,
-                                place_macros,
-                                flat_placement_info);
-        } else {
-            //Assign scores to blocks and placement macros according to how difficult they are to place
+            all_blocks_placed = place_all_blocks_ap(placer_opts.pad_loc_type,
+                                                    blk_loc_registry,
+                                                    place_macros,
+                                                    flat_placement_info);
+
+            // If AP failed to place all of the blocks, reset the placement solution
+            // so we can fall back on the original initial placement algorithm.
+            if (!all_blocks_placed) {
+                blk_loc_registry.clear_all_grid_locs();
+                if (strlen(constraints_file) != 0) {
+                    read_constraints(constraints_file, blk_loc_registry);
+                }
+            }
+        }
+
+        // If all of the blocks have not been placed (i.e. AP is turned off or
+        // is disabled), try to place all of the clusters using heuristics.
+        if (!all_blocks_placed) {
+            // Assign scores to blocks and placement macros according to how difficult they are to place
             vtr::vector<ClusterBlockId, t_block_score> block_scores = assign_block_scores(place_macros);
 
             place_all_blocks(placer_opts, block_scores, placer_opts.pad_loc_type,

vtr_flow/parse/qor_config/qor_ap_fixed_chan_width.txt

@@ -31,3 +31,4 @@ total_runtime;vpr.out;The entire flow of VPR took (.*) seconds
 num_clb;vpr.out;Netlist clb blocks:\s*(\d+)
 num_lab;vpr.out;Netlist LAB blocks:\s*(\d+)
 
+num_pre_packed_blocks;vpr.out;\s+total blocks:\s*(\d+),.*