Added read_place and read_constraints functions and made fixes to read_place_header and read_place_body

Author: sfkhalid

vpr/src/base/read_place.cpp

@@ -1,6 +1,7 @@
 #include <cstdio>
 #include <cstring>
 #include <fstream>
+#include <algorithm>
 
 #include "vtr_assert.h"
 #include "vtr_util.h"
@@ -15,30 +16,78 @@
 #include "read_place.h"
 #include "read_xml_arch_file.h"
 
-/*This function reads the header of a placement file.
- * The header has two lines:
- * One for checking the netlist file
- * And another for checking grid dimensions
- */
-void read_place_header(const char* net_file,
-                       const char* place_file,
-                       bool verify_file_digests,
-                       const DeviceGrid& grid) {
+void read_place_header(
+    std::ifstream& placement_file,
+    const char* net_file,
+    const char* place_file,
+    bool verify_file_hashes,
+    const DeviceGrid& grid);
+
+void read_place_body(
+    std::ifstream& placement_file,
+    const char* place_file,
+    bool is_place_file);
+
+void read_place(
+    const char* net_file,
+    const char* place_file,
+    bool verify_file_digests,
+    const DeviceGrid& grid,
+    bool is_place_file) {
     std::ifstream fstream(place_file);
     if (!fstream) {
         VPR_FATAL_ERROR(VPR_ERROR_PLACE_F,
                         "'%s' - Cannot open place file.\n",
                         place_file);
     }
 
+    VTR_LOG("Reading %s.\n", place_file);
+    VTR_LOG("\n");
+
+    read_place_header(fstream, net_file, place_file, verify_file_digests, grid);
+    read_place_body(fstream, place_file, is_place_file);
+
+    VTR_LOG("Successfully read %s.\n", place_file);
+    VTR_LOG("\n");
+}
+
+void read_constraints(const char* constraints_file,
+                      bool is_place_file) {
+    std::ifstream fstream(constraints_file);
+    if (!fstream) {
+        VPR_FATAL_ERROR(VPR_ERROR_PLACE_F,
+                        "'%s' - Cannot open constraints file.\n",
+                        constraints_file);
+    }
+
+    VTR_LOG("Reading %s.\n", constraints_file);
+    VTR_LOG("\n");
+
+    read_place_body(fstream, constraints_file, is_place_file);
+
+    VTR_LOG("Successfully read %s.\n", constraints_file);
+    VTR_LOG("\n");
+}
+
+/**
+ * This function reads the header (first two lines) of a placement file.
+ * It checks whether the packed netlist file that generated the placement matches the current netlist file.
+ * It also checks whether the FPGA grid size has stayed the same from when the placement was generated.
+ * The verify_file_digests bool is used to decide whether to give a warning or an error if the netlist files do not match.
+ */
+void read_place_header(std::ifstream& placement_file,
+                       const char* net_file,
+                       const char* place_file,
+                       bool verify_file_digests,
+                       const DeviceGrid& grid) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     std::string line;
     int lineno = 0;
     bool seen_netlist_id = false;
-    bool read_header_lines = false;
+    bool seen_grid_dimensions = false;
 
-    while (std::getline(fstream, line) && !read_header_lines) { //Parse line-by-line
+    while (std::getline(placement_file, line) && (!seen_netlist_id || !seen_grid_dimensions)) { //Parse line-by-line
         ++lineno;
 
         std::vector<std::string> tokens = vtr::split(line);
@@ -97,7 +146,7 @@ void read_place_header(const char* net_file,
                           grid.width(), grid.height(), place_file_width, place_file_height);
             }
 
-            read_header_lines = true; //if you have read the grid dimensions you are done reading the place file header
+            seen_grid_dimensions = true; //if you have read the grid dimensions you are done reading the place file header
 
         } else {
             //Unrecognized
@@ -108,35 +157,26 @@ void read_place_header(const char* net_file,
     }
 }
 
-/*This function reads either the body of a placement file or a constraints file.
- * If it is reading a constraints file it marks blocks as locked as it reads in their locations.
+/**
+ * This function reads either the body of a placement file or a constraints file.
+ * If it is reading a place file it sets the x, y, and subtile locations of the blocks in the placement context.
+ * If it is reading a constraints file it does the same and also marks the blocks as locked and marks the grid usage.
  * The bool is_place_file indicates if the file should be read as a place file (is_place_file = true)
  * or a constraints file (is_place_file = false).
  */
-void read_place_body(const char* place_file,
+void read_place_body(std::ifstream& placement_file,
+                     const char* place_file,
                      bool is_place_file) {
-    std::ifstream fstream(place_file);
-    if (!fstream) {
-        VPR_FATAL_ERROR(VPR_ERROR_PLACE_F,
-                        "'%s' - Cannot open place file.\n",
-                        place_file);
-    }
-
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
-    //Mark unseen blocks for error-checking for constraints file
-    if (!is_place_file) {
-        for (auto block_id : cluster_ctx.clb_nlist.blocks()) {
-            place_ctx.block_locs[block_id].loc.x = OPEN; //Mark as not seen yet
-        }
-    }
-
     std::string line;
     int lineno = 0;
 
-    while (std::getline(fstream, line)) { //Parse line-by-line
+    std::vector<ClusterBlockId> seen_blocks;
+
+    while (std::getline(placement_file, line)) { //Parse line-by-line
         ++lineno;
 
         std::vector<std::string> tokens = vtr::split(line);
@@ -147,21 +187,6 @@ void read_place_body(const char* place_file,
         } else if (tokens[0][0] == '#') {
             continue; //Skip commented lines
 
-        } else if (is_place_file
-                   && tokens.size() == 4
-                   && tokens[0] == "Netlist_File:"
-                   && tokens[2] == "Netlist_ID:") {
-            continue; //Skip netlist line if place file, already checked in read_place_header
-
-        } else if (is_place_file
-                   && tokens.size() == 7
-                   && tokens[0] == "Array"
-                   && tokens[1] == "size:"
-                   && tokens[3] == "x"
-                   && tokens[5] == "logic"
-                   && tokens[6] == "blocks") {
-            continue; //Skip checking grid dimensions if place file, already checked in read_place_header
-
         } else if (tokens.size() == 4 || (tokens.size() == 5 && tokens[4][0] == '#')) {
             //Load the block location
             //
@@ -176,18 +201,14 @@ void read_place_body(const char* place_file,
             ClusterBlockId blk_id = cluster_ctx.clb_nlist.find_block(block_name);
 
             //Check if block is listed twice in constraints file
-            if (!is_place_file) {
-                if (place_ctx.block_locs[blk_id].loc.x != OPEN) {
-                    VPR_THROW(VPR_ERROR_PLACE, "The block with ID %d is listed twice in the constraints file.\n", blk_id);
-                }
+            if (find(seen_blocks.begin(), seen_blocks.end(), blk_id) != seen_blocks.end()) {
+                VPR_THROW(VPR_ERROR_PLACE, "The block with ID %d is listed twice in the constraints file.\n", blk_id);
             }
 
             //Check if block location is out of range of grid dimensions
-            if (!is_place_file) {
-                if (block_x < 0 || block_x > int(device_ctx.grid.width() - 1)
-                    || block_y < 0 || block_y > int(device_ctx.grid.height() - 1)) {
-                    VPR_THROW(VPR_ERROR_PLACE, "The block with ID %d is out of range at location (%d, %d). \n", blk_id, block_x, block_y);
-                }
+            if (block_x < 0 || block_x > int(device_ctx.grid.width() - 1)
+                || block_y < 0 || block_y > int(device_ctx.grid.height() - 1)) {
+                VPR_THROW(VPR_ERROR_PLACE, "The block with ID %d is out of range at location (%d, %d). \n", blk_id, block_x, block_y);
             }
 
             if (place_ctx.block_locs.size() != cluster_ctx.clb_nlist.blocks().size()) {
@@ -200,26 +221,38 @@ void read_place_body(const char* place_file,
             place_ctx.block_locs[blk_id].loc.y = block_y;
             place_ctx.block_locs[blk_id].loc.sub_tile = sub_tile_index;
 
+            //Check if block is at an illegal location
+            auto physical_tile = device_ctx.grid[block_x][block_y].type;
+            auto logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
+            if (!is_sub_tile_compatible(physical_tile, logical_block, place_ctx.block_locs[blk_id].loc.sub_tile)) {
+                VPR_THROW(VPR_ERROR_PLACE, place_file, 0, "Attempt to place block %s at illegal location (%d, %d). \n", block_name, block_x, block_y);
+            }
+
+            if (sub_tile_index >= physical_tile->capacity || sub_tile_index < 0) {
+                VPR_THROW(VPR_ERROR_PLACE, place_file, vtr::get_file_line_number_of_last_opened_file(), "Block %s subtile number (%d) is out of range. \n", block_name, sub_tile_index);
+            }
+
             //need to lock down blocks  and mark grid block usage if it is a constraints file
             if (!is_place_file) {
                 place_ctx.block_locs[blk_id].is_fixed = true;
                 place_ctx.grid_blocks[block_x][block_y].blocks[sub_tile_index] = blk_id;
                 place_ctx.grid_blocks[block_x][block_y].usage++;
             }
 
+            //add to vector of blocks that have been seen
+            seen_blocks.push_back(blk_id);
+
         } else {
             //Unrecognized
             vpr_throw(VPR_ERROR_PLACE_F, place_file, lineno,
-                      "Invalid line '%s' in placement file",
+                      "Invalid line '%s' in file",
                       line.c_str());
         }
     }
 
-    if (!is_place_file) {
-        VTR_LOG("Successfully read %s.\n", place_file);
-        VTR_LOG("\n");
+    if (is_place_file) {
+        place_ctx.placement_id = vtr::secure_digest_file(place_file);
     }
-    place_ctx.placement_id = vtr::secure_digest_file(place_file);
 }
 
 /**

vpr/src/base/read_place.h

@@ -1,14 +1,21 @@
 #ifndef READ_PLACE_H
 #define READ_PLACE_H
 
-void read_place_header(
+/**
+ * This function is used to read a placement file.
+ */
+void read_place(
     const char* net_file,
     const char* place_file,
     bool verify_file_hashes,
-    const DeviceGrid& grid);
+    const DeviceGrid& grid,
+    bool is_place_file);
 
-void read_place_body(
-    const char* place_file,
+/**
+ * This function is used to read a constraints file.
+ */
+void read_constraints(
+    const char* constraints_file,
     bool is_place_file);
 
 void print_place(const char* net_file,

vpr/src/base/vpr_api.cpp

@@ -664,8 +664,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
     bool is_a_placement_file = true;
 
     //Load an existing placement from a file
-    read_place_header(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(), filename_opts.verify_file_digests, device_ctx.grid);
-    read_place_body(filename_opts.PlaceFile.c_str(), is_a_placement_file);
+    read_place(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(), filename_opts.verify_file_digests, device_ctx.grid, is_a_placement_file);
 
     //Ensure placement macros are loaded so that they can be drawn after placement (e.g. during routing)
     place_ctx.pl_macros = alloc_and_load_placement_macros(arch.Directs, arch.num_directs);

vpr/src/place/initial_placement.cpp

@@ -451,8 +451,8 @@ void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints
 
     /*Check whether the constraint file is NULL, if not, read in the block locations from the constraints file here*/
     if (strlen(constraints_file) != 0) {
-        bool is_a_place_file = false; //specifies to read_place_body function that this is a constraints file and should be read as such
-        read_place_body(constraints_file, is_a_place_file);
+        bool is_a_place_file = false; //specifies that this is a constraints file, not a place file and should be read as such
+        read_constraints(constraints_file, is_a_place_file);
     }
 
     initial_placement_pl_macros(MAX_NUM_TRIES_TO_PLACE_MACROS_RANDOMLY, free_locations);