apply PR comments

Author: soheilshahrouz

libs/libarchfpga/src/device_grid.h

@@ -137,10 +137,10 @@ class DeviceGrid {
         }
 
         bool operator==(const loc_const_iterator& o) const {
-            return g_ == o.g_
+            return loc_.x == o.loc_.x
+                   && loc_.y == o.loc_.y
                    && loc_.layer_num == o.loc_.layer_num
-                   && loc_.x == o.loc_.x
-                   && loc_.y == o.loc_.y;
+                   && g_ == o.g_;
         }
         bool operator!=(const loc_const_iterator& o) const { return !(*this == o); }
 

vpr/src/base/setup_grid.cpp

@@ -35,7 +35,7 @@ static std::vector<t_logical_block_type_ptr> grid_overused_resources(const Devic
 static bool grid_satisfies_instance_counts(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts, float maximum_utilization);
 static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t width, size_t height, bool warn_out_of_range = true, const std::vector<t_logical_block_type_ptr>& limiting_resources = std::vector<t_logical_block_type_ptr>());
 
-///@brief Check grid is valid
+///@brief Check if grid is valid
 static void check_grid(const DeviceGrid& grid);
 
 static void set_grid_block_type(int priority,
@@ -118,7 +118,7 @@ DeviceGrid create_device_grid(const std::string& layout_name, const std::vector<
             return build_device_grid(*layout, layout->width, layout->height);
         }
     } else {
-        //Use the specified device
+        // Use the specified device
         auto cmp = [&](const t_grid_def& grid_def) {
             return grid_def.name == layout_name;
         };

vpr/src/draw/ui_setup.cpp

@@ -246,7 +246,7 @@ void search_setup(ezgl::application* app) {
     gtk_entry_completion_set_match_func(wildcardComp, (GtkEntryCompletionMatchFunc)customMatchingFunction, NULL, NULL);
 }
 
-/*
+/**
  * @brief connects critical path button to its cbk fn
  *
  * @param app ezgl application
@@ -255,7 +255,7 @@ void crit_path_button_setup(ezgl::application* app) {
 
     t_draw_state* draw_state = get_draw_state_vars();
 
-    //Toggle Critical Path
+    // Toggle Critical Path
     GtkSwitch* toggle_nets_switch = GTK_SWITCH(app->get_object("ToggleCritPath"));
     g_signal_connect(toggle_nets_switch, "state-set", G_CALLBACK(toggle_crit_path_cbk), app);
 
@@ -265,7 +265,7 @@ void crit_path_button_setup(ezgl::application* app) {
     setup_checkbox_button("ToggleCritPathDelays", app, &draw_state->show_crit_path_delays);
 }
 
-/*
+/**
  * @brief Hides or displays critical path routing / routing delay UI elements
  *
  * @param app ezgl app

vpr/src/place/delay_model/compute_delta_delays_utils.cpp

@@ -403,7 +403,7 @@ static bool verify_delta_delays(const vtr::NdMatrix<float, 4>& delta_delays) {
 
                     if (delta_delay < 0.) {
                         VPR_ERROR(VPR_ERROR_PLACE,
-                                  "Found invalid negative delay %g for delta [%d,%d,%d,%d]",
+                                  "Found invalid negative delay %g for delta [%u,%u,%u,%u]",
                                   delta_delay, from_layer_num, to_layer_num, x, y);
                     }
                 }

vpr/src/place/place_util.cpp

@@ -125,16 +125,16 @@ void alloc_and_load_legal_placement_locations(std::vector<std::vector<std::vecto
     int num_tile_types = device_ctx.physical_tile_types.size();
     legal_pos.resize(num_tile_types);
 
-    for (const auto& type : device_ctx.physical_tile_types) {
+    for (const t_physical_tile_type& type : device_ctx.physical_tile_types) {
         legal_pos[type.index].resize(type.sub_tiles.size());
     }
 
     // load the legal placement positions
     for (const t_physical_tile_loc tile_loc : device_ctx.grid.all_locations()) {
-        auto tile = device_ctx.grid.get_physical_type(tile_loc);
+        t_physical_tile_type_ptr tile = device_ctx.grid.get_physical_type(tile_loc);
 
-        for (const auto& sub_tile : tile->sub_tiles) {
-            auto capacity = sub_tile.capacity;
+        for (const t_sub_tile& sub_tile : tile->sub_tiles) {
+            const t_capacity_range& capacity = sub_tile.capacity;
 
             for (int k = 0; k < capacity.total(); k++) {
                 // If this is the anchor position of a block, add it to the legal_pos.

vpr/src/route/overuse_report.cpp

@@ -241,10 +241,8 @@ static void report_overused_ipin_opin(std::ostream& os,
         os << "On Tile Pin"
            << "\n";
     } else {
-        auto pb_type_name = get_pb_graph_node_from_pin_physical_num(device_ctx.grid.get_physical_type(grid_loc),
-                                                                    rr_graph.node_ptc_num(node_id))
-                                ->pb_type->name;
-        auto pb_pin = get_pb_pin_from_pin_physical_num(physical_type, rr_graph.node_ptc_num(node_id));
+        const char* pb_type_name = get_pb_graph_node_from_pin_physical_num(physical_type, rr_graph.node_ptc_num(node_id)) ->pb_type->name;
+        const t_pb_graph_pin* pb_pin = get_pb_pin_from_pin_physical_num(physical_type, rr_graph.node_ptc_num(node_id));
         os << "Intra-Tile Pin - Port : " << pb_pin->port->name << " - PB Type : " << std::string(pb_type_name) << "\n";
     }
     print_block_pins_nets(os,

vpr/src/route/router_lookahead/router_lookahead_compressed_map.cpp

@@ -203,7 +203,7 @@ static void fill_in_missing_compressed_lookahead_entries(const std::map<int, std
         chan_index = 1;
     }
 
-    auto& device_ctx = g_vpr_ctx.device();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
     const int grid_width = static_cast<int>(device_ctx.grid.width());
     const int grid_height = static_cast<int>(device_ctx.grid.height());
     const int grid_layers = static_cast<int>(device_ctx.grid.get_num_layers());

vpr/src/util/vpr_utils.cpp

@@ -1847,13 +1847,12 @@ std::vector<int> get_cluster_netlist_intra_tile_classes_at_loc(const t_physical_
         if (grid_block.is_sub_tile_empty(tile_loc, abs_cap)) {
             continue;
         }
-        auto cluster_blk_id = grid_block.block_at_location({tile_loc, abs_cap});
+        ClusterBlockId cluster_blk_id = grid_block.block_at_location({tile_loc, abs_cap});
         VTR_ASSERT(cluster_blk_id != ClusterBlockId::INVALID());
 
-        auto primitive_classes = get_cluster_internal_class_pairs(atom_lookup,
-                                                                  cluster_blk_id);
+        std::vector<int> primitive_classes = get_cluster_internal_class_pairs(atom_lookup, cluster_blk_id);
         // Initialize SINK/SOURCE nodes and connect them to their respective pins
-        for (auto class_num : primitive_classes) {
+        for (int class_num : primitive_classes) {
             class_num_vec.push_back(class_num);
         }
     }
@@ -1878,13 +1877,13 @@ std::vector<int> get_cluster_netlist_intra_tile_pins_at_loc(const t_physical_til
         if (grid_block.is_sub_tile_empty(tile_loc, abs_cap)) {
             continue;
         }
-        auto cluster_blk_id = grid_block.block_at_location({tile_loc, abs_cap});
+        ClusterBlockId cluster_blk_id = grid_block.block_at_location({tile_loc, abs_cap});
         VTR_ASSERT(cluster_blk_id != ClusterBlockId::INVALID());
 
         cluster_internal_pins = get_cluster_internal_pins(cluster_blk_id);
-        const auto& cluster_pin_chains = pin_chains_num[cluster_blk_id];
-        const auto& cluster_chain_sinks = pin_chains[cluster_blk_id].chain_sink;
-        const auto& cluster_pin_chain_idx = pin_chains[cluster_blk_id].pin_chain_idx;
+        const std::unordered_set<int>& cluster_pin_chains = pin_chains_num[cluster_blk_id];
+        const std::vector<int>& cluster_chain_sinks = pin_chains[cluster_blk_id].chain_sink;
+        const std::vector<int>& cluster_pin_chain_idx = pin_chains[cluster_blk_id].pin_chain_idx;
         // remove common elements between cluster_pin_chains.
         for (int pin : cluster_internal_pins) {
             auto it = cluster_pin_chains.find(pin);