FlatRecon: Flat Placement Reconstruction Full Legalizer

doc/src/vpr/command_line_usage.rst

@@ -1286,6 +1286,12 @@ Analytical Placement is generally split into three stages:
 
     * ``appack`` Use APPack, which takes the Packer in VPR and uses the flat atom placement to create better clusters.
 
+    * ``flat-recon`` Use the Flat Placement Reconstruction Full Legalizer which tries to reconstruct a clustered placement
+      that is as close to the incoming flat placement as possible. It can be used to read flat placement from an '.fplace' file
+      or with Global Placement output. In both cases, it expects the given solution to be close to legal. If used with
+      an '.fplace' file, each atom of a molecule should share same location information. If none of the atoms in a molecule
+      have a specified location in the file, the molecule will be assigned to the center of the device.
+
     **Default:** ``appack``
 
 .. option:: --ap_detailed_placer {none | annealer}

libs/libarchfpga/src/physical_types.h

@@ -881,6 +881,17 @@ struct t_physical_tile_loc {
     operator bool() const {
         return !(x == OPEN || y == OPEN || layer_num == OPEN);
     }
+
+    /**
+     * @brief Comparison operator for t_physical_tile_loc
+     *
+     * Tiles are ordered first by layer number, then by x, and finally by y.
+     */
+    friend bool operator<(const t_physical_tile_loc& lhs, const t_physical_tile_loc& rhs) {
+        if (lhs.layer_num != rhs.layer_num) return lhs.layer_num < rhs.layer_num;
+        if (lhs.x != rhs.x) return lhs.x < rhs.x;
+        return lhs.y < rhs.y;
+    }
 };
 
 /** Describes I/O and clock ports of a physical tile type

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -18,6 +18,7 @@
 #include "gen_ap_netlist_from_atoms.h"
 #include "global_placer.h"
 #include "globals.h"
+#include "load_flat_place.h"
 #include "netlist_fwd.h"
 #include "partial_legalizer.h"
 #include "partial_placement.h"
@@ -105,20 +106,38 @@ static void convert_flat_to_partial_placement(const FlatPlacementInfo& flat_plac
                                     current_loc_x, current_loc_y, current_loc_layer, current_loc_sub_tile,
                                     atom_loc_x, atom_loc_y, atom_loc_layer, atom_loc_sub_tile);
             } else {
-                atom_loc_x = current_loc_x;
-                atom_loc_y = current_loc_y;
-                atom_loc_layer = current_loc_layer;
-                atom_loc_sub_tile = current_loc_sub_tile;
-                found_valid_atom = true;
+                if (current_loc_x != -1 && current_loc_y != -1 && current_loc_layer != -1 && current_loc_sub_tile != -1) {
+                    atom_loc_x = current_loc_x;
+                    atom_loc_y = current_loc_y;
+                    atom_loc_layer = current_loc_layer;
+                    atom_loc_sub_tile = current_loc_sub_tile;
+                    found_valid_atom = true;
+                }
             }
         }
-        // Ensure that there is a valid atom in the molecule to pass its location.
-        VTR_ASSERT_MSG(found_valid_atom, "Each molecule must contain at least one valid atom");
-        // Pass the placement information
-        p_placement.block_x_locs[ap_blk_id] = atom_loc_x;
-        p_placement.block_y_locs[ap_blk_id] = atom_loc_y;
-        p_placement.block_layer_nums[ap_blk_id] = atom_loc_layer;
-        p_placement.block_sub_tiles[ap_blk_id] = atom_loc_sub_tile;
+        // If any atom in the molecule has a location assigned, use that location
+        // for the entire AP block. Otherwise, assign the AP block to the center
+        // of the device grid and update the flat placement info for all its atoms accordingly.
+        if (!found_valid_atom) {
+            VTR_LOG_WARN("No atoms of molecule ID %zu provided in the flat placement. Assigning it to the device center.\n", mol_id);
+            p_placement.block_x_locs[ap_blk_id] = g_vpr_ctx.device().grid.width() / 2.0f;
+            p_placement.block_y_locs[ap_blk_id] = g_vpr_ctx.device().grid.height() / 2.0f;
+            p_placement.block_layer_nums[ap_blk_id] = 0;
+            p_placement.block_sub_tiles[ap_blk_id] = 0;
+            // Update flat placement for atoms of that molecule accordingly
+            for (AtomBlockId atom_blk_id : mol.atom_block_ids) {
+                g_vpr_ctx.mutable_atom().mutable_flat_placement_info().blk_x_pos[atom_blk_id] = g_vpr_ctx.device().grid.width() / 2.0f;
+                g_vpr_ctx.mutable_atom().mutable_flat_placement_info().blk_y_pos[atom_blk_id] = g_vpr_ctx.device().grid.height() / 2.0f;
+                g_vpr_ctx.mutable_atom().mutable_flat_placement_info().blk_layer[atom_blk_id] = 0;
+                g_vpr_ctx.mutable_atom().mutable_flat_placement_info().blk_sub_tile[atom_blk_id] = 0;
+            }
+        } else {
+            // Pass the placement information
+            p_placement.block_x_locs[ap_blk_id] = atom_loc_x;
+            p_placement.block_y_locs[ap_blk_id] = atom_loc_y;
+            p_placement.block_layer_nums[ap_blk_id] = atom_loc_layer;
+            p_placement.block_sub_tiles[ap_blk_id] = atom_loc_sub_tile;
+        }
     }
 }
 
@@ -245,6 +264,15 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
     // Print the device utilization
     print_device_utilization(target_device_utilization);
 
+    // Write out a flat placement file at the end of Full Legalization if the
+    // option is specified.
+    if (!vpr_setup.FileNameOpts.write_flat_place_file.empty()) {
+        write_flat_placement(vpr_setup.FileNameOpts.write_flat_place_file.c_str(),
+                             g_vpr_ctx.clustering().clb_nlist,
+                             g_vpr_ctx.placement().block_locs(),
+                             g_vpr_ctx.clustering().atoms_lookup);
+    }
+
     // Run the Detailed Placer.
     std::unique_ptr<DetailedPlacer> detailed_placer = make_detailed_placer(ap_opts.detailed_placer_type,
                                                                            g_vpr_ctx.placement().blk_loc_registry(),

vpr/src/analytical_place/ap_flow_enums.h

@@ -37,9 +37,9 @@ enum class e_ap_partial_legalizer {
  * enum can select between these different Full Legalizers.
  */
 enum class e_ap_full_legalizer {
-    Naive,                ///< The Naive Full Legalizer, which clusters atoms placed in the same tile and tries to place them in that tile according to the flat placement.
-    APPack,               ///< The APPack Full Legalizer, which uses the flat placement to improve the Packer and Placer.
-    Basic_Min_Disturbance ///< The Basic Min. Disturbance Full Legalizer, which tries to reconstruct a clustered placement that is as close to the incoming flat placement as it can.
+    Naive,    ///< The Naive Full Legalizer, which clusters atoms placed in the same tile and tries to place them in that tile according to the flat placement.
+    APPack,   ///< The APPack Full Legalizer, which uses the flat placement to improve the Packer and Placer.
+    FlatRecon ///< The Flat Placement Reconstruction Full Legalizer, which tries to reconstruct a clustered placement that is as close to the incoming flat placement as it can.
 };
 
 /**