replace accesses to placement context in graphics with accesses to its reference holder

Author: soheilshahrouz

vpr/src/draw/draw.cpp

@@ -1004,7 +1004,7 @@ static void highlight_blocks(double x, double y) {
     }
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
 
     VTR_ASSERT(clb_index != EMPTY_BLOCK_ID);
 
@@ -1048,7 +1048,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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
 
     /// determine block ///
     ezgl::rectangle clb_bbox;
@@ -1071,7 +1071,7 @@ ClusterBlockId get_cluster_block_id_from_xy_loc(double x, double y) {
                 // iterate over sub_blocks
                 const auto& type = device_ctx.grid.get_physical_type({i, j, layer_num});
                 for (int k = 0; k < type->capacity; ++k) {
-                    clb_index = place_ctx.get_grid_blocks().block_at_location({i, j, k, layer_num});
+                    clb_index = grid_blocks.block_at_location({i, j, k, layer_num});
                     if (clb_index != EMPTY_BLOCK_ID) {
                         clb_bbox = draw_coords->get_absolute_clb_bbox(clb_index,
                                                                       cluster_ctx.clb_nlist.block_type(clb_index));

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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
 
     ClusterBlockId bnum;
     int num_sub_tiles;
@@ -136,7 +136,7 @@ void drawplace(ezgl::renderer* g) {
 
                     for (int k = 0; k < num_sub_tiles; ++k) {
                         /* Look at the tile at start of large block */
-                        bnum = place_ctx.get_grid_blocks().block_at_location({i, j, k, layer_num});
+                        bnum = grid_blocks.block_at_location({i, j, k, layer_num});
                         /* Fill background for the clb. Do not fill if "show_blk_internal"
                          * is toggled.
                          */
@@ -159,7 +159,7 @@ void drawplace(ezgl::renderer* g) {
                                                                                            block_color);
                         }
                         // No color specified at this location; use the block color.
-                        if (current_loc_is_highlighted == false) {
+                        if (!current_loc_is_highlighted) {
                             if (bnum != EMPTY_BLOCK_ID) {
                                 block_color = draw_state->block_color(bnum);
                             } else {
@@ -230,7 +230,7 @@ void drawnets(ezgl::renderer* g) {
 
     ClusterBlockId b1, b2;
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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 = place_ctx.block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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_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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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

@@ -15,7 +15,7 @@ ezgl::color t_draw_state::block_color(ClusterBlockId blk) const {
     if (use_default_block_color_[blk]) {
 
         auto& cluster_ctx = g_vpr_ctx.clustering();
-        auto& block_locs = g_vpr_ctx.placement().block_locs();
+        auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
 
         t_physical_tile_type_ptr tile_type = nullptr;
         if (block_locs.empty()) { //No placement, pick best match
@@ -88,7 +88,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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
     return get_pb_bbox(block_locs[clb_index].loc.layer,
@@ -153,7 +153,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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
 
     int total_layer_num = device_ctx.grid.get_num_layers();
 
@@ -175,14 +175,16 @@ void draw_internal_draw_subblk(ezgl::renderer* g) {
                     int num_sub_tiles = type->capacity;
                     for (int k = 0; k < num_sub_tiles; ++k) {
                         /* Don't draw if block is empty. */
-                        if (place_ctx.get_grid_blocks().block_at_location({i, j, k, layer_num}) == EMPTY_BLOCK_ID || place_ctx.get_grid_blocks().block_at_location({i, j, k, layer_num}) == INVALID_BLOCK_ID)
+                        if (grid_blocks.block_at_location({i, j, k, layer_num}) == EMPTY_BLOCK_ID || grid_blocks.block_at_location({i, j, k, layer_num}) == INVALID_BLOCK_ID) {
                             continue;
+                        }
 
                         /* Get block ID */
-                        ClusterBlockId bnum = place_ctx.get_grid_blocks().block_at_location({i, j, k, layer_num});
+                        ClusterBlockId bnum = grid_blocks.block_at_location({i, j, k, layer_num});
                         /* Safety check, that physical blocks exists in the CLB */
-                        if (cluster_ctx.clb_nlist.block_pb(bnum) == nullptr)
+                        if (cluster_ctx.clb_nlist.block_pb(bnum) == nullptr) {
                             continue;
+                        }
                         draw_internal_pb(bnum, cluster_ctx.clb_nlist.block_pb(bnum), ezgl::rectangle({0, 0}, 0, 0), cluster_ctx.clb_nlist.block_type(bnum), g);
                     }
                 }
@@ -271,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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = get_graphics_place_loc_vars_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);
@@ -289,7 +291,7 @@ draw_internal_calc_coords(int type_descrip_index, t_pb_graph_node* pb_graph_node
     int capacity = device_ctx.physical_tile_types[type_descrip_index].capacity;
     // TODO: this is a hack - should be fixed for the layer_num
     const auto& type = device_ctx.grid.get_physical_type({1, 0, 0});
-    if (capacity > 1 && device_ctx.grid.width() > 0 && device_ctx.grid.height() > 0 && place_ctx.get_grid_blocks().get_usage({1, 0, 0}) != 0
+    if (capacity > 1 && device_ctx.grid.width() > 0 && device_ctx.grid.height() > 0 && grid_blocks.get_usage({1, 0, 0}) != 0
         && type_descrip_index == type->index) {
         // that should test for io blocks, and setting capacity_divisor > 1
         // will squish every thing down
@@ -339,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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
 
     t_selected_sub_block_info& sel_sub_info = get_selected_sub_block_info();
 
@@ -557,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 = g_vpr_ctx.placement().block_locs();
+    auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
 
     g->set_line_dash(ezgl::line_dash::none);
 

vpr/src/draw/manual_moves.cpp

@@ -148,8 +148,8 @@ 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& place_ctx = g_vpr_ctx.placement();
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& grid_blocks = get_graphics_place_loc_vars_ref().grid_blocks();
 
     //if the block is not found
     if ((!cluster_ctx.clb_nlist.valid_block_id(ClusterBlockId(block_id)))) {
@@ -173,16 +173,16 @@ bool is_manual_move_legal(ClusterBlockId block_id, t_pl_loc to) {
     }
 
     //If the destination block is user constrained, abort this swap
-    auto b_to = place_ctx.get_grid_blocks().block_at_location(to);
+    ClusterBlockId b_to = grid_blocks.block_at_location(to);
     if (b_to != INVALID_BLOCK_ID && b_to != EMPTY_BLOCK_ID) {
-        if (place_ctx.block_locs()[b_to].is_fixed) {
+        if (get_graphics_place_loc_vars_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 = place_ctx.block_locs()[block_id].loc;
+    t_pl_loc current_block_loc = get_graphics_place_loc_vars_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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& block_locs = get_graphics_place_loc_vars_ref().block_locs();
 
     /// determine block ///
     ezgl::rectangle clb_bbox;
@@ -302,7 +302,7 @@ void highlight_cluster_block(ClusterBlockId clb_index) {
         draw_highlight_blocks_color(cluster_ctx.clb_nlist.block_type(clb_index), clb_index);
         sprintf(msg, "Block #%zu (%s) at (%d, %d) selected.",
                 size_t(clb_index), cluster_ctx.clb_nlist.block_name(clb_index).c_str(),
-                place_ctx.block_locs()[clb_index].loc.x, place_ctx.block_locs()[clb_index].loc.y);
+                block_locs[clb_index].loc.x, block_locs[clb_index].loc.y);
     }
 
     application.update_message(msg);