make format

Author: soheilshahrouz

vpr/src/base/vpr_types.cpp

@@ -9,7 +9,6 @@ t_ext_pin_util_targets::t_ext_pin_util_targets(float default_in_util, float defa
 
 t_ext_pin_util_targets::t_ext_pin_util_targets(const std::vector<std::string>& specs)
     : t_ext_pin_util_targets(1., 1.) {
-
     if (specs.size() == 1 && specs[0] == "auto") {
         //No user-specified pin utilizations, infer them automatically.
         //
@@ -168,7 +167,6 @@ t_pack_high_fanout_thresholds::t_pack_high_fanout_thresholds(int threshold)
 
 t_pack_high_fanout_thresholds::t_pack_high_fanout_thresholds(const std::vector<std::string>& specs)
     : t_pack_high_fanout_thresholds(128) {
-
     if (specs.size() == 1 && specs[0] == "auto") {
         //No user-specified high fanout thresholds, infer them automatically.
         //

vpr/src/noc/noc_router.cpp

@@ -28,7 +28,6 @@ int NocRouter::get_router_layer_position(void) const {
 }
 
 t_physical_tile_loc NocRouter::get_router_physical_location(void) const {
-
     const int x = get_router_grid_position_x();
     const int y = get_router_grid_position_y();
     const int layer = get_router_layer_position();

vpr/src/noc/noc_router.h

@@ -86,7 +86,6 @@ class NocRouter {
      */
     int get_router_layer_position(void) const;
 
-
     /**
      * @brief Gets the physical location where the the physical router is located
      * @return t_physical_tile_loc that contains x-y coordinates and the layer number

vpr/src/noc/noc_traffic_flows.cpp

@@ -89,7 +89,6 @@ void NocTrafficFlows::finished_noc_traffic_flows_setup(void) {
     int number_of_traffic_flows = noc_traffic_flows.size();
     traffic_flow_routes.resize(number_of_traffic_flows);
 
-
     const int num_flows = get_number_of_traffic_flows();
     double bandwidth_sum = 0.0;
     double inverse_latency_sum = 0.0;

vpr/src/pack/cluster.cpp

@@ -282,7 +282,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_index)->name);
             int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
             update_cluster_stats(istart, clb_index,
-                                 is_clock, //Set of clock nets
+                                 is_clock,  //Set of clock nets
                                  is_global, //Set of global nets (currently all clocks)
                                  packer_opts.global_clocks,
                                  packer_opts.alpha, packer_opts.beta,

vpr/src/pack/cluster_util.cpp

@@ -1594,7 +1594,7 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       attraction_groups);
 
     update_cluster_stats(next_molecule, clb_index,
-                         is_clock, //Set of all clocks
+                         is_clock,  //Set of all clocks
                          is_global, //Set of all global signals (currently clocks)
                          packer_opts.global_clocks, packer_opts.alpha, packer_opts.beta, packer_opts.timing_driven,
                          packer_opts.connection_driven,

vpr/src/pack/pack.cpp

@@ -73,7 +73,7 @@ bool try_pack(t_packer_opts* packer_opts,
     helper_ctx.num_models += count_models(library_models);
 
     is_clock = alloc_and_load_is_clock(packer_opts->global_clocks);
-//    is_global = find_likely_global_ctrl_nets(is_clock);
+    //    is_global = find_likely_global_ctrl_nets(is_clock);
     is_global.insert(is_clock.begin(), is_clock.end());
 
     size_t num_p_inputs = 0;

vpr/src/place/initial_placement.cpp

@@ -1141,16 +1141,13 @@ bool place_one_block(const ClusterBlockId& blk_id,
     return placed_macro;
 }
 
-
 static double calculate_noc_cost(const t_placer_costs& costs, const t_noc_opts& noc_opts) {
     double noc_cost = 0.0;
     noc_cost = (noc_opts.noc_placement_weighting) * ((costs.noc_aggregate_bandwidth_cost * costs.noc_aggregate_bandwidth_cost_norm) + (costs.noc_latency_cost * costs.noc_latency_cost_norm));
     return noc_cost;
 }
 
-
 static bool assess_noc_swap(double delta_cost, double prob) {
-
     if (delta_cost <= 0.0) {
         return true;
     }
@@ -1161,7 +1158,7 @@ static bool assess_noc_swap(double delta_cost, double prob) {
 
     float random_num = vtr::frand();
     if (random_num < prob) {
-        return  true;
+        return true;
     } else {
         return false;
     }
@@ -1192,56 +1189,6 @@ static int findFirstInteger(const std::string& str) {
     }
 }
 
-//void print_noc_grid() {
-//
-//    auto& place_ctx = g_vpr_ctx.placement();
-//    auto& cluster_ctx = g_vpr_ctx.clustering();
-//    auto& noc_ctx = g_vpr_ctx.noc();
-//    const int num_layers = g_vpr_ctx.device().grid.get_num_layers();
-//
-//    const auto router_block_type = cluster_ctx.clb_nlist.block_type(noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist()[0]);
-//    const auto& compressed_noc_grid = place_ctx.compressed_block_grids[router_block_type->index];
-//
-//    static int grid_arr[10][10];
-//
-//    for (int i = 0; i < 10; i++) {
-//        for (int j = 0; j < 10; j++) {
-//            grid_arr[i][j] = -1;
-//        }
-//    }
-//
-//    const std::vector<ClusterBlockId>& router_bids = noc_ctx.noc_traffic_flows_storage.get_router_clusters_in_netlist();
-//
-//    // Iterate over all routers
-//    for (auto router_bid : router_bids) {
-//
-//        std::string router_name = cluster_ctx.clb_nlist.block_name(router_bid);
-//        int router_id = findFirstInteger(router_name);
-//
-//        auto compressed_loc = get_compressed_loc_approx(compressed_noc_grid,place_ctx.block_locs[router_bid].loc, num_layers);
-//
-//        int placed_router_x = compressed_loc[0].x;
-//        int placed_router_y = compressed_loc[0].y;
-//        grid_arr[placed_router_x][placed_router_y] = router_id;
-//    }
-//
-//    std::cout << std::endl;
-//    for (int i = 0; i < 10; i++) {
-//        for (int j = 0; j < 10; j++) {
-//            if (grid_arr[j][i] >= 0) {
-//                std::cout << std::setw(2) << std::setfill('0') << grid_arr[j][i] << "\t";
-//            } else {
-//                std::cout << std::setw(2) << std::setfill(' ') << "X-" << "\t";
-//            }
-//
-//        }
-//        std::cout << std::endl;
-//    }
-//
-//    std::cout << std::endl;
-//
-//}
-
 static void initial_noc_placement(const t_noc_opts& noc_opts) {
     auto& place_ctx = g_vpr_ctx.placement();
     auto& noc_ctx = g_vpr_ctx.noc();
@@ -1257,14 +1204,12 @@ static void initial_noc_placement(const t_noc_opts& noc_opts) {
     std::vector<ClusterBlockId> unfixed_routers;
 
     for (auto router_blk_id : router_blk_ids) {
-
         // The block is fixed and was placed in mark_fixed_blocks()
         if (is_block_placed((router_blk_id))) {
             continue;
         }
 
         if (is_cluster_constrained(router_blk_id)) {
-
             auto block_type = cluster_ctx.clb_nlist.block_type(router_blk_id);
             const PartitionRegion& pr = floorplanning_ctx.cluster_constraints[router_blk_id];
 
@@ -1340,7 +1285,7 @@ static void initial_noc_placement(const t_noc_opts& noc_opts) {
                 break;
             }
         }
-    }   // end for of random router placement
+    } // end for of random router placement
 
     // populate internal data structures to maintain route, bandwidth usage, and latencies
     initial_noc_routing();
@@ -1372,19 +1317,18 @@ static void initial_noc_placement(const t_noc_opts& noc_opts) {
         e_create_move create_move_outcome = e_create_move::ABORT;
         clear_move_blocks(blocks_affected);
         // Shrink the range limit over time
-        float r_lim_decayed = 1.0f + (N_MOVES-i_move) * (max_r_lim/N_MOVES);
+        float r_lim_decayed = 1.0f + (N_MOVES - i_move) * (max_r_lim / N_MOVES);
         create_move_outcome = propose_router_swap(blocks_affected, r_lim_decayed);
 
         if (create_move_outcome != e_create_move::ABORT) {
-
             apply_move_blocks(blocks_affected);
 
             double noc_aggregate_bandwidth_delta_c = 0.0;
             double noc_latency_delta_c = 0.0;
             find_affected_noc_routers_and_update_noc_costs(blocks_affected, noc_aggregate_bandwidth_delta_c, noc_latency_delta_c, noc_opts);
             double delta_cost = (noc_opts.noc_placement_weighting) * (noc_latency_delta_c * costs.noc_latency_cost_norm + noc_aggregate_bandwidth_delta_c * costs.noc_aggregate_bandwidth_cost_norm);
 
-            double prob = starting_prob - i_move*prob_step;
+            double prob = starting_prob - i_move * prob_step;
             bool move_accepted = assess_noc_swap(delta_cost, prob);
 
             if (move_accepted) {
@@ -1396,7 +1340,7 @@ static void initial_noc_placement(const t_noc_opts& noc_opts) {
                 if (costs.cost < checkpoint.get_cost() || !checkpoint.is_valid()) {
                     checkpoint.save_checkpoint(costs.cost);
                 }
-            } else {    // The proposed move is rejected
+            } else { // The proposed move is rejected
                 revert_move_blocks(blocks_affected);
                 revert_noc_traffic_flow_routes(blocks_affected);
             }
@@ -1406,10 +1350,8 @@ static void initial_noc_placement(const t_noc_opts& noc_opts) {
     if (checkpoint.get_cost() < costs.cost) {
         checkpoint.restore_checkpoint(noc_opts, costs);
     }
-
 }
 
-
 void initial_placement(enum e_pad_loc_type pad_loc_type, const char* constraints_file, const t_noc_opts& noc_opts) {
     vtr::ScopedStartFinishTimer timer("Initial Placement");
 

vpr/src/place/move_utils.cpp

@@ -1067,8 +1067,8 @@ bool find_compatible_compressed_loc_in_range(t_logical_block_type_ptr type,
             VTR_ASSERT(to_loc.y <= search_range.ymax);
 
             if (from_loc.x == to_loc.x && from_loc.y == to_loc.y && from_loc.layer_num == to_layer_num) {
-                continue; //Same from/to location -- try again for new y-position
-            } else if (check_empty) {   // Check if the location has at least one empty sub-tile
+                continue;             //Same from/to location -- try again for new y-position
+            } else if (check_empty) { // Check if the location has at least one empty sub-tile
                 t_pl_loc to_uncompressed_loc;
                 compressed_grid_to_loc(type, to_loc, to_uncompressed_loc);
                 const t_physical_tile_loc to_phy_uncompressed_loc{to_uncompressed_loc.x, to_uncompressed_loc.y, to_uncompressed_loc.layer};

vpr/src/place/noc_place_checkpoint.cpp

@@ -2,9 +2,9 @@
 #include "noc_place_checkpoint.h"
 #include "noc_place_utils.h"
 
-RouterPlacementCheckpoint::RouterPlacementCheckpoint() :
-    valid_(false),
-    cost_(std::numeric_limits<double>::infinity()) {
+RouterPlacementCheckpoint::RouterPlacementCheckpoint()
+    : valid_(false)
+    , cost_(std::numeric_limits<double>::infinity()) {
     const auto& noc_ctx = g_vpr_ctx.noc();
 
     // Get all router clusters in the net-list
@@ -41,7 +41,6 @@ void RouterPlacementCheckpoint::restore_checkpoint(const t_noc_opts& noc_opts, t
 
     // Clear all physical routers in placement
     for (const auto& phy_router : noc_phy_routers) {
-
         auto phy_loc = phy_router.get_router_physical_location();
 
         place_ctx.grid_blocks.set_usage(phy_loc, 0);
@@ -59,7 +58,6 @@ void RouterPlacementCheckpoint::restore_checkpoint(const t_noc_opts& noc_opts, t
         }
     }
 
-
     // Place routers based on router_locations_
     for (const auto& router_loc : router_locations_) {
         ClusterBlockId router_blk_id = router_loc.first;
@@ -72,7 +70,7 @@ void RouterPlacementCheckpoint::restore_checkpoint(const t_noc_opts& noc_opts, t
     reinitialize_noc_routing(noc_opts, costs);
 }
 
-bool RouterPlacementCheckpoint::is_valid() const{
+bool RouterPlacementCheckpoint::is_valid() const {
     return valid_;
 }
 

vpr/src/place/noc_place_checkpoint.h

@@ -16,7 +16,7 @@ class RouterPlacementCheckpoint {
     RouterPlacementCheckpoint& operator=(const RouterPlacementCheckpoint& other) = delete;
 
     void save_checkpoint(double cost);
-    void restore_checkpoint(const t_noc_opts& noc_opts,  t_placer_costs& costs);
+    void restore_checkpoint(const t_noc_opts& noc_opts, t_placer_costs& costs);
     bool is_valid() const;
     double get_cost() const;
 };

vpr/src/place/noc_place_utils.cpp

@@ -499,7 +499,6 @@ static bool select_random_router_cluster(ClusterBlockId& b_from, t_pl_loc& from,
 }
 
 e_create_move propose_router_swap(t_pl_blocks_to_be_moved& blocks_affected, float rlim) {
-
     // block ID for the randomly selected router cluster
     ClusterBlockId b_from;
     // current location of the randomly selected router cluster
@@ -534,7 +533,6 @@ e_create_move propose_router_swap(t_pl_blocks_to_be_moved& blocks_affected, floa
 }
 
 e_create_move propose_router_swap_flow_centroid(t_pl_blocks_to_be_moved& blocks_affected) {
-
     auto& noc_ctx = g_vpr_ctx.noc();
     auto& place_ctx = g_vpr_ctx.placement();
     const auto& grid = g_vpr_ctx.device().grid;
@@ -590,7 +588,6 @@ e_create_move propose_router_swap_flow_centroid(t_pl_blocks_to_be_moved& blocks_
         }
     }
 
-
     t_pl_loc centroid_loc(OPEN, OPEN, OPEN, OPEN);
 
     if (acc_weight > 0.0) {
@@ -609,14 +606,10 @@ e_create_move propose_router_swap_flow_centroid(t_pl_blocks_to_be_moved& blocks_
         return e_create_move::ABORT;
     }
 
-
     const auto& physical_type = grid.get_physical_type({centroid_loc.x, centroid_loc.y, centroid_loc.layer});
 
     // If the calculated centroid does not have a compatible type, find a compatible location nearby
     if (!is_tile_compatible(physical_type, cluster_from_type)) {
-
-
-
         //Determine centroid location in the compressed space of the current block
         auto compressed_centroid_loc = get_compressed_loc_approx(compressed_noc_grid,
                                                                  {centroid_loc.x, centroid_loc.y, 0, centroid_loc.layer},
@@ -649,7 +642,7 @@ e_create_move propose_router_swap_flow_centroid(t_pl_blocks_to_be_moved& blocks_
         bool legal = find_compatible_compressed_loc_in_range(cluster_from_type,
                                                              delta_cx,
                                                              compressed_from_loc[0],
-                                                            {min_cx, max_cx, min_cy, max_cy},
+                                                             {min_cx, max_cx, min_cy, max_cy},
                                                              compressed_to_loc,
                                                              false,
                                                              compressed_from_loc[0].layer_num,