apply PR comments

Author: soheilshahrouz

vpr/src/draw/draw.cpp

@@ -580,7 +580,7 @@ void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry) {
     /* 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_blk_loc_registry_ref(blk_loc_registry);
+    draw_state->set_graphics_blk_loc_registry_ref(blk_loc_registry);
 
     if (!draw_state->show_graphics && !draw_state->save_graphics
         && draw_state->graphics_commands.empty())
@@ -1004,8 +1004,8 @@ static void highlight_blocks(double x, double y) {
         return; /* Nothing was found on any layer*/
     }
 
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
     VTR_ASSERT(clb_index != ClusterBlockId::INVALID());
 
@@ -1046,14 +1046,15 @@ static void highlight_blocks(double x, double y) {
 ClusterBlockId get_cluster_block_id_from_xy_loc(double x, double y) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
     t_draw_state* draw_state = get_draw_state_vars();
-    auto clb_index = ClusterBlockId::INVALID();
-    auto& device_ctx = g_vpr_ctx.device();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    const auto& grid_blocks = get_graphics_blk_loc_registry_ref().grid_blocks();
+    const auto& device_ctx = g_vpr_ctx.device();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& grid_blocks = draw_state->get_graphics_blk_loc_registry_ref().grid_blocks();
 
     /// determine block ///
     ezgl::rectangle clb_bbox;
 
+    auto clb_index = ClusterBlockId::INVALID();
+
     //iterate over grid z (layers) first. Start search of the block at the top layer to prioritize highlighting of blocks at higher levels during overlapping of layers.
     for (int layer_num = device_ctx.grid.get_num_layers() - 1; layer_num >= 0; layer_num--) {
         if (!draw_state->draw_layer_display[layer_num].visible) {

vpr/src/draw/draw_basic.cpp

@@ -101,9 +101,9 @@ const std::vector<ezgl::color> kelly_max_contrast_colors = {
 void drawplace(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     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_blk_loc_registry_ref().grid_blocks();
+    const auto& device_ctx = g_vpr_ctx.device();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& grid_blocks = draw_state->get_graphics_blk_loc_registry_ref().grid_blocks();
 
     ClusterBlockId bnum;
     int num_sub_tiles;
@@ -224,12 +224,9 @@ void drawplace(ezgl::renderer* g) {
 void drawnets(ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
     t_draw_coords* draw_coords = get_draw_coords_vars();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
-    ClusterBlockId b1, b2;
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
-
-    float transparency_factor;
     float NET_ALPHA = draw_state->net_alpha;
 
     g->set_line_dash(ezgl::line_dash::none);
@@ -250,7 +247,7 @@ void drawnets(ezgl::renderer* g) {
             continue;
         }
 
-        b1 = cluster_ctx.clb_nlist.net_driver_block(net_id);
+        ClusterBlockId b1 = cluster_ctx.clb_nlist.net_driver_block(net_id);
 
         //The layer of the net driver block
         driver_block_layer_num = block_locs[b1].loc.layer;
@@ -262,7 +259,7 @@ void drawnets(ezgl::renderer* g) {
 
         ezgl::point2d driver_center = draw_coords->get_absolute_clb_bbox(b1, cluster_ctx.clb_nlist.block_type(b1)).center();
         for (ClusterPinId pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
-            b2 = cluster_ctx.clb_nlist.pin_block(pin_id);
+            ClusterBlockId b2 = cluster_ctx.clb_nlist.pin_block(pin_id);
 
             //the layer of the pin block (net sinks)
             sink_block_layer_num =block_locs[b2].loc.layer;
@@ -272,7 +269,7 @@ void drawnets(ezgl::renderer* g) {
             if (!element_visibility.visible) {
                 continue; /* Don't Draw */
             }
-            transparency_factor = element_visibility.alpha;
+            float transparency_factor = element_visibility.alpha;
 
             //Take the highest of the 2 transparency values that the user can select from the UI
             // Compare the current cross layer transparency to the overall Net transparency set by the user.
@@ -800,8 +797,8 @@ 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_blk_loc_registry_ref().block_locs();
+    const auto& place_ctx = g_vpr_ctx.placement();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
     for (const t_pl_macro& pl_macro : place_ctx.pl_macros) {
 
@@ -1184,8 +1181,9 @@ 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_blk_loc_registry_ref().block_locs();
-    auto& atom_ctx = g_vpr_ctx.atom();
+    t_draw_state* draw_state = get_draw_state_vars();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
+    const auto& atom_ctx = g_vpr_ctx.atom();
 
     AtomPinId atom_pin = atom_ctx.lookup.tnode_atom_pin(node);
     AtomBlockId atom_block = atom_ctx.nlist.pin_block(atom_pin);
@@ -1415,9 +1413,9 @@ void draw_block_pin_util() {
     if (draw_state->show_blk_pin_util == DRAW_NO_BLOCK_PIN_UTIL)
         return;
 
-    auto& device_ctx = g_vpr_ctx.device();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
+    const auto& device_ctx = g_vpr_ctx.device();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& block_locs = draw_state->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;
@@ -1475,9 +1473,8 @@ void draw_block_pin_util() {
 }
 
 void draw_reset_blk_colors() {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto blks = cluster_ctx.clb_nlist.blocks();
-    for (auto blk : blks) {
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    for (auto blk : cluster_ctx.clb_nlist.blocks()) {
         draw_reset_blk_color(blk);
     }
 }

vpr/src/draw/draw_global.cpp

@@ -26,15 +26,6 @@ static t_draw_state draw_state;
  */
 static t_draw_coords draw_coords;
 
-/**
- * @brief Stores a reference to a PlaceLocVars to be used in the graphics code.
- * @details This reference let us pass in a currently-being-optimized placement state,
- * rather than using the global placement state in placement context that is valid only once placement is done
- */
-static std::optional<std::reference_wrapper<const BlkLocRegistry>> blk_loc_registry_ref;
-
-static std::optional<std::reference_wrapper<const vtr::vector<NocLinkId, double>>> noc_link_bandwidth_usages_ref;
-
 /*********************** Accessor Subroutines Definition ********************/
 
 /* This accessor function returns pointer to the global variable
@@ -49,20 +40,4 @@ t_draw_state* get_draw_state_vars() {
     return &draw_state;
 }
 
-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_blk_loc_registry_ref() {
-    return blk_loc_registry_ref->get();
-}
-
-void set_noc_link_bandwidth_usages_ref(const vtr::vector<NocLinkId, double>& noc_link_bandwidth_usages) {
-    noc_link_bandwidth_usages_ref = noc_link_bandwidth_usages;
-}
-
-const vtr::vector<NocLinkId, double>& get_noc_link_bandwidth_usages_ref() {
-    return noc_link_bandwidth_usages_ref->get();
-}
-
 #endif // NO_GRAPHICS

vpr/src/draw/draw_global.h

@@ -27,28 +27,6 @@ t_draw_coords* get_draw_coords_vars();
 
 t_draw_state* get_draw_state_vars();
 
-/**
- * @brief Set the reference to placement location variable.
- *
- * During the placement stage, this reference should point to a local object
- * in the placement stage because the placement stage does not change the
- * 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 blk_loc_registry The PlaceLocVars that the reference will point to.
- */
-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_blk_loc_registry_ref();
-
-void set_noc_link_bandwidth_usages_ref(const vtr::vector<NocLinkId, double>& noc_link_bandwidth_usages);
-
-const vtr::vector<NocLinkId, double>& get_noc_link_bandwidth_usages_ref();
-
 #endif // NO_GRAPHICS
 
 #endif

vpr/src/draw/draw_noc.cpp

@@ -74,8 +74,8 @@ void draw_noc(ezgl::renderer* g) {
  */
 void draw_noc_usage(vtr::vector<NocLinkId, ezgl::color>& noc_link_colors) {
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& noc_ctx = g_vpr_ctx.noc();
-    const auto& noc_link_bandwidth_usages = get_noc_link_bandwidth_usages_ref();
+    const auto& noc_ctx = g_vpr_ctx.noc();
+    const auto& noc_link_bandwidth_usages = draw_state->get_noc_link_bandwidth_usages_ref();
 
     // check to see if a color map was already created previously
     if (draw_state->noc_usage_color_map == nullptr) {

vpr/src/draw/draw_searchbar.cpp

@@ -68,7 +68,7 @@
 ezgl::rectangle draw_get_rr_chan_bbox(RRNodeId inode) {
     double left = 0, right = 0, top = 0, bottom = 0;
     t_draw_coords* draw_coords = get_draw_coords_vars();
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     switch (rr_graph.node_type(inode)) {
@@ -105,14 +105,11 @@ ezgl::rectangle draw_get_rr_chan_bbox(RRNodeId inode) {
 
 void draw_highlight_blocks_color(t_logical_block_type_ptr type,
                                  ClusterBlockId blk_id) {
-    int k;
-    ClusterBlockId fanblk;
-
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = get_graphics_blk_loc_registry_ref().block_locs();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
-    for (k = 0; k < type->pb_type->num_pins; k++) { /* Each pin on a CLB */
+    for (int 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);
 
         if (net_id == ClusterNetId::INVALID()) {
@@ -130,27 +127,27 @@ void draw_highlight_blocks_color(t_logical_block_type_ptr type,
                 /* If block already highlighted, de-highlight the fanout. (the deselect case)*/
                 draw_state->net_color[net_id] = ezgl::BLACK;
                 for (auto pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
-                    fanblk = cluster_ctx.clb_nlist.pin_block(pin_id);
+                    ClusterBlockId fanblk = cluster_ctx.clb_nlist.pin_block(pin_id);
                     draw_reset_blk_color(fanblk);
                 }
             } else {
                 /* Highlight the fanout */
                 draw_state->net_color[net_id] = DRIVES_IT_COLOR;
                 for (auto pin_id : cluster_ctx.clb_nlist.net_sinks(net_id)) {
-                    fanblk = cluster_ctx.clb_nlist.pin_block(pin_id);
+                    ClusterBlockId fanblk = cluster_ctx.clb_nlist.pin_block(pin_id);
                     draw_state->set_block_color(fanblk, DRIVES_IT_COLOR);
                 }
             }
         } else { /* This net is fanin to the block. */
             if (draw_state->block_color(blk_id) == SELECTED_COLOR) {
                 /* If block already highlighted, de-highlight the fanin. (the deselect case)*/
                 draw_state->net_color[net_id] = ezgl::BLACK;
-                fanblk = cluster_ctx.clb_nlist.net_driver_block(net_id); /* DRIVER to net */
+                ClusterBlockId fanblk = cluster_ctx.clb_nlist.net_driver_block(net_id); /* DRIVER to net */
                 draw_reset_blk_color(fanblk);
             } else {
                 /* Highlight the fanin */
                 draw_state->net_color[net_id] = DRIVEN_BY_IT_COLOR;
-                fanblk = cluster_ctx.clb_nlist.net_driver_block(net_id); /* DRIVER to net */
+                ClusterBlockId fanblk = cluster_ctx.clb_nlist.net_driver_block(net_id); /* DRIVER to net */
                 draw_state->set_block_color(fanblk, DRIVEN_BY_IT_COLOR);
             }
         }
@@ -211,7 +208,7 @@ void highlight_nets(char* message, RRNodeId hit_node, bool is_flat) {
  */
 void draw_highlight_fan_in_fan_out(const std::set<RRNodeId>& nodes) {
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     for (auto node : nodes) {
@@ -267,8 +264,8 @@ void deselect_all() {
     // as well as clearing the highlighed sub-block
 
     t_draw_state* draw_state = get_draw_state_vars();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& device_ctx = g_vpr_ctx.device();
 
     /* Create some colour highlighting */
     for (auto blk_id : cluster_ctx.clb_nlist.blocks()) {

vpr/src/draw/draw_types.cpp

@@ -87,8 +87,9 @@ 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_blk_loc_registry_ref().block_locs();
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    t_draw_state* draw_state = get_draw_state_vars();
+    const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
 
     return get_pb_bbox(block_locs[clb_index].loc.layer,
                        block_locs[clb_index].loc.x,
@@ -99,7 +100,7 @@ ezgl::rectangle t_draw_coords::get_pb_bbox(ClusterBlockId clb_index, const t_pb_
 }
 
 ezgl::rectangle t_draw_coords::get_pb_bbox(int grid_layer, int grid_x, int grid_y, int sub_block_index, const t_logical_block_type_ptr logical_block_type, const t_pb_graph_node& pb_gnode) {
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     t_draw_pb_type_info& blk_type_info = this->blk_info.at(logical_block_type->index);
 
     ezgl::rectangle result = blk_type_info.get_pb_bbox(pb_gnode);
@@ -118,7 +119,7 @@ ezgl::rectangle t_draw_coords::get_pb_bbox(int grid_layer, int grid_x, int grid_
 }
 
 ezgl::rectangle t_draw_coords::get_pb_bbox(int grid_layer, int grid_x, int grid_y, int sub_block_index, const t_logical_block_type_ptr logical_block_type) {
-    auto& device_ctx = g_vpr_ctx.device();
+    const auto& device_ctx = g_vpr_ctx.device();
     t_draw_pb_type_info& blk_type_info = this->blk_info.at(logical_block_type->index);
 
     auto& pb_gnode = *logical_block_type->pb_graph_head;
@@ -141,7 +142,7 @@ ezgl::rectangle t_draw_coords::get_absolute_pb_bbox(const ClusterBlockId clb_ind
     ezgl::rectangle result = this->get_pb_bbox(clb_index, *pb_gnode);
 
     // go up the graph, adding the parent bboxes to the result,
-    // ie. make it relative to one level higher each time.
+    // i.e. make it relative to one level higher each time.
     while (pb_gnode && !pb_gnode->is_root()) {
         ezgl::rectangle parents_bbox = this->get_pb_bbox(clb_index, *pb_gnode->parent_pb_graph_node);
         result += parents_bbox.bottom_left();
@@ -152,7 +153,8 @@ 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_blk_loc_registry_ref().block_locs();
+    t_draw_state* draw_state = get_draw_state_vars();
+    const auto& block_locs = draw_state->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);