fix a few issues to be compliant with break before binary operators

Author: soheilshahrouz

libs/libvtrutil/src/vtr_prefix_sum.h

@@ -94,11 +94,12 @@ class PrefixSum1D {
      * @brief Construct the 1D prefix sum from a vector.
      */
     PrefixSum1D(std::vector<T> vals, T zero = T())
-            : PrefixSum1D(vals.size(),
-                          [&](size_t x) noexcept {
-                            return vals[x];
-                          },
-                          zero) {}
+        : PrefixSum1D(
+            vals.size(),
+            [&](size_t x) noexcept {
+                return vals[x];
+            },
+            zero) {}
 
     /**
      * @brief Get the sum of all values in the original array of values between
@@ -123,7 +124,7 @@ class PrefixSum1D {
         return prefix_sum_[upper_x + 1] - prefix_sum_[lower_x];
     }
 
-private:
+  private:
     /**
      * @brief The 1D prefix sum of the original array of values.
      *
@@ -213,10 +214,10 @@ class PrefixSum2D {
         // to (x - 1, y - 1) inclusive.
         for (size_t x = 1; x < w + 1; x++) {
             for (size_t y = 1; y < h + 1; y++) {
-                prefix_sum_[x][y] = prefix_sum_[x - 1][y] +
-                                    prefix_sum_[x][y - 1] +
-                                    lookup(x - 1, y - 1) -
-                                    prefix_sum_[x - 1][y - 1];
+                prefix_sum_[x][y] = prefix_sum_[x - 1][y]
+                                    + prefix_sum_[x][y - 1]
+                                    + lookup(x - 1, y - 1)
+                                    - prefix_sum_[x - 1][y - 1];
             }
         }
     }
@@ -225,12 +226,13 @@ class PrefixSum2D {
      * @brief Constructs a 2D prefix sum from a 2D grid of values.
      */
     PrefixSum2D(const vtr::NdMatrix<T, 2>& vals, T zero = T())
-            : PrefixSum2D(vals.dim_size(0),
-                          vals.dim_size(1),
-                          [&](size_t x, size_t y) {
-                            return vals[x][y];
-                          },
-                          zero) {}
+        : PrefixSum2D(
+            vals.dim_size(0),
+            vals.dim_size(1),
+            [&](size_t x, size_t y) {
+                return vals[x][y];
+            },
+            zero) {}
 
     /**
      * @brief Get the sum of all values in the original grid of values between
@@ -261,9 +263,10 @@ class PrefixSum2D {
         // Note: all of these are offset by 1 since the first row and column
         //       are all zeros. This allows us to avoid bounds checking when
         //       lower_x or lower_y are 0.
-        return prefix_sum_[upper_x + 1][upper_y + 1] - prefix_sum_[lower_x][upper_y + 1]
-                                                     - prefix_sum_[upper_x + 1][lower_y]
-                                                     + prefix_sum_[lower_x][lower_y];
+        return prefix_sum_[upper_x + 1][upper_y + 1]
+               - prefix_sum_[lower_x][upper_y + 1]
+               - prefix_sum_[upper_x + 1][lower_y]
+               + prefix_sum_[lower_x][lower_y];
     }
 
   private:
@@ -280,4 +283,3 @@ class PrefixSum2D {
 };
 
 } // namespace vtr
-

vpr/src/analytical_place/ap_netlist.cpp

@@ -59,18 +59,12 @@ void APNetlist::set_block_loc(const APBlockId id, const APFixedBlockLoc& loc) {
     VTR_ASSERT_SAFE(valid_block_id(id));
 
     // Check that the location is fixed; if all dims are unfixed then it is not fixed.
-    if (loc.x == APFixedBlockLoc::UNFIXED_DIM &&
-        loc.y == APFixedBlockLoc::UNFIXED_DIM &&
-        loc.sub_tile == APFixedBlockLoc::UNFIXED_DIM &&
-        loc.layer_num == APFixedBlockLoc::UNFIXED_DIM)
+    if (loc.x == APFixedBlockLoc::UNFIXED_DIM && loc.y == APFixedBlockLoc::UNFIXED_DIM && loc.sub_tile == APFixedBlockLoc::UNFIXED_DIM && loc.layer_num == APFixedBlockLoc::UNFIXED_DIM)
         return;
 
     // Ensure that the block is fixed to a single position on the grid (x, y, layer).
     // sub-tile is allowed to be unfixed.
-    VTR_ASSERT(loc.x != APFixedBlockLoc::UNFIXED_DIM &&
-               loc.y != APFixedBlockLoc::UNFIXED_DIM &&
-               loc.layer_num != APFixedBlockLoc::UNFIXED_DIM &&
-               "AP: Currently, AP assumes block is locked down to a single position on the device grid.");
+    VTR_ASSERT(loc.x != APFixedBlockLoc::UNFIXED_DIM && loc.y != APFixedBlockLoc::UNFIXED_DIM && loc.layer_num != APFixedBlockLoc::UNFIXED_DIM && "AP: Currently, AP assumes block is locked down to a single position on the device grid.");
 
     block_locs_[id] = loc;
     block_mobilities_[id] = APBlockMobility::FIXED;
@@ -207,4 +201,3 @@ bool APNetlist::validate_net_sizes_impl(size_t /*num_nets*/) const {
     // No AP-specific net data to check
     return true;
 }
-

vpr/src/analytical_place/partial_legalizer.cpp

@@ -97,10 +97,7 @@ static std::unordered_set<FlatPlacementBinId> get_direct_neighbors_of_bin(
     // the bounding box. We need to ensure that the bin represents a tile (not
     // part of a tile). If it did represent part of a tile, this algorithm
     // would need to change.
-    VTR_ASSERT_DEBUG(static_cast<double>(bl_x) == bin_region.bottom_left().x() &&
-                     static_cast<double>(bl_y) == bin_region.bottom_left().y() &&
-                     static_cast<double>(bin_width) == bin_region.width() &&
-                     static_cast<double>(bin_height) == bin_region.height());
+    VTR_ASSERT_DEBUG(static_cast<double>(bl_x) == bin_region.bottom_left().x() && static_cast<double>(bl_y) == bin_region.bottom_left().y() && static_cast<double>(bin_width) == bin_region.width() && static_cast<double>(bin_height) == bin_region.height());
 
     double placeable_region_width, placeable_region_height, placeable_region_depth;
     std::tie(placeable_region_width, placeable_region_height, placeable_region_depth) = density_manager.get_overall_placeable_region_size();
@@ -251,8 +248,7 @@ void FlowBasedLegalizer::compute_neighbors_of_bin(FlatPlacementBinId src_bin_id,
             q.push(dir_neighbor_bin_id);
         }
         // Check if all of the models have been found in all directions.
-        all_models_found_in_all_directions = all_up_found && all_down_found &&
-                                             all_left_found && all_right_found;
+        all_models_found_in_all_directions = all_up_found && all_down_found && all_left_found && all_right_found;
     }
 
     // Assign the results into the neighbors of the bin.
@@ -437,7 +433,7 @@ std::vector<std::vector<FlatPlacementBinId>> FlowBasedLegalizer::get_paths(
     const PrimitiveVector& starting_bin_supply = get_bin_supply(src_bin_id);
     while (!queue.empty() && demand < starting_bin_supply) {
         // Pop the current bin off the queue.
-        std::vector<FlatPlacementBinId> &p = queue.front();
+        std::vector<FlatPlacementBinId>& p = queue.front();
         FlatPlacementBinId tail_bin_id = p.back();
         // Look over its neighbors
         for (FlatPlacementBinId neighbor_bin_id : bin_neighbors_[tail_bin_id]) {
@@ -500,8 +496,7 @@ std::vector<std::vector<FlatPlacementBinId>> FlowBasedLegalizer::get_paths(
              starting_bin_supply.manhattan_norm());
 
     // Sort the paths in increasing order of cost.
-    std::sort(paths.begin(), paths.end(), [&](const std::vector<FlatPlacementBinId>& a,
-                                              const std::vector<FlatPlacementBinId>& b) {
+    std::sort(paths.begin(), paths.end(), [&](const std::vector<FlatPlacementBinId>& a, const std::vector<FlatPlacementBinId>& b) {
         return bin_cost[a.back()] < bin_cost[b.back()];
     });
 
@@ -730,11 +725,11 @@ struct SpreadingWindow {
 } // namespace
 
 BiPartitioningPartialLegalizer::BiPartitioningPartialLegalizer(
-                                                const APNetlist& netlist,
-                                                std::shared_ptr<FlatPlacementDensityManager> density_manager,
-                                                int log_verbosity)
-            : PartialLegalizer(netlist, log_verbosity)
-            , density_manager_(density_manager) {}
+    const APNetlist& netlist,
+    std::shared_ptr<FlatPlacementDensityManager> density_manager,
+    int log_verbosity)
+    : PartialLegalizer(netlist, log_verbosity)
+    , density_manager_(density_manager) {}
 
 /**
  * @brief Identify spreading windows which contain overfilled bins on the device
@@ -750,8 +745,8 @@ BiPartitioningPartialLegalizer::BiPartitioningPartialLegalizer(
  *         spreading easier.
  */
 static std::vector<SpreadingWindow> identify_non_overlapping_windows(
-                                const APNetlist& netlist,
-                                FlatPlacementDensityManager& density_manager) {
+    const APNetlist& netlist,
+    FlatPlacementDensityManager& density_manager) {
     // Identify overfilled bins
     const std::unordered_set<FlatPlacementBinId>& overfilled_bins = density_manager.get_overfilled_bins();
 
@@ -763,27 +758,27 @@ static std::vector<SpreadingWindow> identify_non_overlapping_windows(
     size_t width, height, layers;
     std::tie(width, height, layers) = density_manager.get_overall_placeable_region_size();
     vtr::PrefixSum2D<float> capacity_prefix_sum(width, height, [&](size_t x, size_t y) {
-                FlatPlacementBinId bin_id = density_manager.get_bin(x, y, 0);
-                // For now we take the L1 norm of the bin divided by its area.
-                // The L1 norm is just a count of the number of primitives that
-                // can fit into the bin (without caring for primitive type). We
-                // divide by area such that large bins (1x4 for example) get
-                // normalized to 1x1 regions.
-                const vtr::Rect<double>& bin_region = density_manager.flat_placement_bins().bin_region(bin_id);
-                float bin_area = bin_region.width() * bin_region.height();
-                return density_manager.get_bin_capacity(bin_id).manhattan_norm() / bin_area;
-            });
+        FlatPlacementBinId bin_id = density_manager.get_bin(x, y, 0);
+        // For now we take the L1 norm of the bin divided by its area.
+        // The L1 norm is just a count of the number of primitives that
+        // can fit into the bin (without caring for primitive type). We
+        // divide by area such that large bins (1x4 for example) get
+        // normalized to 1x1 regions.
+        const vtr::Rect<double>& bin_region = density_manager.flat_placement_bins().bin_region(bin_id);
+        float bin_area = bin_region.width() * bin_region.height();
+        return density_manager.get_bin_capacity(bin_id).manhattan_norm() / bin_area;
+    });
 
     // Create a prefix sum for the utilization.
     // The utilization of the bins will change between routing iterations, so
     // this prefix sum must be recomputed.
     vtr::PrefixSum2D<float> utilization_prefix_sum(width, height, [&](size_t x, size_t y) {
-                FlatPlacementBinId bin_id = density_manager.get_bin(x, y, 0);
-                // This is computed the same way as the capacity prefix sum above.
-                const vtr::Rect<double>& bin_region = density_manager.flat_placement_bins().bin_region(bin_id);
-                float bin_area = bin_region.width() * bin_region.height();
-                return density_manager.get_bin_utilization(bin_id).manhattan_norm() / bin_area;
-            });
+        FlatPlacementBinId bin_id = density_manager.get_bin(x, y, 0);
+        // This is computed the same way as the capacity prefix sum above.
+        const vtr::Rect<double>& bin_region = density_manager.flat_placement_bins().bin_region(bin_id);
+        float bin_area = bin_region.width() * bin_region.height();
+        return density_manager.get_bin_utilization(bin_id).manhattan_norm() / bin_area;
+    });
 
     // 1) For each of the overfilled bins, create and store a minimum window.
     // TODO: This is a very simple algorithm which currently only uses the number
@@ -808,8 +803,7 @@ static std::vector<SpreadingWindow> identify_non_overlapping_windows(
 
             // If the region did not grow, exit. This is a maximal bin.
             // TODO: Maybe print warning.
-            if (new_xmin == region.xmin() && new_xmax == region.xmax() &&
-                new_ymin == region.ymin() && new_ymax == region.ymax()) {
+            if (new_xmin == region.xmin() && new_xmax == region.xmax() && new_ymin == region.ymin() && new_ymax == region.ymax()) {
                 break;
             }
 
@@ -1040,15 +1034,15 @@ void BiPartitioningPartialLegalizer::legalize(PartialPlacement& p_placement) {
         if (partition_dir == e_partition_dir::VERTICAL) {
             // Sort the blocks in the window by the x coordinate.
             std::sort(window.contained_blocks.begin(), window.contained_blocks.end(), [&](APBlockId a, APBlockId b) {
-                        return p_placement.block_x_locs[a] < p_placement.block_x_locs[b];
-                    });
+                return p_placement.block_x_locs[a] < p_placement.block_x_locs[b];
+            });
 
         } else {
             VTR_ASSERT(partition_dir == e_partition_dir::HORIZONTAL);
             // Sort the blocks in the window by the y coordinate.
             std::sort(window.contained_blocks.begin(), window.contained_blocks.end(), [&](APBlockId a, APBlockId b) {
-                        return p_placement.block_y_locs[a] < p_placement.block_y_locs[b];
-                    });
+                return p_placement.block_y_locs[a] < p_placement.block_y_locs[b];
+            });
         }
 
         // Find the pivot block position.
@@ -1092,4 +1086,3 @@ void BiPartitioningPartialLegalizer::legalize(PartialPlacement& p_placement) {
     // Export the legalized placement to the partial placement.
     density_manager_->export_placement_from_bins(p_placement);
 }
-

vpr/src/base/load_flat_place.cpp

@@ -159,8 +159,8 @@ FlatPlacementInfo read_flat_placement(const std::string& read_flat_place_file_pa
 
         // Check if this atom already has a flat placement
         // Using the x_pos and y_pos as identifiers.
-        if (flat_placement_info.blk_x_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS ||
-            flat_placement_info.blk_y_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS) {
+        if (flat_placement_info.blk_x_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS
+            || flat_placement_info.blk_y_pos[atom_blk_id] != FlatPlacementInfo::UNDEFINED_POS) {
             VTR_LOG_WARN("Flat placement file, line %d, atom %s has multiple "
                          "placement definitions in the flat placement file.\n",
                          line_num, atom_netlist.block_name(atom_blk_id).c_str());
@@ -202,12 +202,12 @@ bool load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
 }
 
 void log_flat_placement_reconstruction_info(
-                            const FlatPlacementInfo& flat_placement_info,
-                            const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs,
-                            const vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>>& atoms_lookup,
-                            const AtomLookup& cluster_of_atom_lookup,
-                            const AtomNetlist& atom_netlist,
-                            const ClusteredNetlist& clustered_netlist) {
+    const FlatPlacementInfo& flat_placement_info,
+    const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs,
+    const vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>>& atoms_lookup,
+    const AtomLookup& cluster_of_atom_lookup,
+    const AtomNetlist& atom_netlist,
+    const ClusteredNetlist& clustered_netlist) {
     // Go through each cluster and see how many clusters have atoms that
     // do not belong (cluster is imperfect).
     unsigned num_imperfect_clusters = 0;
@@ -243,10 +243,7 @@ void log_flat_placement_reconstruction_info(
             // want to be in this cluster.
             // FIXME: This should take into account large blocks somehow, just
             //        being 0.5 tiles away may not be sufficient.
-            if (std::abs(centroid_x - flat_placement_info.blk_x_pos[atom_blk_id]) > 0.5f ||
-                std::abs(centroid_y - flat_placement_info.blk_y_pos[atom_blk_id]) > 0.5f ||
-                std::abs(centroid_layer - flat_placement_info.blk_layer[atom_blk_id]) > 0.5f ||
-                std::abs(centroid_sub_tile - flat_placement_info.blk_sub_tile[atom_blk_id]) > 0.5f) {
+            if (std::abs(centroid_x - flat_placement_info.blk_x_pos[atom_blk_id]) > 0.5f || std::abs(centroid_y - flat_placement_info.blk_y_pos[atom_blk_id]) > 0.5f || std::abs(centroid_layer - flat_placement_info.blk_layer[atom_blk_id]) > 0.5f || std::abs(centroid_sub_tile - flat_placement_info.blk_sub_tile[atom_blk_id]) > 0.5f) {
                 num_imperfect_clusters++;
                 break;
             }
@@ -298,13 +295,13 @@ void log_flat_placement_reconstruction_info(
         // TODO: Make this debug option of higher verbosity. Helpful for
         //       debugging flat placement reconstruction.
         /*
-        VTR_LOG("%s %d %d %d %d\n",
-                g_vpr_ctx.atom().netlist().block_name(atom_blk_id).c_str(),
-                clb_loc.loc.x,
-                clb_loc.loc.y,
-                clb_loc.loc.layer,
-                clb_loc.loc.sub_tile);
-        */
+         * VTR_LOG("%s %d %d %d %d\n",
+         * g_vpr_ctx.atom().netlist().block_name(atom_blk_id).c_str(),
+         * clb_loc.loc.x,
+         * clb_loc.loc.y,
+         * clb_loc.loc.layer,
+         * clb_loc.loc.sub_tile);
+         */
     }
 
     // Log the flat placement reconstruction info.
@@ -322,4 +319,3 @@ void log_flat_placement_reconstruction_info(
     VTR_LOG("\tPercent of atoms misplaced from the flat placement: %f\n",
             static_cast<float>(num_atoms_missplaced) / static_cast<float>(num_atoms));
 }
-