[AP][FullLegalizer] Basic Min. Disturbance FL

Added read flat placement to AP flow and
and command line option for Basic Min. Disturbance FL.

Author: haydar-c

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -58,6 +58,24 @@ 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){
+    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;
+        }
+
+        // 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];
+    }
+}
+
 void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
     // Start an overall timer for the Analytical Placement flow.
     vtr::ScopedStartFinishTimer timer("Analytical Placement");
@@ -77,15 +95,25 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                      constraints);
     print_ap_netlist_stats(ap_netlist);
 
-    // 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);
-    PartialPlacement p_placement = global_placer->place();
+    // 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();
+    }
 
     // Verify that the partial placement is valid before running the full
     // legalizer.

vpr/src/analytical_place/analytical_placement_flow.h

@@ -9,6 +9,19 @@
 
 // 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

@@ -15,6 +15,7 @@
  */
 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.
+    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.
 };
 

vpr/src/analytical_place/full_legalizer.cpp

@@ -70,6 +70,11 @@ std::unique_ptr<FullLegalizer> make_full_legalizer(e_ap_full_legalizer full_lega
                                             vpr_setup,
                                             arch,
                                             device_grid);
+        case e_ap_full_legalizer::Basic_Min_Disturbance:
+            VTR_LOG("Basic Minimum Disturbance Full Legalizer selected!\n");
+            VPR_FATAL_ERROR(VPR_ERROR_AP,
+                             "Basic Min. Disturbance Full Legalizer has not been implemented yet.");
+
         default:
              VPR_FATAL_ERROR(VPR_ERROR_AP,
                              "Unrecognized full legalizer type");

vpr/src/base/ShowSetup.cpp

@@ -603,6 +603,9 @@ static void ShowAnalyticalPlacerOpts(const t_ap_opts& APOpts) {
         case e_ap_full_legalizer::APPack:
             VTR_LOG("appack\n");
             break;
+        case e_ap_full_legalizer::Basic_Min_Disturbance:
+            VTR_LOG("basic_min_disturbance\n");
+            break;
         default:
             VPR_FATAL_ERROR(VPR_ERROR_UNKNOWN, "Unknown full_legalizer_type\n");
     }

vpr/src/base/read_options.cpp

@@ -141,6 +141,8 @@ struct ParseAPFullLegalizer {
             conv_value.set_value(e_ap_full_legalizer::Naive);
         else if (str == "appack")
             conv_value.set_value(e_ap_full_legalizer::APPack);
+        else if (str == "basic_min_disturbance")
+            conv_value.set_value(e_ap_full_legalizer::Basic_Min_Disturbance);
         else {
             std::stringstream msg;
             msg << "Invalid conversion from '" << str << "' to e_ap_full_legalizer (expected one of: " << argparse::join(default_choices(), ", ") << ")";
@@ -158,14 +160,16 @@ struct ParseAPFullLegalizer {
             case e_ap_full_legalizer::APPack:
                 conv_value.set_value("appack");
                 break;
+            case e_ap_full_legalizer::Basic_Min_Disturbance:
+                conv_value.set_value("basic_min_disturbance");
             default:
                 VTR_ASSERT(false);
         }
         return conv_value;
     }
 
     std::vector<std::string> default_choices() {
-        return {"naive", "appack"};
+        return {"naive", "appack", "basic_min_disturbance"};
     }
 };
 
@@ -1787,7 +1791,8 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help(
             "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.")
+            " * 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.")
         .default_value("appack")
         .show_in(argparse::ShowIn::HELP_ONLY);
 

vpr/src/base/vpr_api.cpp

@@ -404,8 +404,25 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
 
     { // Analytical Place
         if (vpr_setup.APOpts.doAP == STAGE_DO) {
+            // Passing flat placement input if provided and not loaded yet.
+            if (!vpr_setup.FileNameOpts.read_flat_place_file.empty() &&
+                !g_vpr_ctx.atom().flat_placement_info().valid) {
+                g_vpr_ctx.mutable_atom().mutable_flat_placement_info() = read_flat_placement(
+                                            vpr_setup.FileNameOpts.read_flat_place_file,
+                                            g_vpr_ctx.atom().netlist());
+            }
+
             // TODO: Make this return a bool if the placement was successful or not.
             run_analytical_placement_flow(vpr_setup);
+
+            // Write out a flat placement file at the end of Analytical Placement
+            // flow 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);
+            }
         }
         // Print the placement generated by AP to a .place file.
         auto& filename_opts = vpr_setup.FileNameOpts;