placement: add possibility to constraint other blocks than IO pads

Signed-off-by: Alessandro Comodi <[email protected]>

Author: acomodi

vpr/src/base/read_place.cpp

@@ -146,6 +146,7 @@ void read_user_pad_loc(const char* pad_loc_file) {
     int xtmp, ytmp;
     FILE* fp;
     char buf[vtr::bufsize], bname[vtr::bufsize], *ptr;
+    std::unordered_set<ClusterBlockId> constrained_blocks;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
@@ -160,17 +161,14 @@ void read_user_pad_loc(const char* pad_loc_file) {
 
     hash_table = alloc_hash_table();
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
-        auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        if (is_io_type(pick_best_physical_type(logical_block))) {
-            insert_in_hash_table(hash_table, cluster_ctx.clb_nlist.block_name(blk_id).c_str(), size_t(blk_id));
-            place_ctx.block_locs[blk_id].loc.x = OPEN; /* Mark as not seen yet. */
-        }
+        insert_in_hash_table(hash_table, cluster_ctx.clb_nlist.block_name(blk_id).c_str(), size_t(blk_id));
+        place_ctx.block_locs[blk_id].loc.x = OPEN; /* Mark as not seen yet. */
     }
 
     for (size_t i = 0; i < device_ctx.grid.width(); i++) {
         for (size_t j = 0; j < device_ctx.grid.height(); j++) {
             auto type = device_ctx.grid[i][j].type;
-            if (is_io_type(type)) {
+            if (!is_empty_type(type)) {
                 for (int k = 0; k < type->capacity; k++) {
                     if (place_ctx.grid_blocks[i][j].blocks[k] != INVALID_BLOCK_ID) {
                         place_ctx.grid_blocks[i][j].blocks[k] = EMPTY_BLOCK_ID; /* Flag for err. check */
@@ -236,12 +234,12 @@ void read_user_pad_loc(const char* pad_loc_file) {
         int j = ytmp;
 
         if (place_ctx.block_locs[bnum].loc.x != OPEN) {
-            vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, vtr::get_file_line_number_of_last_opened_file(),
+            VPR_THROW(VPR_ERROR_PLACE_F, pad_loc_file, vtr::get_file_line_number_of_last_opened_file(),
                       "Block %s is listed twice in pad file.\n", bname);
         }
 
         if (i < 0 || i > int(device_ctx.grid.width() - 1) || j < 0 || j > int(device_ctx.grid.height() - 1)) {
-            vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, 0,
+            VPR_THROW(VPR_ERROR_PLACE_F, pad_loc_file, 0,
                       "Block #%zu (%s) location, (%d,%d) is out of range.\n", size_t(bnum), bname, i, j);
         }
 
@@ -250,27 +248,33 @@ void read_user_pad_loc(const char* pad_loc_file) {
         place_ctx.block_locs[bnum].loc.z = k;
         place_ctx.block_locs[bnum].is_fixed = true;
 
-        auto type = device_ctx.grid[i][j].type;
-        if (!is_io_type(type)) {
-            vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, 0,
-                      "Attempt to place IO block %s at illegal location (%d, %d).\n", bname, i, j);
+        auto physical_tile = device_ctx.grid[i][j].type;
+        auto logical_block = cluster_ctx.clb_nlist.block_type(bnum);
+        if (!is_tile_compatible(physical_tile, logical_block)) {
+            VPR_THROW(VPR_ERROR_PLACE_F, pad_loc_file, 0,
+                      "Attempt to place block %s at illegal location (%d, %d).\n", bname, i, j);
         }
 
-        if (k >= type->capacity || k < 0) {
-            vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, vtr::get_file_line_number_of_last_opened_file(),
+        if (k >= physical_tile->capacity || k < 0) {
+            VPR_THROW(VPR_ERROR_PLACE_F, pad_loc_file, vtr::get_file_line_number_of_last_opened_file(),
                       "Block %s subblock number (%d) is out of range.\n", bname, k);
         }
         place_ctx.grid_blocks[i][j].blocks[k] = bnum;
         place_ctx.grid_blocks[i][j].usage++;
 
+        constrained_blocks.insert(bnum);
+
         ptr = vtr::fgets(buf, vtr::bufsize, fp);
     }
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {
-        auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-        auto type = pick_best_physical_type(logical_block);
-        if (is_io_type(type) && place_ctx.block_locs[blk_id].loc.x == OPEN) {
-            vpr_throw(VPR_ERROR_PLACE_F, pad_loc_file, 0,
+        auto result = constrained_blocks.find(blk_id);
+        if (result == constrained_blocks.end()) {
+            continue;
+        }
+
+        if (place_ctx.block_locs[blk_id].loc.x == OPEN) {
+            VPR_THROW(VPR_ERROR_PLACE_F, pad_loc_file, 0,
                       "IO block %s location was not specified in the pad file.\n", cluster_ctx.clb_nlist.block_name(blk_id).c_str());
         }
     }

vpr/src/place/initial_placement.cpp

@@ -282,49 +282,46 @@ static void initial_placement_blocks(int* free_locations, enum e_pad_loc_type pa
 
         auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
 
-        /* Don't do IOs if the user specifies IOs; we'll read those locations later. */
-        if (!(is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == USER)) {
-            /* Randomly select a free location of the appropriate type for blk_id.
-             * We have a linearized list of all the free locations that can
-             * accommodate a block of that type in free_locations[itype].
-             * Choose one randomly and put blk_id there. Then we don't want to pick
-             * that location again, so remove it from the free_locations array.
-             */
-
-            auto type = pick_placement_type(logical_block, 1, free_locations);
-
-            if (type == nullptr) {
-                VPR_FATAL_ERROR(VPR_ERROR_PLACE,
-                                "Initial placement failed.\n"
-                                "Could not place block %s (#%zu); no free locations of type %s (#%d).\n",
-                                cluster_ctx.clb_nlist.block_name(blk_id).c_str(), size_t(blk_id), logical_block->name, logical_block->index);
-            }
+        /* Randomly select a free location of the appropriate type for blk_id.
+         * We have a linearized list of all the free locations that can
+         * accommodate a block of that type in free_locations[itype].
+         * Choose one randomly and put blk_id there. Then we don't want to pick
+         * that location again, so remove it from the free_locations array.
+         */
+
+        auto type = pick_placement_type(logical_block, 1, free_locations);
 
-            itype = type->index;
+        if (type == nullptr) {
+            VPR_FATAL_ERROR(VPR_ERROR_PLACE,
+                            "Initial placement failed.\n"
+                            "Could not place block %s (#%zu); no free locations of type %s (#%d).\n",
+                            cluster_ctx.clb_nlist.block_name(blk_id).c_str(), size_t(blk_id), logical_block->name, logical_block->index);
+        }
 
-            t_pl_loc to;
-            initial_placement_location(free_locations, ipos, itype, to);
+        itype = type->index;
 
-            // Make sure that the position is EMPTY_BLOCK before placing the block down
-            VTR_ASSERT(place_ctx.grid_blocks[to.x][to.y].blocks[to.z] == EMPTY_BLOCK_ID);
+        t_pl_loc to;
+        initial_placement_location(free_locations, ipos, itype, to);
 
-            place_ctx.grid_blocks[to.x][to.y].blocks[to.z] = blk_id;
-            place_ctx.grid_blocks[to.x][to.y].usage++;
+        // Make sure that the position is EMPTY_BLOCK before placing the block down
+        VTR_ASSERT(place_ctx.grid_blocks[to.x][to.y].blocks[to.z] == EMPTY_BLOCK_ID);
 
-            place_ctx.block_locs[blk_id].loc = to;
+        place_ctx.grid_blocks[to.x][to.y].blocks[to.z] = blk_id;
+        place_ctx.grid_blocks[to.x][to.y].usage++;
 
-            //Mark IOs as fixed if specifying a (fixed) random placement
-            if (is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == RANDOM) {
-                place_ctx.block_locs[blk_id].is_fixed = true;
-            }
+        place_ctx.block_locs[blk_id].loc = to;
 
-            /* Ensure randomizer doesn't pick this location again, since it's occupied. Could shift all the
-             * legal positions in legal_pos to remove the entry (choice) we just used, but faster to
-             * just move the last entry in legal_pos to the spot we just used and decrement the
-             * count of free_locations. */
-            legal_pos[itype][ipos] = legal_pos[itype][free_locations[itype] - 1]; /* overwrite used block position */
-            free_locations[itype]--;
+        //Mark IOs as fixed if specifying a (fixed) random placement
+        if (is_io_type(pick_best_physical_type(logical_block)) && pad_loc_type == RANDOM) {
+            place_ctx.block_locs[blk_id].is_fixed = true;
         }
+
+        /* Ensure randomizer doesn't pick this location again, since it's occupied. Could shift all the
+         * legal positions in legal_pos to remove the entry (choice) we just used, but faster to
+         * just move the last entry in legal_pos to the spot we just used and decrement the
+         * count of free_locations. */
+        legal_pos[itype][ipos] = legal_pos[itype][free_locations[itype] - 1]; /* overwrite used block position */
+        free_locations[itype]--;
     }
 }
 
@@ -394,6 +391,10 @@ void initial_placement(enum e_pad_loc_type pad_loc_type,
         place_ctx.block_locs[blk_id].loc = t_pl_loc();
     }
 
+    if (pad_loc_type == USER) {
+        read_user_pad_loc(pad_loc_file);
+    }
+
     initial_placement_pl_macros(MAX_NUM_TRIES_TO_PLACE_MACROS_RANDOMLY, free_locations);
 
     // All the macros are placed, update the legal_pos[][] array
@@ -417,10 +418,6 @@ void initial_placement(enum e_pad_loc_type pad_loc_type,
 
     initial_placement_blocks(free_locations, pad_loc_type);
 
-    if (pad_loc_type == USER) {
-        read_user_pad_loc(pad_loc_file);
-    }
-
     /* Restore legal_pos */
     load_legal_placement_locations();