Merge pull request verilog-to-routing#3152 from AlexandreSinger/feature-ap-solver

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

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.