pass grid_blocks to alloc_and_load_legal_placement_locations()

Author: soheilshahrouz

vpr/src/base/read_route.cpp

@@ -222,7 +222,7 @@ static void process_nodes(const Netlist<>& net_list, std::ifstream& fp, ClusterN
     auto& device_ctx = g_vpr_ctx.mutable_device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.mutable_routing();
-    const auto& grid_blocks = g_vpr_ctx.placement().get_grid_blocks();
+    const auto& grid_blocks = g_vpr_ctx.placement().grid_blocks();
 
     t_trace* head_ptr = nullptr;
     t_trace* tptr = nullptr;
@@ -569,7 +569,7 @@ static bool check_rr_graph_connectivity(RRNodeId prev_node, RRNodeId node) {
 void print_route(const Netlist<>& net_list,
                  FILE* fp,
                  bool is_flat) {
-    const auto& grid_blocks = g_vpr_ctx.placement().get_grid_blocks();
+    const auto& grid_blocks = g_vpr_ctx.placement().grid_blocks();
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
     auto& route_ctx = g_vpr_ctx.mutable_routing();

vpr/src/base/vpr_api.cpp

@@ -833,7 +833,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
     //Initialize placement data structures, which will be filled when loading placement
     auto& block_locs = place_ctx.mutable_block_locs();
-    GridBlock& grid_blocks = place_ctx.get_mutable_grid_blocks();
+    GridBlock& grid_blocks = place_ctx.mutable_grid_blocks();
     init_placement_context(block_locs, grid_blocks);
 
     //Load an existing placement from a file
@@ -1283,7 +1283,7 @@ static void free_atoms() {
 static void free_placement() {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
     place_ctx.mutable_block_locs().clear();
-    place_ctx.get_mutable_grid_blocks().clear();
+    place_ctx.mutable_grid_blocks().clear();
 }
 
 static void free_routing() {

vpr/src/base/vpr_context.h

@@ -402,8 +402,8 @@ struct PlacementContext : public Context {
 
     const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.block_locs(); }
     vtr::vector_map<ClusterBlockId, t_block_loc>& mutable_block_locs() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.mutable_block_locs(); }
-    const GridBlock& get_grid_blocks() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.grid_blocks(); }
-    GridBlock& get_mutable_grid_blocks() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.mutable_grid_blocks(); }
+    const GridBlock& grid_blocks() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.grid_blocks(); }
+    GridBlock& mutable_grid_blocks() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.mutable_grid_blocks(); }
     vtr::vector_map<ClusterPinId, int>& mutable_physical_pins() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.mutable_physical_pins(); }
     const vtr::vector_map<ClusterPinId, int>& physical_pins() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.physical_pins(); }
     BlkLocRegistry& mutable_blk_loc_registry() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_; }

vpr/src/base/vpr_types.h

@@ -908,6 +908,14 @@ class GridBlock {
 };
 
 class BlkLocRegistry {
+  public:
+    BlkLocRegistry() = default;
+    ~BlkLocRegistry() = default;
+    BlkLocRegistry(const BlkLocRegistry&) = delete;
+    BlkLocRegistry& operator=(const BlkLocRegistry&) = default;
+    BlkLocRegistry(BlkLocRegistry&&) = delete;
+    BlkLocRegistry& operator=(BlkLocRegistry&&) = delete;
+
   private:
     ///@brief Clustered block placement locations
     vtr::vector_map<ClusterBlockId, t_block_loc> block_locs_;

vpr/src/place/analytic_placer.cpp

@@ -295,8 +295,9 @@ void AnalyticPlacer::build_solve_type(t_logical_block_type_ptr run, int iter) {
 // (stored in legal_pos). For a type of sub_tile_t found in tile_t, legal_pos[tile_t][sub_tile_t]
 // gives a vector containing all positions (t_pl_loc type) for this sub_tile_t.
 void AnalyticPlacer::build_legal_locations() {
+    const auto& grid_blocks = placer_loc_vars_ref_.grid_blocks();
     // invoking same function used in initial_placement.cpp (can ignore function name)
-    alloc_and_load_legal_placement_locations(legal_pos);
+    alloc_and_load_legal_placement_locations(legal_pos, grid_blocks);
 }
 
 // transfer initial placement from g_vpr_ctx to AnalyticPlacer data members, such as: blk_locs, place_blks

vpr/src/place/place_util.cpp

@@ -316,9 +316,9 @@ void zero_initialize_grid_blocks(GridBlock& grid_blocks) {
     }
 }
 
-void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos) {
+void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos,
+                                              const GridBlock& grid_blocks) {
     auto& device_ctx = g_vpr_ctx.device();
-    auto& place_ctx = g_vpr_ctx.placement();
 
     //alloc the legal placement positions
     int num_tile_types = device_ctx.physical_tile_types.size();
@@ -338,7 +338,7 @@ void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vecto
                     auto capacity = sub_tile.capacity;
 
                     for (int k = 0; k < capacity.total(); k++) {
-                        if (place_ctx.get_grid_blocks().block_at_location({i, j, k + capacity.low, layer_num}) == INVALID_BLOCK_ID) {
+                        if (grid_blocks.block_at_location({i, j, k + capacity.low, layer_num}) == INVALID_BLOCK_ID) {
                             continue;
                         }
                         // If this is the anchor position of a block, add it to the legal_pos.

vpr/src/place/place_util.h

@@ -352,7 +352,8 @@ void load_grid_blocks_from_block_locs(GridBlock& grid_blocks,
  *              of the proper tile type and sub_tile type
  *
  */
-void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos);
+void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vector<t_pl_loc>>>& legal_pos,
+                                              const GridBlock& grid_blocks);
 
 ///@brief Performs error checking to see if location is legal for block type,
 /// and sets the location and grid usage of the block if it is legal.

vpr/src/power/power.cpp

@@ -626,7 +626,7 @@ static void power_usage_blocks(t_power_usage* power_usage) {
                     t_pb* pb = nullptr;
                     t_power_usage pb_power;
 
-                    ClusterBlockId iblk = place_ctx.get_grid_blocks().block_at_location({x, y, z, layer_num});
+                    ClusterBlockId iblk = place_ctx.grid_blocks().block_at_location({x, y, z, layer_num});
 
                     if (iblk != EMPTY_BLOCK_ID && iblk != INVALID_BLOCK_ID) {
                         pb = cluster_ctx.clb_nlist.block_pb(iblk);

vpr/src/route/overuse_report.cpp

@@ -242,7 +242,7 @@ static void report_overused_ipin_opin(std::ostream& os,
 
     //Add block type for IPINs/OPINs in overused rr-node report
     const auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    const auto& grid_info = place_ctx.get_grid_blocks();
+    const auto& grid_info = place_ctx.grid_blocks();
 
     os << "Grid location: X = " << grid_x << ", Y = " << grid_y << '\n';
     os << "Number of blocks currently occupying this grid location = " << grid_info.get_usage({grid_x, grid_y, grid_layer}) << '\n';

vpr/src/util/vpr_utils.cpp

@@ -127,7 +127,7 @@ void sync_grid_to_blocks() {
 
     const int num_layers = device_ctx.grid.get_num_layers();
 
-    auto& grid_blocks = place_ctx.get_mutable_grid_blocks();
+    auto& grid_blocks = place_ctx.mutable_grid_blocks();
     auto& block_locs = place_ctx.block_locs();
 
     /* Reset usage and allocate blocks list if needed */
@@ -2363,7 +2363,7 @@ std::vector<int> get_cluster_netlist_intra_tile_classes_at_loc(int layer,
 
     const auto& place_ctx = g_vpr_ctx.placement();
     const auto& atom_lookup = g_vpr_ctx.atom().lookup;
-    const auto& grid_block = place_ctx.get_grid_blocks();
+    const auto& grid_block = place_ctx.grid_blocks();
 
     class_num_vec.reserve(physical_type->primitive_class_inf.size());
 
@@ -2394,7 +2394,7 @@ std::vector<int> get_cluster_netlist_intra_tile_pins_at_loc(const int layer,
                                                             const vtr::vector<ClusterBlockId, std::unordered_set<int>>& pin_chains_num,
                                                             t_physical_tile_type_ptr physical_type) {
     const auto& place_ctx = g_vpr_ctx.placement();
-    const auto& grid_block = place_ctx.get_grid_blocks();
+    const auto& grid_block = place_ctx.grid_blocks();
 
     std::vector<int> pin_num_vec;
     pin_num_vec.reserve(get_tile_num_internal_pin(physical_type));