Add some comments in device_grid.h - initialize instance_count befor do the counting - apply the review comments

Author: amin1377

libs/libarchfpga/src/device_grid.cpp

@@ -48,6 +48,20 @@ void DeviceGrid::count_instances() {
     instance_counts_.clear();
     instance_counts_.resize(num_layers);
 
+    //Initialize the instance counts
+    for (int layer_num = 0; layer_num < num_layers; ++layer_num) {
+        for (size_t x = 0; x < width(); ++x) {
+            for (size_t y = 0; y < height(); ++y) {
+                auto type = grid_[layer_num][x][y].type;
+
+                if (grid_[layer_num][x][y].width_offset == 0 && grid_[layer_num][x][y].height_offset == 0) {
+                    //Add capacity only if this is the root location
+                    instance_counts_[layer_num][type] = 0;
+                }
+            }
+        }
+    }
+
     //Count the number of blocks in the grid
     for (int layer_num = 0; layer_num < num_layers; ++layer_num) {
         for (size_t x = 0; x < width(); ++x) {

libs/libarchfpga/src/device_grid.h

@@ -9,7 +9,7 @@
 
 /**
  * @brief s_grid_tile is the minimum tile of the fpga
- * @note This struct shouldn't be directly accessed by other functions. Use helper function in DeviceGrid instead.
+ * @note This struct shouldn't be directly accessed by other functions. Use the helper functions in DeviceGrid instead.
  */
 struct t_grid_tile {
     t_physical_tile_type_ptr type = nullptr; ///<Pointer to type descriptor, NULL for illegal
@@ -38,32 +38,12 @@ class DeviceGrid {
     ///@brief Return the height of the grid at the specified layer
     size_t height() const { return grid_.dim_size(2); }
 
-    ///@brief Given t_grid_tile, return the x coordinate of the tile on the given layer
-    inline int get_grid_loc_x(const t_grid_tile*& grid_loc) const {
-        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
-        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
-
-        return diff / grid_.dim_size(2);
-    }
-
-    ///@brief Given t_grid_tile, return the y coordinate of the tile on the given layer
-    inline int get_grid_loc_y(const t_grid_tile*& grid_loc) const {
-        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
-        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
-
-        return diff % grid_.dim_size(2);
-    }
-
-    ///@brief Return the nth t_grid_tile on the given layer of the flattened grid
-    inline const t_grid_tile* get_grid_locs_grid_loc(int n) const {
-        return &grid_.get(n);
-    }
-
     ///@brief Return the size of the flattened grid on the given layer
     inline size_t grid_size() const {
         return grid_.size();
     }
 
+    ///@brief deallocate members of DeviceGrid
     void clear();
 
     /**
@@ -98,20 +78,41 @@ class DeviceGrid {
         return grid_[layer_num][x][y].meta;
     }
 
+    ///@brief Given t_grid_tile, return the x coordinate of the tile on the given layer - Used by serializer functions
+    inline int get_grid_loc_x(const t_grid_tile*& grid_loc) const {
+        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
+        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
+
+        return diff / grid_.dim_size(2);
+    }
+
+    ///@brief Given t_grid_tile, return the y coordinate of the tile on the given layer - Used by serializer functions
+    inline int get_grid_loc_y(const t_grid_tile*& grid_loc) const {
+        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
+        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
+
+        return diff % grid_.dim_size(2);
+    }
+
+    ///@brief Return the nth t_grid_tile on the given layer of the flattened grid - Used by serializer functions
+    inline const t_grid_tile* get_grid_locs_grid_loc(int n) const {
+        return &grid_.get(n);
+    }
+
   private:
     ///@brief count_instances() counts the number of each tile type on each layer and store it in instance_counts_. It is called in the constructor.
     void count_instances();
 
     std::string name_;
 
     /**
-     * @brief grid_ is a of 3D grids.
+     * @brief grid_ is a 3D matrix that represents the grid of the FPGA chip.
      * @note The first dimension is the layer number (grid_[0] corresponds to the bottom layer), the second dimension is the x coordinate, and the third dimension is the y coordinate.
      * @note Note that vtr::Matrix operator[] returns and intermediate type
-     * @note which can be used or indexing in the second dimension, allowing
+     * @note which can be used for indexing in the second dimension, allowing
      * @note traditional 2-d indexing to be used
      */
-    vtr::NdMatrix<t_grid_tile, 3> grid_;
+    vtr::NdMatrix<t_grid_tile, 3> grid_; //This stores the grid of complex blocks. It is a a 3D matrix: [0..num_layers-1][0..grid.width()-1][0..grid_height()-1]
 
     ///@brief instance_counts_ stores the number of each tile type on each layer. It is initialized in count_instances().
     std::vector<std::map<t_physical_tile_type_ptr, size_t>> instance_counts_; /* [layer_num][physical_tile_type_ptr] */

vpr/src/base/vpr_api.cpp

@@ -461,10 +461,8 @@ void vpr_create_device_grid(const t_vpr_setup& vpr_setup, const t_arch& Arch) {
         VTR_LOG("\tArchitecture\n");
         for (const auto equivalent_tile : type.equivalent_tiles) {
             auto num_instances = 0;
-            //Count number of equivalent tile at each die and add all up together
-            for (int layer = 0; layer < device_ctx.grid.get_num_layers(); layer++) {
-                num_instances += device_ctx.grid.num_instances(equivalent_tile, layer);
-            }
+            //get the number of equivalent tile across all layers
+            num_instances = (int)device_ctx.grid.num_instances(equivalent_tile, -1);
 
             VTR_LOG("\t\t%d\tblocks of type: %s\n",
                     num_instances, equivalent_tile->name);

vpr/src/base/vpr_context.h

@@ -145,7 +145,7 @@ struct DeviceContext : public Context {
     /**
      * @brief The device grid
      *
-     * This represents the physical layout of the device. To get the physical tile at each location (x, y, z) the helper function in this data structure should be used.
+     * This represents the physical layout of the device. To get the physical tile at each location (layer_num, x, y) the helper functions in this data structure should be used.
      */
     DeviceGrid grid;
     /*