[AP][Solver] Ignored Disconnected Blocks in AP Solver

After investigating some of the slowest running testcases, I realized
that we were not handling disconnected blocks in the solver.

Especially after we started thresholding out high-fanout nets, some
circuits were taking far longer to solve than they should. They
especially took a long time to set up the matrices. After investigating,
I realized that there were many blocks which we completely disconnected
from the rest of the circuit. There is no reason to optimize the
location of these blocks since the AP objective is formulated based on
net connectivity. As such, these disconnected blocks should be
completely ignored during placement.

Ignoring these blocks reduces the number of variables in the A matrix,
which can greatly improve runtime. Early results on Titan show up to a
3.5x improvement in GP runtime and a 20% improvement in GP runtime on
average.

Future work is to be more methodical on what nets to mark as ignored.
The AP flow currently does not directly set signals like clocks as
ignored, which may be able to allow us to label more blocks as
disconnected.

Author: AlexandreSinger

vpr/src/analytical_place/analytical_solver.cpp

@@ -111,15 +111,32 @@ std::unique_ptr<AnalyticalSolver> make_analytical_solver(e_ap_analytical_solver
 AnalyticalSolver::AnalyticalSolver(const APNetlist& netlist,
                                    const AtomNetlist& atom_netlist,
                                    const PreClusterTimingManager& pre_cluster_timing_manager,
+                                   const DeviceGrid& device_grid,
                                    float ap_timing_tradeoff,
                                    int log_verbosity)
     : netlist_(netlist)
     , atom_netlist_(atom_netlist)
     , blk_id_to_row_id_(netlist.blocks().size(), APRowId::INVALID())
     , row_id_to_blk_id_(netlist.blocks().size(), APBlockId::INVALID())
     , net_weights_(netlist.nets().size(), 1.0f)
+    , device_grid_width_(device_grid.width())
+    , device_grid_height_(device_grid.height())
     , ap_timing_tradeoff_(ap_timing_tradeoff)
     , log_verbosity_(log_verbosity) {
+
+    // Mark completely disconnected blocks. Since these blocks are not connected
+    // to any nets that we care about for AP, we should not pass them into the
+    // AP solver.
+    vtr::vector<APBlockId, bool> block_is_used(netlist.blocks().size(), false);
+    for (APNetId net_id : netlist.nets()) {
+        if (netlist.net_is_ignored(net_id))
+            continue;
+        for (APPinId pin_id : netlist.net_pins(net_id)) {
+            APBlockId blk_id = netlist.pin_block(pin_id);
+            block_is_used[blk_id] = true;
+        }
+    }
+
     // Get the number of moveable blocks in the netlist and create a unique
     // row ID from [0, num_moveable_blocks) for each moveable block in the
     // netlist.
@@ -131,6 +148,12 @@ AnalyticalSolver::AnalyticalSolver(const APNetlist& netlist,
             num_fixed_blocks_++;
         if (netlist.block_mobility(blk_id) != APBlockMobility::MOVEABLE)
             continue;
+        // If this block is disconnected (unused), add it to the disconnected
+        // blocks vector and skip creating a row ID for it.
+        if (!block_is_used[blk_id]) {
+            disconnected_blocks_.push_back(blk_id);
+            continue;
+        }
         APRowId new_row_id = APRowId(current_row_id);
         blk_id_to_row_id_[blk_id] = new_row_id;
         row_id_to_blk_id_[new_row_id] = blk_id;
@@ -404,6 +427,15 @@ void QPHybridSolver::solve(unsigned iteration, PartialPlacement& p_placement) {
     // solution to the zero vector if we do not set it to the guess directly.
     if (iteration == 0 && num_fixed_blocks_ == 0) {
         store_solution_into_placement(guess_x, guess_y, p_placement);
+
+        // Store disconnected blocks into solution at the center of the device
+        for (APBlockId blk_id : disconnected_blocks_) {
+            // All disconnected blocks should not have row IDs or be fixed blocks.
+            VTR_ASSERT_SAFE(!blk_id_to_row_id_[blk_id].is_valid() && netlist_.block_mobility(blk_id) != APBlockMobility::FIXED);
+            p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0f;
+            p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0f;
+        }
+
         return;
     }
 
@@ -442,6 +474,18 @@ void QPHybridSolver::solve(unsigned iteration, PartialPlacement& p_placement) {
     // Write the results back into the partial placement object.
     store_solution_into_placement(x, y, p_placement);
 
+    // In the very first iteration, the solver must provide a location for all
+    // of the blocks. The disconnected blocks will not be given a placement by
+    // the solver above. Just put them in the middle of the device and let the
+    // legalizer find good places for them. In future iterations, the prior
+    // position of these blocks will already be in the p_placement object.
+    if (iteration == 0) {
+        for (APBlockId blk_id : disconnected_blocks_) {
+            p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0;
+            p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0;
+        }
+    }
+
     // Update the guess. The guess for the next iteration is the solution in
     // this iteration.
     guess_x = x;
@@ -497,9 +541,8 @@ void B2BSolver::solve(unsigned iteration, PartialPlacement& p_placement) {
         //       tile location for each AP block. The center is just an
         //       approximation.
         if (num_fixed_blocks_ == 0) {
-            for (size_t row_id_idx = 0; row_id_idx < num_moveable_blocks_; row_id_idx++) {
-                APRowId row_id = APRowId(row_id_idx);
-                APBlockId blk_id = row_id_to_blk_id_[row_id];
+            for (APBlockId blk_id : netlist_.blocks()) {
+                VTR_ASSERT_SAFE(netlist_.block_mobility(blk_id) != APBlockMobility::FIXED);
                 p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0;
                 p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0;
             }
@@ -559,6 +602,13 @@ void B2BSolver::initialize_placement_least_dense(PartialPlacement& p_placement)
             p_placement.block_y_locs[blk_id] = r * gap;
         }
     }
+
+    // Any blocks which are disconnected can be put anywhere. Just put them at
+    // the center of the device for now.
+    for (APBlockId blk_id : disconnected_blocks_) {
+        p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0;
+        p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0;
+    }
 }
 
 void B2BSolver::b2b_solve_loop(unsigned iteration, PartialPlacement& p_placement) {
@@ -654,6 +704,24 @@ void B2BSolver::b2b_solve_loop(unsigned iteration, PartialPlacement& p_placement
         x_guess = x;
         y_guess = y;
     }
+
+    // Disconnected blocks are not optimized by the solver.
+    if (iteration == 0) {
+        // In the first iteration of GP, just place the disconnected blocks at the
+        // center of the device. The legalizer will find a good place to put
+        // them.
+        for (APBlockId blk_id : disconnected_blocks_) {
+            p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0;
+            p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0;
+        }
+    } else {
+        // If a legalized solution is available (after the first iteration of GP), then
+        // set the disconnected blocks to their legalized position.
+        for (APBlockId blk_id : disconnected_blocks_) {
+            p_placement.block_x_locs[blk_id] = block_x_locs_legalized[blk_id];
+            p_placement.block_y_locs[blk_id] = block_y_locs_legalized[blk_id];
+        }
+    }
 }
 
 namespace {
@@ -791,11 +859,11 @@ void B2BSolver::init_linear_system(PartialPlacement& p_placement) {
 
     // Create triplet lists to store the sparse positions to update and reserve
     // space for them.
-    size_t num_nets = netlist_.nets().size();
+    size_t total_num_pins_in_netlist = netlist_.pins().size();
     std::vector<Eigen::Triplet<double>> triplet_list_x;
-    triplet_list_x.reserve(num_nets);
+    triplet_list_x.reserve(total_num_pins_in_netlist);
     std::vector<Eigen::Triplet<double>> triplet_list_y;
-    triplet_list_y.reserve(num_nets);
+    triplet_list_y.reserve(total_num_pins_in_netlist);
 
     for (APNetId net_id : netlist_.nets()) {
         if (netlist_.net_is_ignored(net_id))

vpr/src/analytical_place/analytical_solver.h

@@ -63,6 +63,7 @@ class AnalyticalSolver {
     AnalyticalSolver(const APNetlist& netlist,
                      const AtomNetlist& atom_netlist,
                      const PreClusterTimingManager& pre_cluster_timing_manager,
+                     const DeviceGrid& device_grid,
                      float ap_timing_tradeoff,
                      int log_verbosity);
 
@@ -136,6 +137,21 @@ class AnalyticalSolver {
     ///        between 0 and 1.
     vtr::vector<APNetId, float> net_weights_;
 
+    /// @brief A vector of blocks in the netlist which are not connected to any
+    ///        non-ignored nets. Since the blocks have no connection to any
+    ///        other blocks in the netlist, the are not considered movable or
+    ///        fixed. The solver will just leave these blocks wherever they were
+    ///        legalized.
+    std::vector<APBlockId> disconnected_blocks_;
+
+    /// @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 AP timing tradeoff term used during global placement. Decides
     ///        how much the solver cares about timing vs wirelength.
     float ap_timing_tradeoff_;
@@ -313,7 +329,12 @@ class QPHybridSolver : public AnalyticalSolver {
                    const PreClusterTimingManager& pre_cluster_timing_manager,
                    float ap_timing_tradeoff,
                    int log_verbosity)
-        : AnalyticalSolver(netlist, atom_netlist, pre_cluster_timing_manager, ap_timing_tradeoff, log_verbosity) {
+        : AnalyticalSolver(netlist,
+                           atom_netlist,
+                           pre_cluster_timing_manager,
+                           device_grid,
+                           ap_timing_tradeoff,
+                           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.
@@ -449,9 +470,12 @@ class B2BSolver : public AnalyticalSolver {
               const PreClusterTimingManager& pre_cluster_timing_manager,
               float ap_timing_tradeoff,
               int log_verbosity)
-        : AnalyticalSolver(ap_netlist, atom_netlist, pre_cluster_timing_manager, ap_timing_tradeoff, log_verbosity)
-        , device_grid_width_(device_grid.width())
-        , device_grid_height_(device_grid.height()) {}
+        : AnalyticalSolver(ap_netlist,
+                           atom_netlist,
+                           pre_cluster_timing_manager,
+                           device_grid,
+                           ap_timing_tradeoff,
+                           log_verbosity) {}
 
     /**
      * @brief Perform an iteration of the B2B solver, storing the result into
@@ -603,13 +627,6 @@ class B2BSolver : public AnalyticalSolver {
     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.