Added comments to data members of GridTileLookup class

Author: sfkhalid

vpr/src/place/grid_tile_lookup.cpp

@@ -4,7 +4,7 @@ void GridTileLookup::initialize_grid_tile_matrices() {
     auto& device_ctx = g_vpr_ctx.device();
 
     //Will store the max number of tile locations for each logical block type
-    max_tile_counts.resize(device_ctx.logical_block_types.size());
+    max_placement_locations.resize(device_ctx.logical_block_types.size());
 
     for (const auto& type : device_ctx.logical_block_types) {
         vtr::NdMatrix<int, 2> type_count({device_ctx.grid.width(), device_ctx.grid.height()});
@@ -24,7 +24,7 @@ void GridTileLookup::fill_type_matrix(t_logical_block_type_ptr block_type, vtr::
      * the correct type at each location. For each location, we store the cumulative
      * number of tiles of the type up to that location - meaning we store the number of
      * subtiles at the location, plus the number of subtiles at the locations above and to
-     * the left of it.
+     * the right of it.
      */
     for (int i_col = type_count.dim_size(0) - 1; i_col >= 0; i_col--) {
         for (int j_row = type_count.dim_size(1) - 1; j_row >= 0; j_row--) {
@@ -52,15 +52,15 @@ void GridTileLookup::fill_type_matrix(t_logical_block_type_ptr block_type, vtr::
     }
 
     //The total number of subtiles for the block type will be at [0][0]
-    max_tile_counts[block_type->index] = type_count[0][0];
+    max_placement_locations[block_type->index] = type_count[0][0];
 }
 
 vtr::NdMatrix<int, 2>& GridTileLookup::get_type_grid(t_logical_block_type_ptr block_type) {
     return block_type_matrices[block_type->index];
 }
 
 int GridTileLookup::total_type_tiles(t_logical_block_type_ptr block_type) {
-    return max_tile_counts[block_type->index];
+    return max_placement_locations[block_type->index];
 }
 
 /*

vpr/src/place/grid_tile_lookup.h

@@ -1,7 +1,7 @@
 /*
  * This class is used to store a grid for each logical block type that stores the cumulative number of subtiles
  * for that type available at each location in the grid. The cumulative number of subtiles is the subtiles at the
- * location plus the subtiles available at the grid locations above and to the left of the locations.
+ * location plus the subtiles available at the grid locations above and to the right of the locations.
  * Having these grids allows for O(1) lookups about the number of subtiles available for a given type of block
  * in a rectangular region.
  * This lookup class is used during initial placement when sorting blocks by the size of their floorplan constraint
@@ -30,9 +30,20 @@ class GridTileLookup {
     int total_type_tiles(t_logical_block_type_ptr block_type);
 
   private:
+    /*
+     * Stores the cumulative total of subtiles available at each location in the grid for each block type.
+     * Therefore, the length of the vector will be the number of logical block types. To access the cumulative
+     * number of subtiles at a location, you would use block_type_matrices[iblock_type][x][y] - this would
+     * give the number of placement locations that are at, or above and to the right of the given [x,y] for
+     * the given block type.
+     */
     std::vector<vtr::NdMatrix<int, 2>> block_type_matrices;
 
-    std::vector<int> max_tile_counts;
+    /*
+     * Stores the total number of placement locations (i.e. compatible subtiles) for each block type.
+     * To access the max_placement locations for a particular block type, use max_placement_locations[block_type->index]
+     */
+    std::vector<int> max_placement_locations;
 };
 
 #endif /* VPR_SRC_PLACE_GRID_TILE_LOOKUP_H_ */