add comments and code cleaning

Author: soheilshahrouz

vpr/src/base/load_flat_place.cpp

@@ -9,9 +9,10 @@ static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
 
 static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
                                std::vector<AtomBlockId>& atoms) {
+    const auto& atom_ctx = g_vpr_ctx.atom();
+    const auto& block_locs = g_vpr_ctx.placement().block_locs();
 
-    auto& atom_ctx = g_vpr_ctx.atom();
-    t_pl_loc loc = g_vpr_ctx.placement().block_locs()[iblk].loc;
+    t_pl_loc loc = block_locs[iblk].loc;
     size_t bnum = size_t(iblk);
 
     for (auto atom : atoms) {
@@ -26,7 +27,6 @@ static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
 
 /* prints a flat placement file */
 void print_flat_placement(const char* flat_place_file) {
-
     FILE* fp;
 
     ClusterAtomsLookup atoms_lookup;

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();
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = g_vpr_ctx.placement().get_grid_blocks();
 
     t_trace* head_ptr = nullptr;
     t_trace* tptr = nullptr;
@@ -337,12 +337,10 @@ static void process_nodes(const Netlist<>& net_list, std::ifstream& fp, ClusterN
                     int width_offset = device_ctx.grid.get_width_offset({x, y, layer_num});
                     int height_offset = device_ctx.grid.get_height_offset({x, y, layer_num});
                     auto physical_tile = device_ctx.grid.get_physical_type({x, y, layer_num});
-                    const t_sub_tile* sub_tile;
-                    int sub_tile_rel_cap;
-                    std::tie(sub_tile, sub_tile_rel_cap) = get_sub_tile_from_pin_physical_num(physical_tile, pin_num);
+                    auto [sub_tile, sub_tile_rel_cap] = get_sub_tile_from_pin_physical_num(physical_tile, pin_num);
                     int sub_tile_offset = sub_tile->capacity.low + sub_tile_rel_cap;
 
-                    ClusterBlockId iblock = place_ctx.get_grid_blocks().block_at_location({x - width_offset, y - height_offset, sub_tile_offset, layer_num});
+                    ClusterBlockId iblock = grid_blocks.block_at_location({x - width_offset, y - height_offset, sub_tile_offset, layer_num});
                     VTR_ASSERT(iblock);
 
                     const t_pb_graph_pin* pb_pin;
@@ -571,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) {
-    auto& place_ctx = g_vpr_ctx.placement();
+    const auto& grid_blocks = g_vpr_ctx.placement().get_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();
@@ -644,13 +642,11 @@ void print_route(const Netlist<>& net_list,
                         int pin_num = rr_graph.node_pin_num(inode);
                         int xoffset = device_ctx.grid.get_width_offset({ilow, jlow, layer_num});
                         int yoffset = device_ctx.grid.get_height_offset({ilow, jlow, layer_num});
-                        const t_sub_tile* sub_tile;
-                        int sub_tile_rel_cap;
-                        std::tie(sub_tile, sub_tile_rel_cap) = get_sub_tile_from_pin_physical_num(physical_tile, pin_num);
+                        auto [sub_tile, sub_tile_rel_cap] = get_sub_tile_from_pin_physical_num(physical_tile, pin_num);
                         int sub_tile_offset = sub_tile->capacity.low + sub_tile_rel_cap;
 
-                        ClusterBlockId iblock = place_ctx.get_grid_blocks().block_at_location({ilow - xoffset, jlow - yoffset,
-                                                                                               sub_tile_offset, layer_num});
+                        ClusterBlockId iblock = grid_blocks.block_at_location({ilow - xoffset, jlow - yoffset,
+                                                                               sub_tile_offset, layer_num});
                         VTR_ASSERT(iblock);
                         const t_pb_graph_pin* pb_pin;
                         if (is_pin_on_tile(physical_tile, pin_num)) {

vpr/src/base/stats.cpp

@@ -1,12 +1,9 @@
-#include <cstdio>
-#include <cstring>
 #include <cmath>
 #include <set>
 
 #include "route_tree.h"
 #include "vtr_assert.h"
 #include "vtr_log.h"
-#include "vtr_math.h"
 #include "vtr_ndmatrix.h"
 
 #include "vpr_types.h"
@@ -55,12 +52,10 @@ void routing_stats(const Netlist<>& net_list,
                    enum e_directionality directionality,
                    int wire_to_ipin_switch,
                    bool is_flat) {
-    float area, used_area;
-
     auto& device_ctx = g_vpr_ctx.device();
     auto& rr_graph = device_ctx.rr_graph;
     auto& cluster_ctx = g_vpr_ctx.clustering();
-    auto& block_locs = g_vpr_ctx.placement().block_locs();
+    const auto& block_locs = g_vpr_ctx.placement().block_locs();
 
     int num_rr_switch = rr_graph.num_rr_switches();
 
@@ -70,7 +65,7 @@ void routing_stats(const Netlist<>& net_list,
 
     VTR_LOG("Logic area (in minimum width transistor areas, excludes I/Os and empty grid tiles)...\n");
 
-    area = 0;
+    float area = 0;
     for (int layer_num = 0; layer_num < device_ctx.grid.get_num_layers(); layer_num++) {
         for (int i = 0; i < (int)device_ctx.grid.width(); i++) {
             for (int j = 0; j < (int)device_ctx.grid.height(); j++) {
@@ -93,7 +88,7 @@ void routing_stats(const Netlist<>& net_list,
     /* Todo: need to add pitch of routing to blocks with height > 3 */
     VTR_LOG("\tTotal logic block area (Warning, need to add pitch of routing to blocks with height > 3): %g\n", area);
 
-    used_area = 0;
+    float used_area = 0;
     for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
         t_pl_loc block_loc = block_locs[blk_id].loc;
         auto type = physical_tile_type(block_loc);
@@ -123,26 +118,20 @@ void routing_stats(const Netlist<>& net_list,
  *        and net length in the routing.
  */
 void length_and_bends_stats(const Netlist<>& net_list, bool is_flat) {
-    int bends, total_bends, max_bends;
-    int length, total_length, max_length;
-    int segments, total_segments, max_segments;
-    float av_bends, av_length, av_segments;
-    int num_global_nets, num_clb_opins_reserved, num_absorbed_nets;
-
-    bool is_absorbed;
-
-    max_bends = 0;
-    total_bends = 0;
-    max_length = 0;
-    total_length = 0;
-    max_segments = 0;
-    total_segments = 0;
-    num_global_nets = 0;
-    num_clb_opins_reserved = 0;
-    num_absorbed_nets = 0;
+    int max_bends = 0;
+    int total_bends = 0;
+    int max_length = 0;
+    int total_length = 0;
+    int max_segments = 0;
+    int total_segments = 0;
+    int num_global_nets = 0;
+    int num_clb_opins_reserved = 0;
+    int num_absorbed_nets = 0;
 
     for (auto net_id : net_list.nets()) {
         if (!net_list.net_is_ignored(net_id) && net_list.net_sinks(net_id).size() != 0) { /* Globals don't count. */
+            int bends, length, segments;
+            bool is_absorbed;
             get_num_bends_and_length(net_id, &bends, &length, &segments, &is_absorbed);
 
             total_bends += bends;
@@ -165,20 +154,20 @@ void length_and_bends_stats(const Netlist<>& net_list, bool is_flat) {
         }
     }
 
-    av_bends = (float)total_bends / (float)((int)net_list.nets().size() - num_global_nets);
+    float av_bends = (float)total_bends / (float)((int)net_list.nets().size() - num_global_nets);
     VTR_LOG("\n");
     VTR_LOG("Average number of bends per net: %#g  Maximum # of bends: %d\n", av_bends, max_bends);
     VTR_LOG("\n");
 
-    av_length = (float)total_length / (float)((int)net_list.nets().size() - num_global_nets);
+    float av_length = (float)total_length / (float)((int)net_list.nets().size() - num_global_nets);
     VTR_LOG("Number of global nets: %d\n", num_global_nets);
     VTR_LOG("Number of routed nets (nonglobal): %d\n", (int)net_list.nets().size() - num_global_nets);
     VTR_LOG("Wire length results (in units of 1 clb segments)...\n");
     VTR_LOG("\tTotal wirelength: %d, average net length: %#g\n", total_length, av_length);
     VTR_LOG("\tMaximum net length: %d\n", max_length);
     VTR_LOG("\n");
 
-    av_segments = (float)total_segments / (float)((int)net_list.nets().size() - num_global_nets);
+    float av_segments = (float)total_segments / (float)((int)net_list.nets().size() - num_global_nets);
     VTR_LOG("Wire length results in terms of physical segments...\n");
     VTR_LOG("\tTotal wiring segments used: %d, average wire segments per net: %#g\n", total_segments, av_segments);
     VTR_LOG("\tMaximum segments used by a net: %d\n", max_segments);
@@ -425,9 +414,7 @@ void print_wirelen_prob_dist(bool is_flat) {
  * (i.e. the clock when it is marked global).
  */
 void print_lambda() {
-    int ipin;
     int num_inputs_used = 0;
-    float lambda;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& block_locs = g_vpr_ctx.placement().block_locs();
@@ -437,7 +424,7 @@ void print_lambda() {
         auto type = physical_tile_type(block_loc);
         VTR_ASSERT(type != nullptr);
         if (!is_io_type(type)) {
-            for (ipin = 0; ipin < type->num_pins; ipin++) {
+            for (int ipin = 0; ipin < type->num_pins; ipin++) {
                 if (get_pin_type_from_pin_physical_num(type, ipin) == RECEIVER) {
                     ClusterNetId net_id = cluster_ctx.clb_nlist.block_net(blk_id, ipin);
                     if (net_id != ClusterNetId::INVALID())                 /* Pin is connected? */
@@ -448,7 +435,7 @@ void print_lambda() {
         }
     }
 
-    lambda = (float)num_inputs_used / (float)cluster_ctx.clb_nlist.blocks().size();
+    float lambda = (float)num_inputs_used / (float)cluster_ctx.clb_nlist.blocks().size();
     VTR_LOG("Average lambda (input pins used per clb) is: %g\n", lambda);
 }
 

vpr/src/base/vpr_context.h

@@ -384,7 +384,18 @@ struct PackingMultithreadingContext : public Context {
  */
 struct PlacementContext : public Context {
   private:
+    /**
+     * Determines if place_loc_vars_ 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.
+     */
     bool loc_vars_are_accessible_ = true;
+
+    /**
+     * @brief Stores block location information, which is subject to change during the
+     * placement stage.
+     */
     PlaceLocVars place_loc_vars_;
 
   public:
@@ -398,7 +409,21 @@ struct PlacementContext : public Context {
     PlaceLocVars& mutable_place_loc_vars() { VTR_ASSERT(loc_vars_are_accessible_); return place_loc_vars_; }
     const PlaceLocVars& place_loc_vars() const { VTR_ASSERT(loc_vars_are_accessible_); return place_loc_vars_; }
 
+    /**
+     * @brief Makes place_loc_vars_ 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
+     * stored in the global state.
+     */
     void lock_loc_vars() { loc_vars_are_accessible_ = false; }
+
+    /**
+     * @brief Makes place_loc_vars_ 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.
+     */
     void unlock_loc_vars() { loc_vars_are_accessible_ = true; }
 
     ///@brief The pl_macros array stores all the placement macros (usually carry chains).

vpr/src/base/vpr_types.cpp

@@ -562,7 +562,7 @@ void t_cluster_placement_stats::free_primitives() {
 int PlaceLocVars::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const {
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    // Get the logical pin index of pin within it's logical block type
+    // Get the logical pin index of pin within its logical block type
     ClusterPinId pin_id = cluster_ctx.clb_nlist.net_pin(net_id, net_pin_index);
 
     return this->tile_pin_index(pin_id);

vpr/src/base/vpr_types.h

@@ -922,11 +922,11 @@ class PlaceLocVars {
     inline const vtr::vector_map<ClusterPinId, int>& physical_pins() const { return physical_pins_; }
     inline vtr::vector_map<ClusterPinId, int>& mutable_physical_pins() { return physical_pins_; }
 
-    //Returns the physical pin of the tile, related to the given ClusterPinId
+    ///@brief Returns the physical pin of the tile, related to the given ClusterPinId
     inline int tile_pin_index(const ClusterPinId pin) const { return physical_pins_[pin]; }
 
-     //Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
-    int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
+     ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
+    inline int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
 };
 
 ///@brief Names of various files

vpr/src/draw/draw.cpp

@@ -580,6 +580,9 @@ void init_draw_coords(float width_val, const PlaceLocVars& place_loc_vars) {
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
+    /* 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);
 
     if (!draw_state->show_graphics && !draw_state->save_graphics