[AP] General Fixed/Unfixed Blocks Cleanup

Fixed a couple of small known issues around the AP flow related to how
we handle fixed blocks.

Offset the fixed block locations by 0.5 such that they are no longer on
the edge. Previously, fixed blocks were placed at the root location of
tiles. This was a problem since atoms would want to be generally close
to the fixed block and may be biased to the bottom/left tiles to the
fixed-block tile. This does not handle large tiles, but will help in
general.

If no fixed blocks are provided, the AP solver will always produce the
trivial solution (all blocks placed on top of one another anywhere on
the device). We were wasting time running bound2bound to solve this and
the solution was probably being put on the bottom-left corner (0,0)
which is not ideal. Instead of running bound2bound during the first
iteration in this case, just placed all blocks in the center of the
device. This greatly speeds up the first iteration when no fixed blocks
are provided.

Author: AlexandreSinger

vpr/src/analytical_place/analytical_solver.cpp

@@ -446,6 +446,25 @@ void B2BSolver::solve(unsigned iteration, PartialPlacement& p_placement) {
     // Store an initial placement into the p_placement object as a starting point
     // for the B2B solver.
     if (iteration == 0) {
+        // If there are no fixed blocks, running bound2bound will always yield
+        // the trivial solution (all blocks on top of each other anywhere on the
+        // device). Skip having to solve for this by just putting all the blocks
+        // at the center of the device.
+        // TODO: This can be further improved by using the average compatible
+        //       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];
+                p_placement.block_x_locs[blk_id] = device_grid_width_ / 2.0;
+                p_placement.block_y_locs[blk_id] = device_grid_height_ / 2.0;
+            }
+            block_x_locs_solved = p_placement.block_x_locs;
+            block_y_locs_solved = p_placement.block_y_locs;
+            return;
+        }
+
         // In the first iteration, we have no prior information.
         // Run the intial placer to get a first guess.
         switch (initial_placement_ty_) {

vpr/src/analytical_place/ap_netlist.h

@@ -35,10 +35,10 @@
  */
 struct APFixedBlockLoc {
     // Value that represents an unfixed dimension.
-    static constexpr int UNFIXED_DIM = -1;
+    static constexpr float UNFIXED_DIM = -1;
     // The dimensions to fix.
-    int x = UNFIXED_DIM;
-    int y = UNFIXED_DIM;
+    float x = UNFIXED_DIM;
+    float y = UNFIXED_DIM;
     int layer_num = UNFIXED_DIM;
     int sub_tile = UNFIXED_DIM;
 };

vpr/src/analytical_place/gen_ap_netlist_from_atoms.cpp

@@ -89,8 +89,13 @@ APNetlist gen_ap_netlist_from_atoms(const AtomNetlist& atom_netlist,
             const vtr::Rect<int>& region_rect = region.get_rect();
             VTR_ASSERT(region_rect.xmin() == region_rect.xmax() && "AP: Expect each region to be a single point in x!");
             VTR_ASSERT(region_rect.ymin() == region_rect.ymax() && "AP: Expect each region to be a single point in y!");
-            int blk_x_loc = region_rect.xmin();
-            int blk_y_loc = region_rect.ymin();
+            // Here we offset by 0.5 to put the fixed point in the center of the
+            // tile (assuming the tile is 1x1).
+            // TODO: Think about what to do when the user fixes blocks to large
+            //       tiles. However, this solution will at least keep the atoms
+            //       away from the edge of tiles.
+            float blk_x_loc = region_rect.xmin() + 0.5f;
+            float blk_y_loc = region_rect.ymin() + 0.5f;
             // Get the layer.
             VTR_ASSERT(region.get_layer_range().first == region.get_layer_range().second && "AP: Expect each region to be a single point in layer!");
             int blk_layer_num = region.get_layer_range().first;

vtr_flow/parse/qor_config/qor_ap_fixed_chan_width.txt

@@ -5,6 +5,7 @@ vpr_status;output.txt;vpr_status=(.*)
 crit_path_delay;vpr.out;Critical path: (.*) ns
 post_gp_hpwl;vpr.out;\s*Placement HPWL: (.*)
 post_fl_hpwl;vpr.out;Initial placement BB estimate of wirelength: (.*)
+post_dp_hpwl;vpr.out;BB estimate of min-dist \(placement\) wire length: (.*)
 total_wirelength;vpr.out;\s*Total wirelength: (\d+)
 post_gp_overfilled_bins;vpr.out;\s*Number of overfilled bins: (\d+)
 post_gp_avg_overfill;vpr.out;\s*Average overfill magnitude: (.*)