avoid copying Region and PartitionRegion unnecessarily

Author: soheilshahrouz

vpr/src/base/partition.cpp

@@ -1,29 +1,33 @@
 #include "partition.h"
 #include "partition_region.h"
 #include <algorithm>
-#include <vector>
+#include <utility>
 
-const std::string Partition::get_name() {
+const std::string& Partition::get_name() const{
     return name;
 }
 
 void Partition::set_name(std::string _part_name) {
-    name = _part_name;
+    name = std::move(_part_name);
 }
 
-const PartitionRegion Partition::get_part_region() {
+const PartitionRegion& Partition::get_part_region() const {
+    return part_region;
+}
+
+PartitionRegion& Partition::get_mutable_part_region() {
     return part_region;
 }
 
 void Partition::set_part_region(PartitionRegion pr) {
-    part_region = pr;
+    part_region = std::move(pr);
 }
 
-void print_partition(FILE* fp, Partition part) {
-    std::string name = part.get_name();
+void print_partition(FILE* fp, const Partition& part) {
+    const std::string& name = part.get_name();
     fprintf(fp, "partition_name: %s\n", name.c_str());
 
-    PartitionRegion pr = part.get_part_region();
+    const PartitionRegion& pr = part.get_part_region();
 
     print_partition_region(fp, pr);
 }

vpr/src/base/partition.h

@@ -28,7 +28,7 @@ class Partition {
     /**
      *  @brief Get the unique name of the partition
      */
-    const std::string get_name();
+    const std::string& get_name() const;
 
     /**
      * @brief Set the name of the partition
@@ -46,14 +46,19 @@ class Partition {
     /**
      * @brief Get the PartitionRegion (union of rectangular regions) for this partition
      */
-    const PartitionRegion get_part_region();
+    const PartitionRegion& get_part_region() const;
+
+    /**
+     * @brief Get the mutable PartitionRegion (union of rectangular regions) for this partition
+     */
+    PartitionRegion& get_mutable_part_region();
 
   private:
     std::string name;            ///< name of the partition, name will be unique across partitions
     PartitionRegion part_region; ///< the union of regions that the partition can be placed in
 };
 
 ///@brief used to print data from a Partition
-void print_partition(FILE* fp, Partition part);
+void print_partition(FILE* fp, const Partition& part);
 
 #endif /* PARTITION_H */

vpr/src/base/partition_region.cpp

@@ -1,32 +1,34 @@
 #include "partition_region.h"
 #include "region.h"
 
+#include <utility>
+
 void PartitionRegion::add_to_part_region(Region region) {
-    partition_region.push_back(region);
+    regions.push_back(region);
 }
 
-std::vector<Region> PartitionRegion::get_partition_region() {
-    return partition_region;
+const std::vector<Region>& PartitionRegion::get_regions() const {
+    return regions;
 }
 
-std::vector<Region> PartitionRegion::get_partition_region() const {
-    return partition_region;
+std::vector<Region>& PartitionRegion::get_mutable_regions() {
+    return regions;
 }
 
 void PartitionRegion::set_partition_region(std::vector<Region> pr) {
-    partition_region = pr;
+    regions = std::move(pr);
 }
 
-bool PartitionRegion::empty() {
-    return partition_region.size() == 0;
+bool PartitionRegion::empty() const {
+    return regions.empty();
 }
 
-bool PartitionRegion::is_loc_in_part_reg(t_pl_loc loc) {
+bool PartitionRegion::is_loc_in_part_reg(const t_pl_loc& loc) const {
     bool is_in_pr = false;
 
-    for (unsigned int i = 0; i < partition_region.size(); i++) {
-        is_in_pr = partition_region[i].is_loc_in_reg(loc);
-        if (is_in_pr == true) {
+    for (const auto & region : regions) {
+        is_in_pr = region.is_loc_in_reg(loc);
+        if (is_in_pr) {
             break;
         }
     }
@@ -41,12 +43,13 @@ PartitionRegion intersection(const PartitionRegion& cluster_pr, const PartitionR
      * Rectangles are not merged even if it would be possible
      */
     PartitionRegion pr;
+    auto& pr_regions = pr.get_mutable_regions();
     Region intersect_region;
-    for (unsigned int i = 0; i < cluster_pr.partition_region.size(); i++) {
-        for (unsigned int j = 0; j < new_pr.partition_region.size(); j++) {
-            intersect_region = intersection(cluster_pr.partition_region[i], new_pr.partition_region[j]);
+    for (const auto& cluster_region : cluster_pr.get_regions()) {
+        for (const auto& new_region : new_pr.get_regions()) {
+            intersect_region = intersection(cluster_region, new_region);
             if (!intersect_region.empty()) {
-                pr.partition_region.push_back(intersect_region);
+                pr_regions.push_back(intersect_region);
             }
         }
     }
@@ -55,11 +58,11 @@ PartitionRegion intersection(const PartitionRegion& cluster_pr, const PartitionR
 }
 
 void update_cluster_part_reg(PartitionRegion& cluster_pr, const PartitionRegion& new_pr) {
-    Region intersect_region;
     std::vector<Region> int_regions;
-    for (unsigned int i = 0; i < cluster_pr.partition_region.size(); i++) {
-        for (unsigned int j = 0; j < new_pr.partition_region.size(); j++) {
-            intersect_region = intersection(cluster_pr.partition_region[i], new_pr.partition_region[j]);
+
+    for (const auto& cluster_region : cluster_pr.get_regions()) {
+        for (const auto& new_region : new_pr.get_regions()) {
+            Region intersect_region = intersection(cluster_region, new_region);
             if (!intersect_region.empty()) {
                 int_regions.push_back(intersect_region);
             }
@@ -68,14 +71,14 @@ void update_cluster_part_reg(PartitionRegion& cluster_pr, const PartitionRegion&
     cluster_pr.set_partition_region(int_regions);
 }
 
-void print_partition_region(FILE* fp, PartitionRegion pr) {
-    std::vector<Region> part_region = pr.get_partition_region();
+void print_partition_region(FILE* fp, const PartitionRegion& pr) {
+    const std::vector<Region>& regions = pr.get_regions();
 
-    int pr_size = part_region.size();
+    int pr_size = regions.size();
 
     fprintf(fp, "\tNumber of regions in partition is: %d\n", pr_size);
 
-    for (unsigned int i = 0; i < part_region.size(); i++) {
-        print_region(fp, part_region[i]);
+    for (const auto & region : regions) {
+        print_region(fp, region);
     }
 }

vpr/src/base/partition_region.h

@@ -25,8 +25,12 @@ class PartitionRegion {
     /**
      * @brief Return the union of regions
      */
-    std::vector<Region> get_partition_region();
-    std::vector<Region> get_partition_region() const;
+    std::vector<Region>& get_mutable_regions();
+
+    /**
+     * @brief Return the union of regions
+     */
+    const std::vector<Region>& get_regions() const;
 
     /**
      * @brief Set the union of regions
@@ -36,38 +40,38 @@ class PartitionRegion {
     /**
      * @brief Check if the PartitionRegion is empty (meaning there is no constraint on the object the PartitionRegion belongs to)
      */
-    bool empty();
+    bool empty() const;
 
     /**
      * @brief Check if the given location is within the legal bounds of the  PartitionRegion.
      * The location provided is assumed to be valid.
      *
      *   @param loc       The location to be checked
      */
-    bool is_loc_in_part_reg(t_pl_loc loc);
-
-    /**
-     * @brief Global friend function that returns the intersection of two PartitionRegions
-     *
-     *   @param cluster_pr     One of the PartitionRegions to be intersected
-     *   @param new_pr         One of the PartitionRegions to be intersected
-     */
-    friend PartitionRegion intersection(const PartitionRegion& cluster_pr, const PartitionRegion& new_pr);
-
-    /**
-     * @brief Global friend function that updates the PartitionRegion of a cluster with the intersection
-     *        of the cluster PartitionRegion and a new PartitionRegion
-     *
-     *   @param cluster_pr     The cluster PartitionRegion that is to be updated
-     *   @param new_pr         The new PartitionRegion that the cluster PartitionRegion will be intersected with
-     */
-    friend void update_cluster_part_reg(PartitionRegion& cluster_pr, const PartitionRegion& new_pr);
+    bool is_loc_in_part_reg(const t_pl_loc& loc) const;
 
   private:
-    std::vector<Region> partition_region; ///< union of rectangular regions that a partition can be placed in
+    std::vector<Region> regions; ///< union of rectangular regions that a partition can be placed in
 };
 
 ///@brief used to print data from a PartitionRegion
-void print_partition_region(FILE* fp, PartitionRegion pr);
+void print_partition_region(FILE* fp, const PartitionRegion& pr);
+
+/**
+* @brief Global friend function that returns the intersection of two PartitionRegions
+*
+*   @param cluster_pr     One of the PartitionRegions to be intersected
+*   @param new_pr         One of the PartitionRegions to be intersected
+*/
+PartitionRegion intersection(const PartitionRegion& cluster_pr, const PartitionRegion& new_pr);
+
+/**
+* @brief Global friend function that updates the PartitionRegion of a cluster with the intersection
+*        of the cluster PartitionRegion and a new PartitionRegion
+*
+*   @param cluster_pr     The cluster PartitionRegion that is to be updated
+*   @param new_pr         The new PartitionRegion that the cluster PartitionRegion will be intersected with
+*/
+void update_cluster_part_reg(PartitionRegion& cluster_pr, const PartitionRegion& new_pr);
 
 #endif /* PARTITION_REGIONS_H */

vpr/src/base/region.cpp

@@ -42,7 +42,7 @@ bool Region::empty() {
             || layer_num < 0);
 }
 
-bool Region::is_loc_in_reg(t_pl_loc loc) {
+bool Region::is_loc_in_reg(t_pl_loc loc) const {
     bool is_loc_in_reg = false;
     int loc_layer_num = loc.layer;
 
@@ -149,7 +149,7 @@ Region intersection(const Region& r1, const Region& r2) {
     return intersect;
 }
 
-void print_region(FILE* fp, Region region) {
+void print_region(FILE* fp, const Region& region) {
     const auto region_coord = region.get_region_rect();
     const auto region_rect = vtr::Rect<int>(region_coord.xmin, region_coord.ymin, region_coord.xmax, region_coord.ymax);
     fprintf(fp, "\tRegion: \n");

vpr/src/base/region.h

@@ -43,8 +43,7 @@ struct RegionRectCoord {
     bool operator==(const RegionRectCoord& rhs) const {
         vtr::Rect<int> lhs_rect(xmin, ymin, xmax, ymax);
         vtr::Rect<int> rhs_rect(rhs.xmin, rhs.ymin, rhs.xmax, rhs.ymax);
-        return lhs_rect == rhs_rect
-               && layer_num == rhs.layer_num;
+        return (lhs_rect == rhs_rect) && (layer_num == rhs.layer_num);
     }
 };
 
@@ -105,7 +104,7 @@ class Region {
      *
      *   @param loc     The location to be checked
      */
-    bool is_loc_in_reg(t_pl_loc loc);
+    bool is_loc_in_reg(t_pl_loc loc) const;
 
     bool operator==(const Region& reg) const {
         return (reg.get_region_rect() == this->get_region_rect()
@@ -142,7 +141,7 @@ bool do_regions_intersect(Region r1, Region r2);
 Region intersection(const Region& r1, const Region& r2);
 
 ///@brief Used to print data from a Region
-void print_region(FILE* fp, Region region);
+void print_region(FILE* fp, const Region& region);
 
 namespace std {
 template<>

vpr/src/base/vpr_constraints.cpp

@@ -1,7 +1,7 @@
 #include "vpr_constraints.h"
 #include "partition.h"
 
-void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id) {
+void VprConstraints::add_constrained_atom(AtomBlockId blk_id, PartitionId part_id) {
     auto got = constrained_atoms.find(blk_id);
 
     /**
@@ -16,27 +16,29 @@ void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const Partit
     }
 }
 
-PartitionId VprConstraints::get_atom_partition(AtomBlockId blk_id) {
-    PartitionId part_id;
-
+PartitionId VprConstraints::get_atom_partition(AtomBlockId blk_id) const {
     auto got = constrained_atoms.find(blk_id);
 
     if (got == constrained_atoms.end()) {
-        return part_id = PartitionId::INVALID(); ///< atom is not in a partition, i.e. unconstrained
+        return PartitionId::INVALID(); ///< atom is not in a partition, i.e. unconstrained
     } else {
         return got->second;
     }
 }
 
-void VprConstraints::add_partition(Partition part) {
+void VprConstraints::add_partition(const Partition& part) {
     partitions.push_back(part);
 }
 
-Partition VprConstraints::get_partition(PartitionId part_id) {
+const Partition& VprConstraints::get_partition(PartitionId part_id) const {
+    return partitions[part_id];
+}
+
+Partition& VprConstraints::get_mutable_partition(PartitionId part_id) {
     return partitions[part_id];
 }
 
-std::vector<AtomBlockId> VprConstraints::get_part_atoms(PartitionId part_id) {
+std::vector<AtomBlockId> VprConstraints::get_part_atoms(PartitionId part_id) const {
     std::vector<AtomBlockId> part_atoms;
 
     for (auto& it : constrained_atoms) {
@@ -48,18 +50,19 @@ std::vector<AtomBlockId> VprConstraints::get_part_atoms(PartitionId part_id) {
     return part_atoms;
 }
 
-int VprConstraints::get_num_partitions() {
+int VprConstraints::get_num_partitions() const {
     return partitions.size();
 }
 
-PartitionRegion VprConstraints::get_partition_pr(PartitionId part_id) {
-    PartitionRegion pr;
-    pr = partitions[part_id].get_part_region();
-    return pr;
+const PartitionRegion& VprConstraints::get_partition_pr(PartitionId part_id) const {
+    return partitions[part_id].get_part_region();
+}
+
+PartitionRegion& VprConstraints::get_mutable_partition_pr(PartitionId part_id) {
+    return partitions[part_id].get_mutable_part_region();
 }
 
-void print_constraints(FILE* fp, VprConstraints constraints) {
-    Partition temp_part;
+void print_constraints(FILE* fp, const VprConstraints& constraints) {
     std::vector<AtomBlockId> atoms;
 
     int num_parts = constraints.get_num_partitions();
@@ -69,7 +72,7 @@ void print_constraints(FILE* fp, VprConstraints constraints) {
     for (int i = 0; i < num_parts; i++) {
         PartitionId part_id(i);
 
-        temp_part = constraints.get_partition(part_id);
+        const Partition& temp_part = constraints.get_partition(part_id);
 
         fprintf(fp, "\npartition_id: %zu\n", size_t(part_id));
         print_partition(fp, temp_part);
@@ -80,8 +83,7 @@ void print_constraints(FILE* fp, VprConstraints constraints) {
 
         fprintf(fp, "\tAtom vector size is %d\n", atoms_size);
         fprintf(fp, "\tIds of atoms in partition: \n");
-        for (unsigned int j = 0; j < atoms.size(); j++) {
-            AtomBlockId atom_id = atoms[j];
+        for (auto atom_id : atoms) {
             fprintf(fp, "\t#%zu\n", size_t(atom_id));
         }
     }