add load_from_block_locs() to GridBlock

Author: soheilshahrouz

vpr/src/grid_block.cpp renamed to vpr/src/base/grid_block.cpp

@@ -25,6 +25,23 @@ void GridBlock::zero_initialize() {
     }
 }
 
+void GridBlock::load_from_block_locs(const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs) {
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+    auto& device_ctx = g_vpr_ctx.device();
+
+    zero_initialize();
+
+    for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
+        t_pl_loc location = block_locs[blk_id].loc;
+
+        VTR_ASSERT(location.x < (int)device_ctx.grid.width());
+        VTR_ASSERT(location.y < (int)device_ctx.grid.height());
+
+        set_block_at_location(location, blk_id);
+        increment_usage({location.x, location.y, location.layer});
+    }
+}
+
 int GridBlock::increment_usage(const t_physical_tile_loc& loc) {
     int curr_usage = get_usage(loc);
     int updated_usage = set_usage(loc, curr_usage + 1);
@@ -38,3 +55,5 @@ int GridBlock::decrement_usage(const t_physical_tile_loc& loc) {
 
     return updated_usage;
 }
+
+

vpr/src/base/grid_block.h

@@ -75,6 +75,12 @@ class GridBlock {
      */
     void zero_initialize();
 
+    /**
+     * @brief Initializes the GridBlock object with the given block_locs.
+     * @param block_locs Stores the location of each clustered block.
+     */
+    void load_from_block_locs(const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs);
+
     int increment_usage(const t_physical_tile_loc& loc);
 
     int decrement_usage(const t_physical_tile_loc& loc);

vpr/src/place/cut_spreader.cpp

@@ -12,6 +12,7 @@
 #    include "globals.h"
 #    include "vtr_log.h"
 #    include "place_util.h"
+#    include "grid_block.h"
 
 // sentinel for base case in CutSpreader (i.e. only 1 block left in region)
 constexpr std::pair<int, int> BASE_CASE = {-2, -2};

vpr/src/place/move_transactions.cpp

@@ -2,7 +2,6 @@
 #include "move_utils.h"
 
 #include "globals.h"
-#include "place_util.h"
 #include "grid_block.h"
 #include "vtr_assert.h"
 

vpr/src/place/move_utils.h

@@ -256,10 +256,12 @@ void set_placer_breakpoint_reached(bool);
  * if it was able to find a compatible location and false otherwise.
  * It is similar to find_to_loc_uniform but searching in a defined range instead of searching in a range around the current block location.
  *
- *  @param blk_type: the type of the moving block
- *  @param from_loc: the original location of the moving block
- *  @param limit_coords: the region where I can move the block to
- *  @param to_loc: the new location that the function picked for the block
+ *  @param blk_type the type of the moving block
+ *  @param from_loc the original location of the moving block
+ *  @param limit_coords the region where I can move the block to
+ *  @param to_loc the new location that the function picked for the block
+ *  @param b_from The unique ID of the clustered block whose median location is to be computed.
+ *  @param blk_loc_registry Information about clustered block locations.
  */
 bool find_to_loc_median(t_logical_block_type_ptr blk_type,
                         const t_pl_loc& from_loc,
@@ -313,6 +315,7 @@ void compressed_grid_to_loc(t_logical_block_type_ptr blk_type,
  *
  * @param type logical block type
  * @param to_loc The location to be checked
+ * @param grid_blocks A mapping from grid locations to clustered blocks placed there.
  *
  * @return int The subtile number if there is an empty compatible subtile, otherwise -1
  * is returned to indicate that there are no empty subtiles compatible with the given type..
@@ -428,10 +431,6 @@ std::string e_move_result_to_string(e_move_result move_outcome);
  * @brif Iterate over all layers that have a physical tile at the x-y location specified by "loc" that can accommodate "logical_block".
  * If the location in the layer specified by "layer_num" is empty, return that layer. Otherwise,
  * return a layer that is not occupied at that location. If there isn't any, again, return the layer of loc.
- *
- * @param logical_block
- * @param loc
- * @return
  */
 int find_free_layer(t_logical_block_type_ptr logical_block,
                     const t_pl_loc& loc,

vpr/src/place/noc_place_checkpoint.h

@@ -36,14 +36,16 @@ class NoCPlacementCheckpoint {
     /**
      * @brief Saves the current NoC router placement as a checkpoint
      *
-     *  @param cost: The placement cost associated with the current placement
+     *  @param cost The placement cost associated with the current placement
+     *  @param block_locs Stores where each clustered block (including NoC routers) is placed at.
      */
     void save_checkpoint(double cost, const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs);
 
     /**
      * @brief Loads the save checkpoint into global placement data structues.
      *
-     *  @param costs: Used to load NoC related costs for the checkpoint
+     *  @param costs Used to load NoC related costs for the checkpoint
+     *  @param blk_loc_registry To be updated with the save checkpoint for NoC router locations.
      */
     void restore_checkpoint(t_placer_costs& costs,
                             BlkLocRegistry& blk_loc_registry);

vpr/src/place/place_checkpoint.cpp

@@ -1,6 +1,7 @@
 #include "place_checkpoint.h"
 #include "noc_place_utils.h"
 #include "placer_state.h"
+#include "grid_block.h"
 
 float t_placement_checkpoint::get_cp_cpd() const { return cpd_; }
 
@@ -20,7 +21,7 @@ void t_placement_checkpoint::save_placement(const vtr::vector_map<ClusterBlockId
 t_placer_costs t_placement_checkpoint::restore_placement(vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs,
                                                          GridBlock& grid_blocks) {
     block_locs = block_locs_;
-    load_grid_blocks_from_block_locs(grid_blocks, block_locs);
+    grid_blocks.load_from_block_locs(block_locs);
     return costs_;
 }
 

vpr/src/place/place_util.cpp

@@ -273,23 +273,6 @@ double get_std_dev(int n, double sum_x_squared, double av_x) {
     return (std_dev > 0.) ? sqrt(std_dev) : 0.;
 }
 
-void load_grid_blocks_from_block_locs(GridBlock& grid_blocks,
-                                      const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs) {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& device_ctx = g_vpr_ctx.device();
-
-    grid_blocks.zero_initialize();
-
-    for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
-        t_pl_loc location = block_locs[blk_id].loc;
-
-        VTR_ASSERT(location.x < (int)device_ctx.grid.width());
-        VTR_ASSERT(location.y < (int)device_ctx.grid.height());
-
-        grid_blocks.set_block_at_location(location, blk_id);
-        grid_blocks.increment_usage({location.x, location.y, location.layer});
-    }
-}
 
 void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos) {
     auto& device_ctx = g_vpr_ctx.device();

vpr/src/place/place_util.h

@@ -336,10 +336,6 @@ int get_initial_move_lim(const t_placer_opts& placer_opts, const t_annealing_sch
  */
 double get_std_dev(int n, double sum_x_squared, double av_x);
 
-///@brief a utility to calculate grid_blocks given the updated block_locs (used in restore_checkpoint)
-void load_grid_blocks_from_block_locs(GridBlock& grid_blocks,
-                                      const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs);
-
 /**
  * @brief Builds (alloc and load) legal_pos that holds all the legal locations for placement
  *

vpr/src/util/vpr_utils.cpp

@@ -19,6 +19,7 @@
 #include "user_route_constraints.h"
 #include "re_cluster_util.h"
 #include "placer_state.h"
+#include "grid_block.h"
 
 /* This module contains subroutines that are used in several unrelated parts *
  * of VPR.  They are VPR-specific utility routines.                          */