Added member functions to VprConstraints and added unit tests to test these and changed a class name to PartitionRegion

Author: sfkhalid

vpr/src/base/partition.cpp

@@ -2,20 +2,6 @@
 #include <algorithm>
 #include <vector>
 
-Partition::Partition() {
-    id = PartitionId::INVALID();
-    name = "";
-    atom_blocks = {};
-}
-
-const PartitionId Partition::get_partition_id() {
-    return id;
-}
-
-void Partition::set_partition_id(PartitionId _part_id) {
-    id = _part_id;
-}
-
 const std::string Partition::get_name() {
     return name;
 }
@@ -24,26 +10,10 @@ void Partition::set_name(std::string _part_name) {
     name = _part_name;
 }
 
-void Partition::add_to_atoms(AtomBlockId atom_id) {
-    atom_blocks.push_back(atom_id);
-}
-
-bool Partition::contains_atom(AtomBlockId atom_id) {
-    bool contains_atom = false;
-    if (std::find(atom_blocks.begin(), atom_blocks.end(), atom_id) != atom_blocks.end()) {
-        contains_atom = true;
-    }
-    return contains_atom;
-}
-
-const std::vector<AtomBlockId> Partition::get_atoms() {
-    return atom_blocks;
-}
-
-const PartitionRegions Partition::get_part_regions() {
+const PartitionRegion Partition::get_part_regions() {
     return part_regions;
 }
 
-void Partition::set_part_regions(PartitionRegions pr) {
+void Partition::set_part_regions(PartitionRegion pr) {
     part_regions = pr;
 }

vpr/src/base/partition.h

@@ -3,8 +3,8 @@
 
 #include "vtr_strong_id.h"
 #include "region.h"
-#include "partition_regions.h"
 #include "atom_netlist_fwd.h"
+#include "partition_region.h"
 /**
  * @file
  * @brief This file defines the data for a partition: a grouping of atoms that are constrained to a portion of an FPGA. A partition defines
@@ -21,34 +21,18 @@ typedef vtr::StrongId<partition_id_tag> PartitionId;
 
 class Partition {
   public:
-    Partition();
-
-    const PartitionId get_partition_id();
-    void set_partition_id(PartitionId _part_id);
-
     const std::string get_name();
     void set_name(std::string _part_name);
 
-    //add an id to the atom_blocks vector
-    void add_to_atoms(AtomBlockId atom_id);
-
-    //check if a given atom is in the partition
-    bool contains_atom(AtomBlockId atom_id);
-
-    //get the atom_blocks vector
-    const std::vector<AtomBlockId> get_atoms();
-
     //set the union of regions for this partition;
-    void set_part_regions(PartitionRegions pr);
+    void set_part_regions(PartitionRegion pr);
 
     //get the union of regions of this partition
-    const PartitionRegions get_part_regions();
+    const PartitionRegion get_part_regions();
 
   private:
-    PartitionId id;                       //unique id for this partition
-    std::string name;                     //name of the partition, name will be unique across partitions
-    std::vector<AtomBlockId> atom_blocks; //atoms that belong to this partition, each atom should only belong to one partition
-    PartitionRegions part_regions;        //the union of regions that the partition can be placed in
+    std::string name;             //name of the partition, name will be unique across partitions
+    PartitionRegion part_regions; //the union of regions that the partition can be placed in
 };
 
 #endif /* PARTITION_H */

vpr/src/base/partition_regions.cpp renamed to vpr/src/base/partition_region.cpp

@@ -1,12 +1,12 @@
-#include "partition_regions.h"
+#include "partition_region.h"
 
-PartitionRegions PartitionRegions::get_intersection(PartitionRegions part_region) {
+PartitionRegion PartitionRegion::get_intersection(PartitionRegion part_region) {
     /**for N regions in part_region and M in the calling object you can get anywhere from
      * 0 to M*N regions in the resulting vector. Only intersection regions with non-zero area rectangles and
      * equivalent subtiles are put in the resulting vector
      * Rectangles are not merged even if it would be possible
      */
-    PartitionRegions pr;
+    PartitionRegion pr;
     Region intersect_region;
     bool regions_intersect;
     for (unsigned int i = 0; i < partition_regions.size(); i++) {
@@ -22,10 +22,10 @@ PartitionRegions PartitionRegions::get_intersection(PartitionRegions part_region
     return pr;
 }
 
-void PartitionRegions::add_to_part_regions(Region region) {
+void PartitionRegion::add_to_part_regions(Region region) {
     partition_regions.push_back(region);
 }
 
-std::vector<Region> PartitionRegions::get_partition_regions() {
+std::vector<Region> PartitionRegion::get_partition_regions() {
     return partition_regions;
 }

vpr/src/base/partition_regions.h renamed to vpr/src/base/partition_region.h

@@ -10,10 +10,10 @@
  * of regions that a partition can be placed in.
  */
 
-class PartitionRegions {
+class PartitionRegion {
   public:
     //Returns the intersection of two PartitionRegions vectors that are passed to it.
-    PartitionRegions get_intersection(PartitionRegions part_region);
+    PartitionRegion get_intersection(PartitionRegion part_region);
 
     //function to add to the partition_regions vector
     void add_to_part_regions(Region region);

vpr/src/base/vpr_constraints.cpp

@@ -1,13 +1,23 @@
 #include "vpr_constraints.h"
 
-void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId partition) {
-    constrained_atoms.insert({blk_id, partition});
+void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id) {
+    constrained_atoms.insert({blk_id, part_id});
+
+    //std::unordered_map<AtomBlockId, PartitionId>::const_iterator got = constrained_atoms.find(blk_id);
+    auto got = constrained_atoms.find(blk_id);
+
+    if (got == constrained_atoms.end()) {
+        constrained_atoms.insert({blk_id, part_id});
+    } else {
+        got->second = part_id;
+    }
 }
 
 PartitionId VprConstraints::get_atom_partition(AtomBlockId blk_id) {
     PartitionId part_id;
 
-    std::unordered_map<AtomBlockId, PartitionId>::const_iterator got = constrained_atoms.find(blk_id);
+    //std::unordered_map<AtomBlockId, PartitionId>::const_iterator got = constrained_atoms.find(blk_id);
+    auto got = constrained_atoms.find(blk_id);
 
     if (got == constrained_atoms.end()) {
         return part_id = PartitionId::INVALID();
@@ -20,6 +30,18 @@ void VprConstraints::add_partition(Partition part) {
     partitions.push_back(part);
 }
 
-vtr::vector<PartitionId, Partition> VprConstraints::get_partitions() {
-    return partitions;
+Partition VprConstraints::get_partition(PartitionId part_id) {
+    return partitions[part_id];
+}
+
+std::vector<AtomBlockId> VprConstraints::get_part_atoms(PartitionId part_id) {
+    std::vector<AtomBlockId> part_atoms;
+
+    for (auto& it : constrained_atoms) {
+        if (it.second == part_id) {
+            part_atoms.push_back(it.first);
+        }
+    }
+
+    return part_atoms;
 }

vpr/src/base/vpr_constraints.h

@@ -4,7 +4,7 @@
 #include "vtr_vector.h"
 #include "vpr_utils.h"
 #include "partition.h"
-#include "partition_regions.h"
+#include "partition_region.h"
 
 /**
  * @file
@@ -21,23 +21,21 @@
 
 class VprConstraints {
   public:
-    //VprConstraints();
-
     //function to add an atom to constrained_atoms
-    void add_constrained_atom(const AtomBlockId blk_id, const PartitionId partition);
+    void add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id);
 
     //function to find which partition an atom belongs to
     PartitionId get_atom_partition(AtomBlockId blk_id);
 
     //function to add a partition to partitions
     void add_partition(Partition part);
 
-    //function to return the partitions vector
-    vtr::vector<PartitionId, Partition> get_partitions();
-
     //function to return a partition given a PartitionId
     Partition get_partition(PartitionId part_id);
 
+    //function to return the atoms belonging to a partition
+    std::vector<AtomBlockId> get_part_atoms(PartitionId part_id);
+
   private:
     /**
      * Store constraints information of each  constrained atom.