replace accesses to global block_locs and grid_blocks with a reference to place location vars

Author: soheilshahrouz

vpr/src/place/analytic_placer.cpp

@@ -128,7 +128,9 @@ constexpr int HEAP_STALLED_ITERATIONS_STOP = 15;
  * Currently only initializing AP configuration parameters
  * Placement & device info is accessed via g_vpr_ctx
  */
-AnalyticPlacer::AnalyticPlacer() {
+
+AnalyticPlacer::AnalyticPlacer(const PlaceLocVars& place_loc_vars)
+    : placer_loc_vars_ref_(place_loc_vars) {
     //Eigen::initParallel();
 
     // TODO: PlacerHeapCfg should be externally configured & supplied
@@ -301,7 +303,7 @@ void AnalyticPlacer::build_legal_locations() {
 // initialize other data members
 void AnalyticPlacer::init() {
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    auto& block_locs = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = placer_loc_vars_ref_.block_locs();
 
     for (auto blk_id : clb_nlist.blocks()) {
         blk_locs.insert(blk_id, BlockLocation{});
@@ -741,7 +743,7 @@ std::string AnalyticPlacer::print_overlap(vtr::Matrix<int>& overlap, FILE* fp) {
 void AnalyticPlacer::print_place(const char* place_file) {
     const DeviceContext& device_ctx = g_vpr_ctx.device();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    auto& block_locs = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = placer_loc_vars_ref_.block_locs();
 
     FILE* fp;
 

vpr/src/place/analytic_placer.h

@@ -122,7 +122,8 @@ class AnalyticPlacer {
      * @brief Constructor of AnalyticPlacer, currently initializes AnalyticPlacerCfg for the analytic placer
      * To tune these parameters, change directly in constructor
      */
-    AnalyticPlacer();
+    AnalyticPlacer() = delete;
+    explicit AnalyticPlacer(const PlaceLocVars& place_loc_vars);
 
     /*
      * @brief main function of analytic placement
@@ -180,6 +181,9 @@ class AnalyticPlacer {
     // Lookup from blockID to block location
     vtr::vector_map<ClusterBlockId, BlockLocation> blk_locs;
 
+    // reference to the placement location variables
+    PlaceLocVars& placer_loc_vars_ref_;
+
     /*
      * The set of blks of different types to be placed by AnalyticPlacement process,
      * i.e. the free variable blocks.

vpr/src/place/cut_spreader.cpp

@@ -405,7 +405,7 @@ void CutSpreader::expand_regions() {
 std::pair<int, int> CutSpreader::cut_region(SpreaderRegion& r, bool dir) {
     const DeviceContext& device_ctx = g_vpr_ctx.device();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    PlacementContext& place_ctx = g_vpr_ctx.mutable_placement();
+    const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
 
     // TODO: CutSpreader is not compatible with 3D FPGA
     VTR_ASSERT(device_ctx.grid.get_num_layers() == 1);
@@ -503,15 +503,15 @@ std::pair<int, int> CutSpreader::cut_region(SpreaderRegion& r, bool dir) {
     // while left subarea is over-utilized, move logic blocks to the right subarea one at a time
     while (pivot > 0 && rl.overused(ap->ap_cfg.beta)) {
         auto& move_blk = cut_blks.at(pivot);
-        int size = (imacro(move_blk) != NO_MACRO) ? place_ctx.pl_macros[imacro(move_blk)].members.size() : 1;
+        int size = (imacro(move_blk) != NO_MACRO) ? pl_macros[imacro(move_blk)].members.size() : 1;
         rl.n_blks -= size;
         rr.n_blks += size;
         pivot--;
     }
     // while right subarea is over-utilized, move logic blocks to the left subarea one at a time
     while (pivot < int(cut_blks.size()) - 1 && rr.overused(ap->ap_cfg.beta)) {
         auto& move_blk = cut_blks.at(pivot + 1);
-        int size = (imacro(move_blk) != NO_MACRO) ? place_ctx.pl_macros[imacro(move_blk)].members.size() : 1;
+        int size = (imacro(move_blk) != NO_MACRO) ? pl_macros[imacro(move_blk)].members.size() : 1;
         rl.n_blks += size;
         rr.n_blks -= size;
         pivot++;
@@ -617,15 +617,15 @@ int CutSpreader::initial_source_cut(SpreaderRegion& r,
                                     bool dir,
                                     int& clearance_l,
                                     int& clearance_r) {
-    PlacementContext& place_ctx = g_vpr_ctx.mutable_placement();
+    const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
 
     // pivot is the midpoint of cut_blks in terms of total block size (counting macro members)
     // this ensures the initial partitions have similar number of blocks
     int pivot_blks = 0; // midpoint in terms of total number of blocks
     int pivot = 0;      // midpoint in terms of index of cut_blks
     for (auto& blk : cut_blks) {
         // if blk is part of macro (only macro heads in cut_blks, no macro members), add that macro's size
-        pivot_blks += (imacro(blk) != NO_MACRO) ? place_ctx.pl_macros[imacro(blk)].members.size() : 1;
+        pivot_blks += (imacro(blk) != NO_MACRO) ? pl_macros[imacro(blk)].members.size() : 1;
         if (pivot_blks >= r.n_blks / 2)
             break;
         pivot++;
@@ -670,16 +670,16 @@ int CutSpreader::initial_target_cut(SpreaderRegion& r,
                                     int& right_blks_n,
                                     int& left_tiles_n,
                                     int& right_tiles_n) {
-    PlacementContext& place_ctx = g_vpr_ctx.mutable_placement();
+    const auto& pl_macros = g_vpr_ctx.mutable_placement().pl_macros;
 
     // To achieve smallest difference in utilization, first move all tiles to right partition
     left_blks_n = 0, right_blks_n = 0;
     left_tiles_n = 0, right_tiles_n = r.n_tiles;
     // count number of blks in each partition, from initial source cut
     for (int i = 0; i <= init_source_cut; i++)
-        left_blks_n += (imacro(cut_blks.at(i)) != NO_MACRO) ? place_ctx.pl_macros[imacro(cut_blks.at(i))].members.size() : 1;
+        left_blks_n += (imacro(cut_blks.at(i)) != NO_MACRO) ? pl_macros[imacro(cut_blks.at(i))].members.size() : 1;
     for (int i = init_source_cut + 1; i < int(cut_blks.size()); i++)
-        right_blks_n += (imacro(cut_blks.at(i)) != NO_MACRO) ? place_ctx.pl_macros[imacro(cut_blks.at(i))].members.size() : 1;
+        right_blks_n += (imacro(cut_blks.at(i)) != NO_MACRO) ? pl_macros[imacro(cut_blks.at(i))].members.size() : 1;
 
     int best_tgt_cut = -1;
     double best_deltaU = std::numeric_limits<double>::max();
@@ -805,8 +805,8 @@ void CutSpreader::linear_spread_subarea(std::vector<ClusterBlockId>& cut_blks,
  */
 void CutSpreader::strict_legalize() {
     auto& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    auto& place_ctx = g_vpr_ctx.placement();
-    auto& block_locs = place_ctx.block_locs();
+    const auto& block_locs = ap->placer_loc_vars_ref_.block_locs();
+    const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
     int max_x = g_vpr_ctx.device().grid.width();
     int max_y = g_vpr_ctx.device().grid.height();
 
@@ -824,7 +824,7 @@ void CutSpreader::strict_legalize() {
     std::priority_queue<std::pair<int, ClusterBlockId>> remaining;
     for (ClusterBlockId blk : ap->solve_blks) {
         if (imacro(blk) != NO_MACRO) // blk is head block of a macro (only head blks are solved)
-            remaining.emplace(place_ctx.pl_macros[imacro(blk)].members.size(), blk);
+            remaining.emplace(pl_macros[imacro(blk)].members.size(), blk);
         else
             remaining.emplace(1, blk);
     }
@@ -962,16 +962,15 @@ void CutSpreader::strict_legalize() {
  * Place blk on sub_tile location by modifying place_ctx.grid_blocks, place_ctx.block_locs, and ap->blk_locs[blk].loc
  */
 void CutSpreader::bind_tile(t_pl_loc sub_tile, ClusterBlockId blk) {
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
-    auto& grid_blocks = place_ctx.get_mutable_grid_blocks();
-    auto& block_locs = place_ctx.mutable_block_locs();
+    auto& grid_blocks = ap->placer_loc_vars_ref_.mutable_grid_blocks();
+    auto& block_locs = ap->placer_loc_vars_ref_.mutable_block_locs();
 
     VTR_ASSERT(grid_blocks.block_at_location(sub_tile) == EMPTY_BLOCK_ID);
     VTR_ASSERT(block_locs[blk].is_fixed == false);
     grid_blocks.set_block_at_location(sub_tile, blk);
     block_locs[blk].loc = sub_tile;
     grid_blocks.set_usage({sub_tile.x, sub_tile.y, sub_tile.layer},
-                          place_ctx.get_grid_blocks().get_usage({sub_tile.x, sub_tile.y, sub_tile.layer}) + 1);
+                          grid_blocks.get_usage({sub_tile.x, sub_tile.y, sub_tile.layer}) + 1);
     ap->blk_locs[blk].loc = sub_tile;
 }
 
@@ -980,17 +979,16 @@ void CutSpreader::bind_tile(t_pl_loc sub_tile, ClusterBlockId blk) {
  * Remove placement at sub_tile location by clearing place_ctx.block_locs and place_Ctx.grid_blocks
  */
 void CutSpreader::unbind_tile(t_pl_loc sub_tile) {
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
-    auto& grid_blocks = place_ctx.get_mutable_grid_blocks();
-    auto& block_locs = place_ctx.mutable_block_locs();
+    auto& grid_blocks = ap->placer_loc_vars_ref_.mutable_grid_blocks();
+    auto& block_locs = ap->placer_loc_vars_ref_.mutable_block_locs();
 
     VTR_ASSERT(grid_blocks.block_at_location(sub_tile) != EMPTY_BLOCK_ID);
     ClusterBlockId blk = grid_blocks.block_at_location(sub_tile);
     VTR_ASSERT(block_locs[blk].is_fixed == false);
     block_locs[blk].loc = t_pl_loc{};
     grid_blocks.set_block_at_location(sub_tile, EMPTY_BLOCK_ID);
     grid_blocks.set_usage({sub_tile.x, sub_tile.y, sub_tile.layer},
-                          place_ctx.get_grid_blocks().get_usage({sub_tile.x, sub_tile.y, sub_tile.layer}) - 1);
+                          grid_blocks.get_usage({sub_tile.x, sub_tile.y, sub_tile.layer}) - 1);
 }
 
 /*
@@ -999,9 +997,8 @@ void CutSpreader::unbind_tile(t_pl_loc sub_tile) {
  * the block in place_ctx.grid_blocks)
  */
 bool CutSpreader::is_placed(ClusterBlockId blk) {
-    auto& place_ctx = g_vpr_ctx.placement();
-    auto& grid_blocks = place_ctx.get_grid_blocks();
-    auto& block_locs = place_ctx.block_locs();
+    const auto& grid_blocks = ap->placer_loc_vars_ref_.grid_blocks();
+    const auto& block_locs = ap->placer_loc_vars_ref_.block_locs();
 
     if (block_locs[blk].loc != t_pl_loc{}) {
         auto loc = block_locs[blk].loc;
@@ -1035,14 +1032,14 @@ bool CutSpreader::try_place_blk(ClusterBlockId blk,
                                 int& best_inp_len,
                                 t_pl_loc& best_subtile,
                                 std::priority_queue<std::pair<int, ClusterBlockId>>& remaining) {
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
+    const auto& grid_blocks = ap->placer_loc_vars_ref_.grid_blocks();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
-    // iteration at current radius has exceed exploration limit, and a candidate sub_tile (best_subtile) is found
+    // iteration at current radius has exceeded exploration limit, and a candidate sub_tile (best_subtile) is found
     // then blk is placed in best_subtile
     if (exceeds_explore_limit && best_subtile != t_pl_loc{}) {
         // find the logic block bound to (placed on) best_subtile
-        ClusterBlockId bound_blk = place_ctx.get_grid_blocks().block_at_location(best_subtile);
+        ClusterBlockId bound_blk = grid_blocks.block_at_location(best_subtile);
         if (bound_blk != EMPTY_BLOCK_ID) {   // if best_subtile has a logic block
             unbind_tile(best_subtile);       // clear bound_block and best_subtile's placement info
             remaining.emplace(1, bound_blk); // put bound_blk back into remaining blocks to place
@@ -1053,7 +1050,7 @@ bool CutSpreader::try_place_blk(ClusterBlockId blk,
 
     // if exploration limit is not met or a candidate sub_tile is not found yet
     for (auto sub_t : subtiles_at_location[nx][ny]) {                              // for each available sub_tile at random location
-        ClusterBlockId bound_blk = place_ctx.get_grid_blocks().block_at_location(sub_t); // logic blk at [nx, ny]
+        ClusterBlockId bound_blk = grid_blocks.block_at_location(sub_t); // logic blk at [nx, ny]
         if (bound_blk == EMPTY_BLOCK_ID
             || ripup_radius_met
             || rand() % (20000) < 10) {
@@ -1113,7 +1110,8 @@ bool CutSpreader::try_place_macro(ClusterBlockId blk,
                                   int nx,
                                   int ny,
                                   std::priority_queue<std::pair<int, ClusterBlockId>>& remaining) {
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
+    const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
+    const auto& grid_blocks = ap->placer_loc_vars_ref_.grid_blocks();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     for (auto sub_t : subtiles_at_location[nx][ny]) {
@@ -1137,7 +1135,7 @@ bool CutSpreader::try_place_macro(ClusterBlockId blk,
 
             // if the target location has a logic block, ensure it's not part of a macro
             // because a macro placed before the current one has higher priority (longer chain)
-            ClusterBlockId bound = place_ctx.get_grid_blocks().block_at_location(target);
+            ClusterBlockId bound = grid_blocks.block_at_location(target);
             if (bound != EMPTY_BLOCK_ID && imacro(bound) != NO_MACRO) {
                 placement_impossible = true;
                 break;
@@ -1146,7 +1144,7 @@ bool CutSpreader::try_place_macro(ClusterBlockId blk,
             targets.emplace_back(visit_blk, target);
             if (macro_head(visit_blk) == visit_blk) { // if visit_blk is the head block of the macro
                 // push all macro members to visit queue along with their calculated positions
-                const std::vector<t_pl_macro_member>& members = place_ctx.pl_macros[imacro(blk)].members;
+                const std::vector<t_pl_macro_member>& members = pl_macros[imacro(blk)].members;
                 for (auto member = members.begin() + 1; member != members.end(); ++member) {
                     t_pl_loc mloc = target + member->offset; // calculate member_loc using (head blk location + offset)
                     visit.emplace(member->blk_index, mloc);
@@ -1156,7 +1154,7 @@ bool CutSpreader::try_place_macro(ClusterBlockId blk,
 
         if (!placement_impossible) { // if placement is possible, apply this placement
             for (auto& target : targets) {
-                ClusterBlockId bound = place_ctx.get_grid_blocks().block_at_location(target.second);
+                ClusterBlockId bound = grid_blocks.block_at_location(target.second);
                 if (bound != EMPTY_BLOCK_ID) {
                     // if target location has a logic block, displace it and put it in remaining queue to be placed later
                     unbind_tile(target.second);

vpr/src/place/place.cpp

@@ -722,8 +722,9 @@ void try_place(const Netlist<>& net_list,
 #ifdef ENABLE_ANALYTIC_PLACE
     // Analytic placer: When enabled, skip most of the annealing and go straight to quench
     // TODO: refactor goto label.
-    if (placer_opts.enable_analytic_placer)
+    if (placer_opts.enable_analytic_placer) {
         skip_anneal = true;
+    }
 #endif /* ENABLE_ANALYTIC_PLACE */
 
     //RL agent state definition
@@ -2142,7 +2143,7 @@ static int check_block_placement_consistency(const PlaceLocVars& place_loc_vars)
 int check_macro_placement_consistency(const PlaceLocVars& place_loc_vars) {
     const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
     const auto& block_locs = place_loc_vars.block_locs();
-    const GridBlock grid_blocks = place_loc_vars.grid_blocks();
+    const auto& grid_blocks = place_loc_vars.grid_blocks();
 
     int error = 0;