[AP][FullLegalizer] Basic Min. Disturbance FL

Changes based on review.

Author: haydar-c

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -58,21 +58,72 @@ static void print_ap_netlist_stats(const APNetlist& netlist) {
     VTR_LOG("\n");
 }
 
-void convert_flat_to_partial_placement(const FlatPlacementInfo& flat_placement_info, const APNetlist& ap_netlist, PartialPlacement& p_placement){
+/**
+ * @brief Passes the flat placement information to a provided partial placement.
+ *
+ *  @param flat_placement_info    The flat placement information to be read.
+ *  @param ap_netlist             The APNetlist that used to iterate over its blocks.
+ *  @param prepacker              The Prepacker to get molecule of blocks in the ap_netlist.
+ *  @param p_placement            The partial placement to be updated which is assumend
+ * to be generated on ap_netlist or have same blocks.
+ */
+static void convert_flat_to_partial_placement(const FlatPlacementInfo& flat_placement_info, const APNetlist& ap_netlist, const Prepacker& prepacker, PartialPlacement& p_placement){
     for (APBlockId ap_blk_id : ap_netlist.blocks()) {
-        std::string ap_block_name = ap_netlist.block_name(ap_blk_id);
-
-        // Find the AtomBlockId of a given AP block name
-        AtomBlockId atom_blk = g_vpr_ctx.atom().netlist().find_block(ap_block_name);
-        if (!atom_blk.is_valid()) {
-            continue;
+        // Get the molecule that AP block represents
+        PackMoleculeId mol_id = ap_netlist.block_molecule(ap_blk_id);
+        const t_pack_molecule& mol = prepacker.get_molecule(mol_id);
+        // Get location of a valid atom in the molecule and verify that
+        // all atoms of the molecule share same placement information.
+        t_pl_loc atom_loc;
+        bool found_valid_atom = false;
+        for (AtomBlockId atom_blk_id: mol.atom_block_ids) {
+            if (!atom_blk_id.is_valid())
+                continue;
+            const t_pl_loc current_loc(flat_placement_info.blk_x_pos[atom_blk_id],
+                                       flat_placement_info.blk_y_pos[atom_blk_id],
+                                       flat_placement_info.blk_sub_tile[atom_blk_id],
+                                       flat_placement_info.blk_layer[atom_blk_id]);
+            if (found_valid_atom) {
+                VTR_ASSERT_MSG(current_loc == atom_loc, "Verify all atoms of a molecule provided in the flat placement share same location.\n");
+            } else {
+                atom_loc = current_loc;
+                found_valid_atom = true;
+            }
         }
-
+        // Skip if no valid atom found
+        if (!found_valid_atom)
+            continue;
         // Pass the placement information
-        p_placement.block_x_locs[ap_blk_id] = flat_placement_info.blk_x_pos[atom_blk];
-        p_placement.block_y_locs[ap_blk_id] = flat_placement_info.blk_y_pos[atom_blk];
-        p_placement.block_layer_nums[ap_blk_id] = flat_placement_info.blk_layer[atom_blk];
-        p_placement.block_sub_tiles[ap_blk_id] = flat_placement_info.blk_sub_tile[atom_blk];
+        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;
+    }
+}
+
+/**
+ * @brief If a flat placement is provided, skips the Global Placer and
+ * converts it to a partial placement. Otherwise, runs the Global Placer.
+ */
+static PartialPlacement run_global_placer(const AtomNetlist& atom_nlist, const APNetlist& ap_netlist, const Prepacker& prepacker, const DeviceContext& device_ctx) {
+    if (g_vpr_ctx.atom().flat_placement_info().valid) {
+        VTR_LOG("Flat Placement is provided in the AP flow, skipping the Global Placement.\n");
+        PartialPlacement p_placement(ap_netlist);
+        convert_flat_to_partial_placement(g_vpr_ctx.atom().flat_placement_info(),
+                                          ap_netlist,
+                                          prepacker,
+                                          p_placement);
+        return p_placement;
+    } else {
+        // Run the Global Placer
+        std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(e_global_placer::SimPL,
+                                                                        ap_netlist,
+                                                                        prepacker,
+                                                                        atom_nlist,
+                                                                        device_ctx.grid,
+                                                                        device_ctx.logical_block_types,
+                                                                        device_ctx.physical_tile_types);
+        return global_placer->place();
     }
 }
 
@@ -95,25 +146,11 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                      constraints);
     print_ap_netlist_stats(ap_netlist);
 
-    // If a flat placement is provided, skip the Global Placer and conver it
-    // to a partial placement. Otherwise, run the Global Placer.
-    PartialPlacement p_placement(ap_netlist);
-    if (g_vpr_ctx.atom().flat_placement_info().valid) {
-        VTR_LOG("Flat Placement is provided in the AP flow, skipping the Global Placement.\n");
-        convert_flat_to_partial_placement(g_vpr_ctx.atom().flat_placement_info(),
-                                          ap_netlist,
-                                          p_placement);
-    } else {
-        // Run the Global Placer
-        std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(e_global_placer::SimPL,
-                                                                        ap_netlist,
-                                                                        prepacker,
-                                                                        atom_nlist,
-                                                                        device_ctx.grid,
-                                                                        device_ctx.logical_block_types,
-                                                                        device_ctx.physical_tile_types);
-        p_placement = global_placer->place();
-    }
+    // Run the Global Placer.
+    PartialPlacement p_placement = run_global_placer(atom_nlist,
+                                                     ap_netlist,
+                                                     prepacker,
+                                                     device_ctx);
 
     // Verify that the partial placement is valid before running the full
     // legalizer.

vpr/src/analytical_place/analytical_placement_flow.h

@@ -9,19 +9,6 @@
 
 // Forward declarations
 struct t_vpr_setup;
-struct PartialPlacement;
-class FlatPlacementInfo;
-class APNetlist;
-
-/**
- * @brief Passes the flat placement information to a provided partial placement.
- *
- *  @param flat_placement_info    The flat placement information to be read.
- *  @param ap_netlist             The APNetlist that used to iterate over its blocks.
- *  @param p_placement            The partial placement to be updated which is assumend
- * to be generated on ap_netlist or have same blocks.
- */
-void convert_flat_to_partial_placement(const FlatPlacementInfo& flat_placement_info, const APNetlist& ap_netlist, PartialPlacement& p_placement);
 
 /**
  * @brief Run the Analaytical Placement flow.

vpr/src/analytical_place/ap_flow_enums.h

@@ -16,6 +16,6 @@
 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 uses flat placement and tries to reconstruct clusters identically. The method for handling orphan clusters has not yet been determined.
+    Basic_Min_Disturbance ///< The Basic Min. Disturbance Full Legalizer, which tries to reconstruct a clustered placement as close to the incoming flat placement as it can.
 };
 

vpr/src/base/read_options.cpp

@@ -1792,7 +1792,7 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
             "Controls which Full Legalizer to use in the AP Flow.\n"
             " * naive: Use a Naive Full Legalizer which will try to create clusters exactly where their atoms are placed.\n"
             " * appack: Use APPack, which takes the Packer in VPR and uses the flat atom placement to create better clusters.\n"
-            " * basic_min_disturbance: Use The Basic Min. Disturbance Full Legalizer which uses flat placement to reconstruct clusters identically, but the orphan cluster handling method is yet to be determined.")
+            " * basic-min-disturbance: Use the Basic Min. Disturbance Full Legalizer which tries to reconstruct a clustered placement as close to the incoming flat placement as it can.\n")
         .default_value("appack")
         .show_in(argparse::ShowIn::HELP_ONLY);