[AP][GlobalPlacment] Added Bound2Bound Solver

The Bound2Bound net model is a method to solve for the linear HPWL
objective by iteratively solving a quadratic objective function.

This method does obtain a better quality post-global placement flat
placement; at the expense of being more computationally expensive.

Found that this solver also has numerical stability issues. This may
cause the CG solver to never converge which will hit the iteration limit
of 2 * the number of moveable blocks. This makes this algorithm
quadratic with the number of blocks in the netlist. To resolve this, set
a custom iteration limit. This seems to work well on our benchmarks but
may need to be revisited in the future.

Author: AlexandreSinger

doc/src/vpr/command_line_usage.rst

@@ -1188,15 +1188,40 @@ Analytical Placement is generally split into three stages:
 
     Analytical Placement is experimental and under active development.
 
-.. option:: --ap_global_placer {quadratic-bipartitioning-lookahead | quadratic-flowbased-lookahead}
+.. option:: --ap_analytical_solver {qp-hybrid | lp-b2b}
 
-    Controls which Global Placer to use in the AP Flow.
+    Controls which Analytical Solver the Global Placer will use in the AP Flow.
+    The Analytical Solver solves for a placement which optimizes some objective
+    function, ignorant of the FPGA legality constraints. This provides a "lower-
+    bound" solution. The Global Placer will legalize this solution and feed it
+    back to the analytical solver to make its solution more legal.
 
-    * ``quadratic-bipartitioning-lookahead`` Use a Global Placer which uses a quadratic solver and a bi-partitioning lookahead legalizer. Anchor points are used to spread the solved solution to the legalized solution.
+    * ``qp-hybrid`` Solves for a placement that minimizes the quadratic HPWL of
+      the flat placement using a hybrid clique/star net model. Uses the legalized solution
+      as anchor-points to pull the solution to a more legal solution.
 
-    * ``quadratic-flowbased-lookahead`` Use a Global Placer which uses a quadratic solver and a multi-commodity-flow-based lookahead legalizer. Anchor points are used to spread the solved solution to the legalized solution.
+    * ``lp-b2b`` Solves for a placement that minimizes the linear HPWL of the
+      flat placement using the Bound2Bound net model. Uses the legalized solution
+      as anchor-points to pull the solution to a more legal solution.
 
-    **Default:** ``quadratic-bipartitioning-lookahead``
+    **Default:** ``lp-b2b``
+
+.. option:: --ap_partial_legalizer {bipartitioning | flow-based}
+
+    Controls which Partial Legalizer the Global Placer will use in the AP Flow.
+    The Partial Legalizer legalizes a placement generated by an Analytical Solver.
+    It is used within the Global Placer to guide the solver to a more legal
+    solution.
+
+    * ``bipartitioning`` Creates minimum windows around over-dense regions of
+      the device bi-partitions the atoms in these windows such that the region
+      is no longer over-dense and the atoms are in tiles that they can be placed
+      into.
+
+    * ``flow-based`` Flows atoms from regions that are overfilled to regions that
+      are underfilled.
+
+    **Default:** ``bipartitioning``
 
 .. option:: --ap_full_legalizer {naive | appack}
 

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -130,7 +130,8 @@ static PartialPlacement run_global_placer(const t_ap_opts& ap_opts,
         return p_placement;
     } else {
         // Run the Global Placer
-        std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(ap_opts.global_placer_type,
+        std::unique_ptr<GlobalPlacer> global_placer = make_global_placer(ap_opts.analytical_solver_type,
+                                                                         ap_opts.partial_legalizer_type,
                                                                          ap_netlist,
                                                                          prepacker,
                                                                          atom_nlist,

vpr/src/analytical_place/analytical_solver.cpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <memory>
+#include "ap_flow_enums.h"
 #include "ap_netlist.h"
 #include "device_grid.h"
 #include "vtr_strong_id.h"
@@ -31,15 +32,6 @@
 class PartialPlacement;
 class APNetlist;
 
-/**
- * @brief Enumeration of all of the solvers currently implemented in VPR.
- *
- * NOTE: More are coming.
- */
-enum class e_analytical_solver {
-    QP_HYBRID // A solver which optimizes the quadratic HPWL of the design.
-};
-
 /**
  * @brief A strong ID for the rows in a matrix used during solving.
  *
@@ -68,7 +60,7 @@ class AnalyticalSolver {
      * Initializes the internal data members of the base class which are useful
      * for all solvers.
      */
-    AnalyticalSolver(const APNetlist& netlist);
+    AnalyticalSolver(const APNetlist& netlist, int log_verbosity);
 
     /**
      * @brief Run an iteration of the solver using the given partial placement
@@ -90,6 +82,14 @@ class AnalyticalSolver {
      */
     virtual void solve(unsigned iteration, PartialPlacement& p_placement) = 0;
 
+    /**
+     * @brief Print statistics on the analytical solver.
+     *
+     * This is expected to be called after global placement to collect cummulative
+     * information on how the solver performed.
+     */
+    virtual void print_statistics() = 0;
+
   protected:
     /// @brief The APNetlist the solver is optimizing over. It is implied that
     ///        the netlist is not being modified during global placement.
@@ -112,14 +112,18 @@ class AnalyticalSolver {
     ///        APBlock it represents. useful when getting the results from the
     ///        solver.
     vtr::vector<APRowId, APBlockId> row_id_to_blk_id_;
+
+    /// @brief The verbosity of log messages in the Analytical Solver.
+    int log_verbosity_;
 };
 
 /**
  * @brief A factory method which creates an Analytical Solver of the given type.
  */
-std::unique_ptr<AnalyticalSolver> make_analytical_solver(e_analytical_solver solver_type,
+std::unique_ptr<AnalyticalSolver> make_analytical_solver(e_ap_analytical_solver solver_type,
                                                          const APNetlist& netlist,
-                                                         const DeviceGrid& device_grid);
+                                                         const DeviceGrid& device_grid,
+                                                         int log_verbosity);
 
 // The Eigen library is used to solve matrix equations in the following solvers.
 // The solver cannot be built if Eigen is not installed.
@@ -263,14 +267,19 @@ class QPHybridSolver : public AnalyticalSolver {
     /// @brief The current guess for the y positions of the blocks.
     Eigen::VectorXd guess_y;
 
+    /// @brief The total number of CG iterations this solver has performed so far.
+    unsigned total_num_cg_iters_ = 0;
+
   public:
     /**
      * @brief Constructor of the QPHybridSolver
      *
      * Initializes internal data and constructs the initial linear system.
      */
-    QPHybridSolver(const APNetlist& netlist, const DeviceGrid& device_grid)
-        : AnalyticalSolver(netlist) {
+    QPHybridSolver(const APNetlist& netlist,
+                   const DeviceGrid& device_grid,
+                   int log_verbosity)
+        : AnalyticalSolver(netlist, log_verbosity) {
         // Initializing the linear system only depends on the netlist and fixed
         // block locations. Both are provided by the netlist, allowing this to
         // be initialized in the constructor.
@@ -301,6 +310,213 @@ class QPHybridSolver : public AnalyticalSolver {
      *                      this object.
      */
     void solve(unsigned iteration, PartialPlacement& p_placement) final;
+
+    /**
+     * @brief Print statistics of the solver.
+     */
+    void print_statistics() final;
+};
+
+/**
+ * @brief An Analytical Solver which tries to minimize the linear HPWL objective:
+ *          SUM((xmax - xmin) + (ymax - ymin)) over all nets.
+ *
+ * This is implemented using the Bound2Bound method, which iteratively sets up a
+ * linear system of equations (similar to the QP Hybrid approach above) which
+ * solves a quadratic objective function. For a net model, each block connects
+ * to the current bounding blocks in the given dimension and the weight of this
+ * connection is inversly proportional to the distance of the block to the bound.
+ * After minimizing this system, the bounds are likely to change; so the system
+ * needs to be reconstructed and solved iteratively.
+ *
+ * This technique was proposed in Kraftwerk2, where they proved that the B2B Net
+ * Model will, in theory, converge on the linear HPWL solution.
+ *          https://doi.org/10.1109/TCAD.2008.925783
+ */
+class B2BSolver : public AnalyticalSolver {
+  private:
+    /**
+     * @brief Enumeration for different initial placements that this class can
+     *        perform in the first iteration.
+     */
+    enum class e_initial_placement_type {
+        RandomNormal,  //< Randomly distribute blocks over the grid using a normal distribution.
+        RandomUniform, //< Randomly distribute blocks over the grid using a uniform distribution.
+        LeastDense     //< Randomly place blocks as a uniform grid over the device.
+    };
+
+    /// @brief Which initial placement algorithm to use in the first iteration.
+    ///        In the first iteration, we need some solution to initialize the
+    ///        bounds. Some papers have found that setting it to a random
+    ///        initial placement is the best approach.
+    static constexpr e_initial_placement_type initial_placement_ty_ = e_initial_placement_type::LeastDense;
+
+    /// @brief Since the weights in the B2B model divide by the distance between
+    ///        blocks and their bounds, that distance may get very very close to
+    ///        0. This causes the weight matrix to become numerically unstable.
+    ///        We can gaurd against this by clamping the distance to not be smaller
+    ///        than some epsilon.
+    ///        Decreasing this number may lead to more instability, but can yield
+    ///        a higher quality solution.
+    static constexpr double distance_epsilon_ = 0.5;
+
+    /// @brief Max number of bound update / solve iterations. Increasing this
+    ///        number will yield better quality at the expense of runtime.
+    static constexpr unsigned max_num_bound_updates_ = 6;
+
+    /// @brief Max number of iterations the Conjugate Gradient solver can perform.
+    ///        Due to the weights getting very large in the early iterations of
+    ///        Global Placement, the CG solver may take a very long time to
+    ///        converge; but the solution quality will not change much. By
+    ///        default the max iteration is set to 2 * num_moveable_blocks;
+    ///        which causes the first iteration of B2B to become quadratic in the
+    ///        number of moveable blocks if it cannot converge. Found through
+    ///        experimentation that this can be clamped to a much smaller number
+    ///        to prevent this behaviour and get good runtime.
+    // TODO: Need to investigate this more to find a good number for this.
+    // TODO: Should this be a proportion of the design size?
+    static constexpr unsigned max_cg_iterations_ = 200;
+
+    // The following constants are used to configure the anchor weighting.
+    // The weights of anchors grow exponentially each iteration by the following
+    // function:
+    //      anchor_w = anchor_weight_mult_ * e^(iter / anchor_weight_exp_fac_)
+    // The numbers below were empircally found to work well.
+
+    /// @brief Multiplier for the anchorweight. The smaller this number is, the
+    ///        weaker the anchors will be at the start.
+    static constexpr double anchor_weight_mult_ = 0.01;
+
+    /// @brief Factor for controlling the growth of the exponential term in the
+    ///        weight factor function. Larger numbers will cause the anchor
+    ///        weights to grow slower.
+    static constexpr double anchor_weight_exp_fac_ = 5.0;
+
+  public:
+    B2BSolver(const APNetlist& ap_netlist,
+              const DeviceGrid& device_grid,
+              int log_verbosity)
+        : AnalyticalSolver(ap_netlist, log_verbosity)
+        , device_grid_width_(device_grid.width())
+        , device_grid_height_(device_grid.height()) {}
+
+    /**
+     * @brief Perform an iteration of the B2B solver, storing the result into
+     *        the partial placement object passed in.
+     *
+     * In the first iteration (iteration = 0), the partial placement object will
+     * be ignored, and a random initial placement will be used to initially
+     * construct the system of equations. In all other iterations, the previous
+     * solved solution will be used.
+     *
+     * The B2B solver will then iteratively solve the system of equations and
+     * update the system to achieve a good HPWL solution which is close to the
+     * linear HPWL solution. Due to numerical issues with this algorithm, we will
+     * likely not converge on the true minimum HPWL solution, but it should be
+     * close.
+     *
+     * See the base class for more information.
+     *
+     *  @param iteration
+     *      The current iteration of the Global Placer
+     *  @param p_placement
+     *      A "guess" solution. The result will be written into this object.
+     *      In all iterations other than the first, this solution will be used
+     *      as anchor-points in the system.
+     */
+    void solve(unsigned iteration, PartialPlacement& p_placement) final;
+
+    /**
+     * @brief Print overall statistics on this solver.
+     *
+     * This is expected to be called after all iterations of Global Placement
+     * has been complete.
+     */
+    void print_statistics() final;
+
+  private:
+    /**
+     * @brief Run the B2B outer solving loop.
+     *
+     * The placement in p_placement should be initialized with the initial
+     * positions of the blocks that the B2B algorithm should use to build the
+     * first system of equations. This placement will be iteratively updated
+     * with better and better solutions as B2B iterates.
+     *
+     * If iteration is 0, no anchor-blocks will be added to the system, otherwise
+     * the solution in block_locs_legalized will be used as anchor-blocks.
+     */
+    void b2b_solve_loop(unsigned iteration, PartialPlacement& p_placement);
+
+    /**
+     * @brief Randomly distributes AP blocks using a normal distribution.
+     */
+    void initialize_placement_random_normal(PartialPlacement& p_placement);
+
+    /**
+     * @brief Randomly distributes AP blocks using a uniform distribution.
+     */
+    void initialize_placement_random_uniform(PartialPlacement& p_placement);
+
+    /**
+     * @brief Randomly distributes AP blocks using as a uniform grid.
+     */
+    void initialize_placement_least_dense(PartialPlacement& p_placement);
+
+    /**
+     * @brief Initializes the linear system with the given partial placement.
+     *
+     * This will set the connectivity matrices (A) and constant vectors (b) to
+     * be solved by B2B.
+     */
+    void init_linear_system(PartialPlacement& p_placement);
+
+    /**
+     * @brief Updates the linear system with anchor-blocks from the legalized
+     *        solution.
+     */
+    void update_linear_system_with_anchors(PartialPlacement& p_placement,
+                                           unsigned iteration);
+
+    // The following are variables used to store the system of equations to be
+    // solved in the x and y dimensions. The equations are of the form:
+    //          Ax = b
+    // There are two sets of matrices and vectors since the x and y dimensions
+    // of the objective are independent and can be solved separately.
+    // These are updated each iteration of the B2B loop.
+
+    /// @brief The coefficient / connectivity matrix for the x dimension.
+    Eigen::SparseMatrix<double> A_sparse_x;
+    /// @brief The coefficient / connectivity matrix for the y dimension.
+    Eigen::SparseMatrix<double> A_sparse_y;
+    /// @brief The constant vector in the x dimension.
+    Eigen::VectorXd b_x;
+    /// @brief The constant vector in the y dimension.
+    Eigen::VectorXd b_y;
+
+    // The following is the solution of the previous iteration of this solver.
+    // They are updated at the end of solve() and are used as the starting point
+    // for the next call to solve.
+    vtr::vector<APBlockId, double> block_x_locs_solved;
+    vtr::vector<APBlockId, double> block_y_locs_solved;
+
+    // The following are the legalized solution coming into the analytical solver
+    // (other than the first iteration). These are stored to be used as anchor
+    // blocks during the solver.
+    vtr::vector<APBlockId, double> block_x_locs_legalized;
+    vtr::vector<APBlockId, double> block_y_locs_legalized;
+
+    /// @brief The width of the device grid. Used for randomly generating points
+    ///        on the grid.
+    size_t device_grid_width_;
+    /// @brief The height of the device grid. Used for randomly generating points
+    ///        on the grid.
+    size_t device_grid_height_;
+
+    /// @brief The total number of CG iterations that this solver has performed
+    ///        so far. This can be a useful metric for the amount of work the
+    ///        solver performs.
+    unsigned total_num_cg_iters_ = 0;
 };
 
 #endif // EIGEN_INSTALLED

vpr/src/analytical_place/analytical_solver.h

@@ -8,15 +8,27 @@
 #pragma once
 
 /**
- * @brief The type of a Global Placer.
+ * @brief The type of an Analytical Solver.
  *
- * The Analytical Placement flow may implement different Global Placers. This
- * enum can select between these different Global Placers.
+ * The Analytical Placement flow may implement different Analytical Solvers as
+ * part of the Global Placer. This enum can select between these different
+ * Analytical Solvers.
  */
-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.
+enum class e_ap_analytical_solver {
+    QP_Hybrid, ///< Analytical Solver which uses the hybrid net model to optimize the quadratic HPWL objective.
+    LP_B2B     ///< Analytical Solver which uses the B2B net model to optimize the linear HPWL objective.
+};
+
+/**
+ * @brief The type of a Partial Legalizer.
+ *
+ * The Analytical Placement flow may implement different Partial Legalizer as
+ * part of the Global Placer. This enum can select between these different
+ * Partial Legalizers.
+ */
+enum class e_ap_partial_legalizer {
+    BiPartitioning, ///< Partial Legalizer which forms minimum windows around dense regions and uses bipartitioning to spread blocks over windows.
+    FlowBased       ///> Partial Legalizer which flows blocks from overfilled bins to underfilled bins.
 };
 
 /**