rename place_loc_vars args to blk_loc_registry

Author: soheilshahrouz

vpr/src/base/read_place.h

@@ -17,15 +17,15 @@ struct t_block_loc;
  */
 std::string read_place(const char* net_file,
                        const char* place_file,
-                       BlkLocRegistry& place_loc_vars,
+                       BlkLocRegistry& blk_loc_registry,
                        bool verify_file_hashes,
                        const DeviceGrid& grid);
 
 /**
  * This function is used to read a constraints file that specifies the desired locations of blocks.
  */
 void read_constraints(const char* constraints_file,
-                      BlkLocRegistry& place_loc_vars);
+                      BlkLocRegistry& blk_loc_registry);
 
 /**
  * This function prints out a place file.

vpr/src/base/vpr_context.h

@@ -385,7 +385,7 @@ struct PackingMultithreadingContext : public Context {
 struct PlacementContext : public Context {
   private:
     /**
-     * Determines if place_loc_vars_ can be accessed by calling getter methods.
+     * Determines if blk_loc_registry_ can be accessed by calling getter methods.
      * This flag should be set to false at the beginning of the placement stage,
      * and set to true at the end of placement. This ensures that variables that
      * are subject to change during placement are kept local to the placement stage.
@@ -410,7 +410,7 @@ struct PlacementContext : public Context {
     const BlkLocRegistry& blk_loc_registry() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_; }
 
     /**
-     * @brief Makes place_loc_vars_ inaccessible through the getter methods.
+     * @brief Makes blk_loc_registry_ inaccessible through the getter methods.
      *
      * This method should be called at the beginning of the placement stage to
      * guarantee that the placement stage code does not access block location variables
@@ -419,7 +419,7 @@ struct PlacementContext : public Context {
     void lock_loc_vars() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); loc_vars_are_accessible_ = false; }
 
     /**
-     * @brief Makes place_loc_vars_ accessible through the getter methods.
+     * @brief Makes blk_loc_registry_ accessible through the getter methods.
      *
      * This method should be called at the end of the placement stage to
      * make the block location information accessible for subsequent stages.

vpr/src/draw/draw.cpp

@@ -570,7 +570,7 @@ void free_draw_structs() {
 #endif /* NO_GRAPHICS */
 }
 
-void init_draw_coords(float width_val, const BlkLocRegistry& place_loc_vars) {
+void init_draw_coords(float width_val, const BlkLocRegistry& blk_loc_registry) {
 #ifndef NO_GRAPHICS
     /* Load the arrays containing the left and bottom coordinates of the clbs   *
      * forming the FPGA.  tile_width_val sets the width and height of a drawn    *
@@ -583,7 +583,7 @@ void init_draw_coords(float width_val, const BlkLocRegistry& place_loc_vars) {
     /* Store a reference to block location variables so that other drawing
      * functions can access block location information without accessing
      * the global placement state, which is inaccessible during placement.*/
-    set_graphics_place_loc_vars_ref(place_loc_vars);
+    set_graphics_blk_loc_registry_ref(blk_loc_registry);
 
     if (!draw_state->show_graphics && !draw_state->save_graphics
         && draw_state->graphics_commands.empty())
@@ -642,7 +642,7 @@ void init_draw_coords(float width_val, const BlkLocRegistry& place_loc_vars) {
                                                  * draw_height});
 #else
     (void)width_val;
-    (void)place_loc_vars;
+    (void)blk_loc_registry;
 #endif /* NO_GRAPHICS */
 }
 
@@ -1008,7 +1008,7 @@ static void highlight_blocks(double x, double y) {
     }
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     VTR_ASSERT(clb_index != EMPTY_BLOCK_ID);
 
@@ -1052,7 +1052,7 @@ ClusterBlockId get_cluster_block_id_from_xy_loc(double x, double y) {
     ClusterBlockId clb_index = EMPTY_BLOCK_ID;
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
+    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
 
     /// determine block ///
     ezgl::rectangle clb_bbox;

vpr/src/draw/draw_basic.cpp

@@ -103,7 +103,7 @@ void drawplace(ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
+    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
 
     ClusterBlockId bnum;
     int num_sub_tiles;
@@ -230,7 +230,7 @@ void drawnets(ezgl::renderer* g) {
 
     ClusterBlockId b1, b2;
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     float transparency_factor;
     float NET_ALPHA = draw_state->net_alpha;
@@ -804,7 +804,7 @@ void draw_placement_macros(ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
 
     auto& place_ctx = g_vpr_ctx.placement();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     for (const t_pl_macro& pl_macro : place_ctx.pl_macros) {
 
@@ -1187,7 +1187,7 @@ void draw_crit_path_elements(const std::vector<tatum::TimingPath>& paths, const
 }
 
 int get_timing_path_node_layer_num(tatum::NodeId node) {
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
     auto& atom_ctx = g_vpr_ctx.atom();
 
     AtomPinId atom_pin = atom_ctx.lookup.tnode_atom_pin(node);
@@ -1420,7 +1420,7 @@ void draw_block_pin_util() {
 
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     std::map<t_physical_tile_type_ptr, size_t> total_input_pins;
     std::map<t_physical_tile_type_ptr, size_t> total_output_pins;

vpr/src/draw/draw_global.cpp

@@ -29,7 +29,7 @@ static t_draw_coords draw_coords;
 /**
  * @brief Stores a reference to a PlaceLocVars to be used in the graphics code.
  */
-static std::optional<std::reference_wrapper<const BlkLocRegistry>> place_loc_vars_ref;
+static std::optional<std::reference_wrapper<const BlkLocRegistry>> blk_loc_registry_ref;
 
 /*********************** Accessor Subroutines Definition ********************/
 
@@ -45,12 +45,12 @@ t_draw_state* get_draw_state_vars() {
     return &draw_state;
 }
 
-void set_graphics_place_loc_vars_ref(const BlkLocRegistry& place_loc_vars) {
-    place_loc_vars_ref = std::ref(place_loc_vars);
+void set_graphics_blk_loc_registry_ref(const BlkLocRegistry& blk_loc_registry) {
+    blk_loc_registry_ref = std::ref(blk_loc_registry);
 }
 
-const BlkLocRegistry& get_graphics_place_loc_vars_ref() {
-    return place_loc_vars_ref->get();
+const BlkLocRegistry& get_graphics_blk_loc_registry_ref() {
+    return blk_loc_registry_ref->get();
 }
 
 #endif // NO_GRAPHICS

vpr/src/draw/draw_global.h

@@ -35,15 +35,15 @@ t_draw_state* get_draw_state_vars();
  * global stage in place_ctx until the end of placement. After the placement is
  * done, the reference should point to the global state stored in place_ctx.
  *
- * @param place_loc_vars The PlaceLocVars that the reference will point to.
+ * @param blk_loc_registry The PlaceLocVars that the reference will point to.
  */
-void set_graphics_place_loc_vars_ref(const BlkLocRegistry& place_loc_vars);
+void set_graphics_blk_loc_registry_ref(const BlkLocRegistry& blk_loc_registry);
 
 /**
  * @brief Returns the reference to placement block location variables.
  * @return A const reference to placement block location variables.
  */
-const BlkLocRegistry& get_graphics_place_loc_vars_ref();
+const BlkLocRegistry& get_graphics_blk_loc_registry_ref();
 
 #endif // NO_GRAPHICS
 

vpr/src/draw/draw_searchbar.cpp

@@ -110,7 +110,7 @@ void draw_highlight_blocks_color(t_logical_block_type_ptr type,
 
     t_draw_state* draw_state = get_draw_state_vars();
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     for (k = 0; k < type->pb_type->num_pins; k++) { /* Each pin on a CLB */
         ClusterNetId net_id = cluster_ctx.clb_nlist.block_net(blk_id, k);

vpr/src/draw/draw_types.cpp

@@ -14,7 +14,7 @@
 ezgl::color t_draw_state::block_color(ClusterBlockId blk) const {
     if (use_default_block_color_[blk]) {
         auto& cluster_ctx = g_vpr_ctx.clustering();
-        const auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+        const auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
         t_physical_tile_type_ptr tile_type = nullptr;
         if (block_locs.empty()) { //No placement, pick best match
@@ -87,7 +87,7 @@ float t_draw_coords::get_tile_height() {
 }
 
 ezgl::rectangle t_draw_coords::get_pb_bbox(ClusterBlockId clb_index, const t_pb_graph_node& pb_gnode) {
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     return get_pb_bbox(block_locs[clb_index].loc.layer,
@@ -152,7 +152,7 @@ ezgl::rectangle t_draw_coords::get_absolute_pb_bbox(const ClusterBlockId clb_ind
 }
 
 ezgl::rectangle t_draw_coords::get_absolute_clb_bbox(const ClusterBlockId clb_index, const t_logical_block_type_ptr block_type) {
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     t_pl_loc loc = block_locs[clb_index].loc;
     return get_pb_bbox(loc.layer, loc.x, loc.y, loc.sub_tile, block_type);

vpr/src/draw/intra_logic_block.cpp

@@ -152,7 +152,7 @@ void draw_internal_draw_subblk(ezgl::renderer* g) {
     }
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
+    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
 
     int total_layer_num = device_ctx.grid.get_num_layers();
 
@@ -273,7 +273,7 @@ draw_internal_calc_coords(int type_descrip_index, t_pb_graph_node* pb_graph_node
     float sub_tile_x, sub_tile_y;
     float child_width, child_height;
     auto& device_ctx = g_vpr_ctx.device();
-    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
+    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
 
     // get the bbox for this pb type
     ezgl::rectangle& pb_bbox = get_draw_coords_vars()->blk_info.at(type_descrip_index).get_pb_bbox_ref(*pb_graph_node);
@@ -341,7 +341,7 @@ static void draw_internal_pb(const ClusterBlockId clb_index, t_pb* pb, const ezg
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
 
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     t_selected_sub_block_info& sel_sub_info = get_selected_sub_block_info();
 
@@ -559,7 +559,7 @@ void draw_logical_connections(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
 
     auto& atom_ctx = g_vpr_ctx.atom();
-    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     g->set_line_dash(ezgl::line_dash::none);
 
@@ -652,7 +652,7 @@ void find_pin_index_at_model_scope(const AtomPinId pin_id, const AtomBlockId blk
                 int atom_port_index = atom_ctx.nlist.pin_port_bit(pin_id);
 
                 //The index of this pin in the model is the pins counted so-far
-                //(i.e. accross previous ports) plus the index in the port
+                //(i.e. across previous ports) plus the index in the port
                 *pin_index = pin_cnt + atom_port_index;
             }
 

vpr/src/draw/manual_moves.cpp

@@ -149,7 +149,7 @@ void calculate_cost_callback(GtkWidget* /*widget*/, GtkWidget* grid) {
 bool is_manual_move_legal(ClusterBlockId block_id, t_pl_loc to) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
-    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
+    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
 
     //if the block is not found
     if ((!cluster_ctx.clb_nlist.valid_block_id(ClusterBlockId(block_id)))) {
@@ -175,14 +175,14 @@ bool is_manual_move_legal(ClusterBlockId block_id, t_pl_loc to) {
     //If the destination block is user constrained, abort this swap
     ClusterBlockId b_to = grid_blocks.block_at_location(to);
     if (b_to != INVALID_BLOCK_ID && b_to != EMPTY_BLOCK_ID) {
-        if (get_graphics_place_loc_vars_ref().block_locs()[b_to].is_fixed) {
+        if (get_graphics_blk_loc_registry_ref().block_locs()[b_to].is_fixed) {
             invalid_breakpoint_entry_window("Block is fixed");
             return false;
         }
     }
 
     //If the block requested is already in that location.
-    t_pl_loc current_block_loc = get_graphics_place_loc_vars_ref().block_locs()[block_id].loc;
+    t_pl_loc current_block_loc = get_graphics_blk_loc_registry_ref().block_locs()[block_id].loc;
     if (to.x == current_block_loc.x && to.y == current_block_loc.y && to.sub_tile == current_block_loc.sub_tile) {
         invalid_breakpoint_entry_window("The block is currently in this location");
         return false;

vpr/src/draw/search_bar.cpp

@@ -283,7 +283,7 @@ void auto_zoom_rr_node(RRNodeId rr_node_id) {
 void highlight_cluster_block(ClusterBlockId clb_index) {
     char msg[vtr::bufsize];
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
+    const auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
 
     /// determine block ///
     ezgl::rectangle clb_bbox;

vpr/src/place/analytic_placer.cpp

@@ -129,8 +129,8 @@ constexpr int HEAP_STALLED_ITERATIONS_STOP = 15;
  * Placement & device info is accessed via g_vpr_ctx
  */
 
-AnalyticPlacer::AnalyticPlacer(BlkLocRegistry& place_loc_vars)
-    : placer_loc_vars_ref_(place_loc_vars) {
+AnalyticPlacer::AnalyticPlacer(BlkLocRegistry& blk_loc_registry)
+    : placer_loc_vars_ref_(blk_loc_registry) {
     //Eigen::initParallel();
 
     // TODO: PlacerHeapCfg should be externally configured & supplied

vpr/src/place/centroid_move_generator.cpp

@@ -49,7 +49,7 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& cluster_ctx = g_vpr_ctx.clustering();
     const auto& place_move_ctx = placer_ctx.move();
-    const auto& place_loc_vars = placer_ctx.blk_loc_registry();
+    const auto& blk_loc_registry = placer_ctx.blk_loc_registry();
 
     // Find a movable block based on blk_type
     ClusterBlockId b_from = propose_block_to_move(placer_opts,
@@ -84,17 +84,17 @@ e_create_move CentroidMoveGenerator::propose_move(t_pl_blocks_to_be_moved& block
     t_pl_loc to, centroid;
 
     /* Calculate the centroid location*/
-    calculate_centroid_loc(b_from, false, centroid, nullptr, noc_attraction_enabled_, noc_attraction_w_, place_loc_vars);
+    calculate_centroid_loc(b_from, false, centroid, nullptr, noc_attraction_enabled_, noc_attraction_w_, blk_loc_registry);
 
     // Centroid location is not necessarily a valid location, and the downstream location expects a valid
     // layer for the centroid location. So if the layer is not valid, we set it to the same layer as from loc.
     centroid.layer = (centroid.layer < 0) ? from.layer : centroid.layer;
     /* Find a location near the weighted centroid_loc */
-    if (!find_to_loc_centroid(cluster_from_type, from, centroid, range_limiters, to, b_from, place_loc_vars)) {
+    if (!find_to_loc_centroid(cluster_from_type, from, centroid, range_limiters, to, b_from, blk_loc_registry)) {
         return e_create_move::ABORT;
     }
 
-    e_create_move create_move = ::create_move(blocks_affected, b_from, to, place_loc_vars);
+    e_create_move create_move = ::create_move(blocks_affected, b_from, to, blk_loc_registry);
 
     //Check that all the blocks affected by the move would still be in a legal floorplan region after the swap
     if (!floorplan_legal(blocks_affected)) {

vpr/src/place/critical_uniform_move_generator.cpp

@@ -15,7 +15,7 @@ e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved
     auto& cluster_ctx = g_vpr_ctx.clustering();
     const auto& placer_ctx = placer_ctx_.get();
     const auto& block_locs = placer_ctx.block_locs();
-    const auto& place_loc_vars = placer_ctx.blk_loc_registry();
+    const auto& blk_loc_registry = placer_ctx.blk_loc_registry();
 
     ClusterNetId net_from;
     int pin_from;
@@ -41,11 +41,11 @@ e_create_move CriticalUniformMoveGenerator::propose_move(t_pl_blocks_to_be_moved
 
     t_pl_loc to;
     to.layer = from.layer;
-    if (!find_to_loc_uniform(cluster_from_type, rlim, from, to, b_from, place_loc_vars)) {
+    if (!find_to_loc_uniform(cluster_from_type, rlim, from, to, b_from, blk_loc_registry)) {
         return e_create_move::ABORT;
     }
 
-    e_create_move create_move = ::create_move(blocks_affected, b_from, to, place_loc_vars);
+    e_create_move create_move = ::create_move(blocks_affected, b_from, to, blk_loc_registry);
 
     //Check that all the blocks affected by the move would still be in a legal floorplan region after the swap
     if (!floorplan_legal(blocks_affected)) {