[AP][PartialLegalizer] Added Bi-Partitioning Spreader

Bi-partitioning spreading is a technique where minimum spanning windows
are formed around overfilled regions of the device such that the
capacity of the bins within the window is larger than the utilization of
the bins within the window. These windows are then successively
partitioned, moving the blocks to the different partitions, until the
window is small enough. Due to its divide and conquer nature, this
algorithm tends to be very fast.

Created a basic version of this algorithm which does not take into
account the different types of blocks being spread. It worked
suprisingly well, giving better QoR and runtime than the original
spreader that I decided to merge this in immediately. In the future,
will add these features.

Kept the old spreader in as a separate Global Placer as it may be
interesting to compare since the old multi-commodity flow-based approach
should, in theory, do a better job spreading (at the expense of
runtime). This old spreader may also be interesting to add into other
stages of the flow. Added tests to keep this spreader from regressing.

Author: AlexandreSinger

doc/src/vpr/command_line_usage.rst

@@ -1188,6 +1188,16 @@ Analytical Placement is generally split into three stages:
 
     Analytical Placement is experimental and under active development.
 
+.. option:: --ap_global_placer {simple-bipartitioning | simple-flowbased}
+
+    Controls which Global Placer to use in the AP Flow.
+
+    * ``simple-bipartitioning`` Use a Global Placer based on the SimPL AP flow, which uses a quadratic solver and a bi-partitioning partial legalizer.
+
+    * ``simple-flowbased`` Use a Global Placer based on the SimPL AP flow, which uses a quadratic solver and a multi-commodity-flow-based partial legalizer.
+
+    **Default:** ``simple-bipartitioning``
+
 .. option:: --ap_full_legalizer {naive | appack}
 
     Controls which Full Legalizer to use in the AP Flow.
@@ -1198,6 +1208,23 @@ Analytical Placement is generally split into three stages:
 
     **Default:** ``appack``
 
+.. option:: --ap_verbosity <int>
+
+    Controls the verbosity of the AP flow output.
+    Larger values produce more detailed output, which may be useful for
+    debugging the algorithms in the AP flow.
+
+    * ``1 <= verbosity < 10`` Print standard, stage-level messages. This will
+      print messages at the GP, FL, or DP level.
+
+    * ``10 <= verbosity < 20`` Print more detailed messages of what is happening
+      within stages. For example, show high-level information on the legalization
+      iterations within the Global Placer.
+
+    * ``20 <= verbosity`` Print very detailed messages on intra-stage algorithms.
+
+    **Default:** ``1``
+
 
 .. _router_options:
 

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -78,13 +78,15 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
     print_ap_netlist_stats(ap_netlist);
 
     // Run the Global Placer
-    std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(e_global_placer::SimPL,
+    const t_ap_opts& ap_opts = vpr_setup.APOpts;
+    std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(ap_opts.global_placer_type,
                                                                      ap_netlist,
                                                                      prepacker,
                                                                      atom_nlist,
                                                                      device_ctx.grid,
                                                                      device_ctx.logical_block_types,
-                                                                     device_ctx.physical_tile_types);
+                                                                     device_ctx.physical_tile_types,
+                                                                     ap_opts.log_verbosity);
     PartialPlacement p_placement = global_placer->place();
 
     // Verify that the partial placement is valid before running the full
@@ -97,7 +99,6 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                   device_ctx.grid.get_num_layers()));
 
     // Run the Full Legalizer.
-    const t_ap_opts& ap_opts = vpr_setup.APOpts;
     std::unique_ptr<FullLegalizer> full_legalizer = make_full_legalizer(ap_opts.full_legalizer_type,
                                                                         ap_netlist,
                                                                         atom_nlist,

vpr/src/analytical_place/ap_flow_enums.h

@@ -7,6 +7,18 @@
 
 #pragma once
 
+/**
+ * @brief The type of a Global Placer.
+ *
+ * The Analytical Placement flow may implement different Global Placers. This
+ * enum can select between these different Global Placers.
+ */
+enum class e_ap_global_placer {
+    // Global placers based on the the SimPL paper.
+    SimPL_BiParitioning, ///< Global Placer based on the SimPL technique to Global Placement. Uses a quadratic solver and a bi-partitioning Partial Legalizer.
+    SimPL_FlowBased      ///< Global Placer based on the SimPL technique to Global Placement. Uses a quadratic solver and a multi-commodity-flow-baed Partial Legalizer.
+};
+
 /**
  * @brief The type of a Full Legalizer.
  *

vpr/src/analytical_place/global_placer.cpp

@@ -11,6 +11,7 @@
 #include <memory>
 #include <vector>
 #include "analytical_solver.h"
+#include "ap_flow_enums.h"
 #include "ap_netlist.h"
 #include "atom_netlist.h"
 #include "device_grid.h"
@@ -22,36 +23,50 @@
 #include "vtr_log.h"
 #include "vtr_time.h"
 
-std::unique_ptr<GlobalPlacer> make_global_placer(e_global_placer placer_type,
+std::unique_ptr<GlobalPlacer> make_global_placer(e_ap_global_placer placer_type,
                                                  const APNetlist& ap_netlist,
                                                  const Prepacker& prepacker,
                                                  const AtomNetlist& atom_netlist,
                                                  const DeviceGrid& device_grid,
                                                  const std::vector<t_logical_block_type>& logical_block_types,
-                                                 const std::vector<t_physical_tile_type>& physical_tile_types) {
+                                                 const std::vector<t_physical_tile_type>& physical_tile_types,
+                                                 int log_verbosity) {
     // Based on the placer type passed in, build the global placer.
     switch (placer_type) {
-        case e_global_placer::SimPL:
-            return std::make_unique<SimPLGlobalPlacer>(ap_netlist,
+        case e_ap_global_placer::SimPL_BiParitioning:
+            return std::make_unique<SimPLGlobalPlacer>(e_partial_legalizer::BI_PARTITIONING,
+                                                       ap_netlist,
                                                        prepacker,
                                                        atom_netlist,
                                                        device_grid,
                                                        logical_block_types,
-                                                       physical_tile_types);
+                                                       physical_tile_types,
+                                                       log_verbosity);
+        case e_ap_global_placer::SimPL_FlowBased:
+            return std::make_unique<SimPLGlobalPlacer>(e_partial_legalizer::FLOW_BASED,
+                                                       ap_netlist,
+                                                       prepacker,
+                                                       atom_netlist,
+                                                       device_grid,
+                                                       logical_block_types,
+                                                       physical_tile_types,
+                                                       log_verbosity);
         default:
             VPR_FATAL_ERROR(VPR_ERROR_AP,
                             "Unrecognized global placer type");
 
     }
 }
 
-SimPLGlobalPlacer::SimPLGlobalPlacer(const APNetlist& ap_netlist,
+SimPLGlobalPlacer::SimPLGlobalPlacer(e_partial_legalizer partial_legalizer_type,
+                                     const APNetlist& ap_netlist,
                                      const Prepacker& prepacker,
                                      const AtomNetlist& atom_netlist,
                                      const DeviceGrid& device_grid,
                                      const std::vector<t_logical_block_type>& logical_block_types,
-                                     const std::vector<t_physical_tile_type>& physical_tile_types)
-                                        : GlobalPlacer(ap_netlist) {
+                                     const std::vector<t_physical_tile_type>& physical_tile_types,
+                                     int log_verbosity)
+                                        : GlobalPlacer(ap_netlist, log_verbosity) {
     // This can be a long method. Good to time this to see how long it takes to
     // construct the global placer.
     vtr::ScopedStartFinishTimer global_placer_building_timer("Constructing Global Placer");
@@ -67,9 +82,10 @@ SimPLGlobalPlacer::SimPLGlobalPlacer(const APNetlist& ap_netlist,
                                                                      physical_tile_types,
                                                                      log_verbosity_);
     // Build the partial legalizer
-    partial_legalizer_ = make_partial_legalizer(e_partial_legalizer::FLOW_BASED,
+    partial_legalizer_ = make_partial_legalizer(partial_legalizer_type,
                                                 ap_netlist_,
-                                                density_manager_);
+                                                density_manager_,
+                                                log_verbosity_);
 }
 
 /**

vpr/src/analytical_place/global_placer.h

@@ -15,7 +15,9 @@
 #pragma once
 
 #include <memory>
+#include "ap_flow_enums.h"
 #include "flat_placement_density_manager.h"
+#include "partial_legalizer.h"
 
 // Forward declarations
 class APNetlist;
@@ -24,13 +26,6 @@ class PartialLegalizer;
 class Prepacker;
 struct PartialPlacement;
 
-/**
- * @brief Enumeration of all of the global placers currently implemented in VPR.
- */
-enum class e_global_placer {
-    SimPL       // Global placer based on the SimPL paper.
-};
-
 /**
  * @brief The Global Placer base class
  *
@@ -52,7 +47,7 @@ class GlobalPlacer {
      *  @param log_verbosity    The verbosity of log messages in the Global
      *                          Placer.
      */
-    GlobalPlacer(const APNetlist& ap_netlist, int log_verbosity = 1)
+    GlobalPlacer(const APNetlist& ap_netlist, int log_verbosity)
                     : ap_netlist_(ap_netlist),
                       log_verbosity_(log_verbosity) {}
 
@@ -78,13 +73,14 @@ class GlobalPlacer {
 /**
  * @brief A factory method which creates a Global Placer of the given type.
  */
-std::unique_ptr<GlobalPlacer> make_global_placer(e_global_placer placer_type,
+std::unique_ptr<GlobalPlacer> make_global_placer(e_ap_global_placer placer_type,
                                                  const APNetlist& ap_netlist,
                                                  const Prepacker& prepacker,
                                                  const AtomNetlist& atom_netlist,
                                                  const DeviceGrid& device_grid,
                                                  const std::vector<t_logical_block_type>& logical_block_types,
-                                                 const std::vector<t_physical_tile_type>& physical_tile_types);
+                                                 const std::vector<t_physical_tile_type>& physical_tile_types,
+                                                 int log_verbosity);
 
 /**
  * @brief A Global Placer based on the SimPL work for analytical ASIC placement.
@@ -140,12 +136,14 @@ class SimPLGlobalPlacer : public GlobalPlacer {
      *
      * Constructs the solver and partial legalizer.
      */
-    SimPLGlobalPlacer(const APNetlist& ap_netlist,
+    SimPLGlobalPlacer(e_partial_legalizer partial_legalizer_type,
+                      const APNetlist& ap_netlist,
                       const Prepacker& prepacker,
                       const AtomNetlist& atom_netlist,
                       const DeviceGrid& device_grid,
                       const std::vector<t_logical_block_type>& logical_block_types,
-                      const std::vector<t_physical_tile_type>& physical_tile_types);
+                      const std::vector<t_physical_tile_type>& physical_tile_types,
+                      int log_verbosity);
 
     /**
      * @brief Run a SimPL-like global placement algorithm