Created draft of new constraints class header file

vpr/src/base/partition.cpp

@@ -0,0 +1,43 @@
+#include "partition.h"
+#include <algorithm>
+#include <vector>
+
+PartitionId Partition::get_partition_id() {
+    return id;
+}
+
+void Partition::set_partition_id(PartitionId _part_id) {
+    id = _part_id;
+}
+
+std::string Partition::get_name() {
+    return name;
+}
+
+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;
+}
+
+std::vector<AtomBlockId> Partition::get_atoms() {
+    return atom_blocks;
+}
+
+PartitionRegions Partition::get_part_regions() {
+    return part_regions;
+}
+
+void Partition::set_part_regions(PartitionRegions pr) {
+    part_regions = pr;
+}

vpr/src/base/partition.h

@@ -0,0 +1,52 @@
+#ifndef PARTITION_H
+#define PARTITION_H
+
+#include "vtr_strong_id.h"
+#include "region.h"
+#include "partition_regions.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
+ * the atoms that are assigned to it, and the locations in which they can be placed. The locations are a union of rectangles in x, y,
+ * sub_tile space. Common cases include a single rectangle or a single x, y, sub_tile (specific location). More complex partitions
+ * with L, T or other shapes can be created with a union of multiple rectangles.
+ */
+
+//Type tag for PartitionId
+struct partition_id_tag;
+
+//A unique identifier for a partition
+typedef vtr::StrongId<partition_id_tag> PartitionId;
+
+class Partition {
+  public:
+    PartitionId get_partition_id();
+    void set_partition_id(PartitionId _part_id);
+
+    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
+    std::vector<AtomBlockId> get_atoms();
+
+    //set the union of regions for this partition;
+    void set_part_regions(PartitionRegions pr);
+
+    //get the union of regions of this partition
+    PartitionRegions 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
+};
+
+#endif /* PARTITION_H */

vpr/src/base/partition_regions.cpp

@@ -0,0 +1,40 @@
+#include "partition_regions.h"
+
+PartitionRegions PartitionRegions::get_intersection(PartitionRegions region) {
+    //region is a vector of regions, part_regions is another vector of regions
+    //have to intersect the regions and return their intersection
+    PartitionRegions pr;
+    Region intersect_region;
+    bool regions_intersect;
+    for (int i = 0; i < partition_regions.size(); i++) {
+        for (int j = 0; j < region.partition_regions.size(); j++) {
+            regions_intersect = partition_regions[i].do_regions_intersect(region.partition_regions[j]);
+            if (regions_intersect) {
+                intersect_region = partition_regions[i].regions_intersection(region.partition_regions[j]);
+                pr.partition_regions.push_back(intersect_region);
+            }
+        }
+    }
+
+    return pr;
+}
+
+bool PartitionRegions::intersects(PartitionRegions region) {
+    //fill in check for intersection
+    bool test;
+    return test;
+}
+
+PartitionRegions PartitionRegions::get_intersect(const AtomBlockId atom_id) {
+    //fill in to get intersection
+    PartitionRegions pr;
+    return pr;
+}
+
+void PartitionRegions::add_to_part_regions(Region region) {
+    partition_regions.push_back(region);
+}
+
+std::vector<Region> PartitionRegions::get_partition_regions() {
+    return partition_regions;
+}

vpr/src/base/partition_regions.h

@@ -0,0 +1,39 @@
+#ifndef PARTITION_REGIONS_H
+#define PARTITION_REGIONS_H
+
+#include "region.h"
+
+/**
+ * @file
+ * @brief This file defines the PartitionRegions class. The PartitionRegions class is used to store the union
+ * of regions that a partition can be placed in.
+ */
+
+class PartitionRegions {
+  public:
+    /**
+     * Returns the intersection of two PartitionRegions vectors that are passed to it.
+     */
+    PartitionRegions get_intersection(PartitionRegions region);
+
+    /**
+     * A test for intersection of the PartitionRegions of two blocks
+     */
+    bool intersects(PartitionRegions region);
+
+    /**
+     * Takes Atom Id returns intersection of atom's PartitionRegions with the PartitionRegions of the object
+     */
+    PartitionRegions get_intersect(const AtomBlockId atom_id);
+
+    //method to add to the partition_regions vector
+    void add_to_part_regions(Region region);
+
+    //method to get the partition_regions vector
+    std::vector<Region> get_partition_regions();
+
+  private:
+    std::vector<Region> partition_regions; //vector of regions that a partition can be placed in
+};
+
+#endif /* PARTITION_REGIONS_H */

vpr/src/base/region.cpp

@@ -0,0 +1,110 @@
+#include "region.h"
+
+//sentinel value for indicating that a subtile has not been specified
+int NO_SUBTILE = -1;
+
+Region::Region() {
+    sub_tile = NO_SUBTILE;
+}
+
+int Region::get_xmin() {
+    return region_bounds.xmin();
+}
+
+int Region::get_xmax() {
+    return region_bounds.xmax();
+}
+
+int Region::get_ymin() {
+    return region_bounds.ymin();
+}
+
+int Region::get_ymax() {
+    return region_bounds.ymax();
+}
+
+void Region::set_region_rect(int _xmin, int _ymin, int _xmax, int _ymax) {
+    region_bounds.set_xmin(_xmin);
+    region_bounds.set_xmax(_xmax);
+    region_bounds.set_ymin(_ymin);
+    region_bounds.set_ymax(_ymax);
+}
+
+int Region::get_sub_tile() {
+    return sub_tile;
+}
+
+void Region::set_sub_tile(int _sub_tile) {
+    sub_tile = _sub_tile;
+}
+
+bool Region::do_regions_intersect(Region region) {
+    bool intersect = true;
+
+    int x_min_1 = region.get_xmin();
+    int x_min_2 = region_bounds.xmin();
+    int int_x_min = std::max(x_min_1, x_min_2);
+
+    int y_min_1 = region.get_ymin();
+    int y_min_2 = region_bounds.ymin();
+    int int_y_min = std::max(y_min_1, y_min_2);
+
+    int x_max_1 = region.get_xmax();
+    int x_max_2 = region_bounds.xmax();
+    int int_x_max = std::min(x_max_1, x_max_2);
+
+    int y_max_1 = region.get_ymax();
+    int y_max_2 = region_bounds.ymax();
+    int int_y_max = std::min(y_max_1, y_max_2);
+
+    //check if rectangles dimensions are invalid
+    if (int_x_min > int_x_max || int_y_min > int_y_max) {
+        intersect = false;
+    }
+
+    return intersect;
+}
+
+Region Region::regions_intersection(Region region) {
+    Region intersect;
+
+    int x_min_1 = region.get_xmin();
+    int x_min_2 = region_bounds.xmin();
+    int int_x_min = std::max(x_min_1, x_min_2);
+
+    int y_min_1 = region.get_ymin();
+    int y_min_2 = region_bounds.ymin();
+    int int_y_min = std::max(y_min_1, y_min_2);
+
+    int x_max_1 = region.get_xmax();
+    int x_max_2 = region_bounds.xmax();
+    int int_x_max = std::min(x_max_1, x_max_2);
+
+    int y_max_1 = region.get_ymax();
+    int y_max_2 = region_bounds.ymax();
+    int int_y_max = std::min(y_max_1, y_max_2);
+
+    intersect.set_region_rect(int_x_min, int_y_min, int_x_max, int_y_max);
+
+    return intersect;
+}
+
+bool Region::locked() {
+    bool locked = false;
+    bool x_matches = false;
+    bool y_matches = false;
+
+    if (region_bounds.xmin() == region_bounds.xmax()) {
+        x_matches = true;
+    }
+
+    if (region_bounds.ymin() == region_bounds.ymax()) {
+        y_matches = true;
+    }
+
+    if (x_matches && y_matches && sub_tile != NO_SUBTILE) {
+        locked = true;
+    }
+
+    return locked;
+}

vpr/src/base/region.h

@@ -0,0 +1,48 @@
+#ifndef REGION_H
+#define REGION_H
+
+#include "globals.h"
+
+/**
+ * @file
+ * @brief This file defines the Region class. The Region class stores the data for each constraint region.
+ *        This includes the bounds of the region rectangle and the sub_tile bounds. To lock a block down to a specific location,
+ *        when defining the region specify xmin = xmax, ymin = ymax, sub_tile_min = sub_tile_max
+ *
+ */
+
+//sentinel value for indicating that a subtile had not been specified
+extern int NO_SUBTILE;
+
+class Region {
+  public:
+    Region();
+
+    //vtr::Rect get_region_rect();
+    int get_xmin();
+    int get_xmax();
+    int get_ymin();
+    int get_ymax();
+    void set_region_rect(int _xmin, int _ymin, int _xmax, int _ymax);
+
+    int get_sub_tile();
+
+    void set_sub_tile(int _sub_tile);
+
+    //function to see if two regions intersect anywhere
+    bool do_regions_intersect(Region region);
+
+    //returns the coordinates of the intersection of two regions
+    Region regions_intersection(Region region);
+
+    //function to check whether a block is locked down to a specific x, y, subtile location
+    //can be called by the placer to see if the block is locked down
+    bool locked();
+
+  private:
+    //may need to include zmin, zmax for future use in 3D FPGA designs
+    vtr::Rect<int> region_bounds; //xmin, ymin, xmax, ymax inclusive
+    int sub_tile;                 //users will optionally select a subtile, will select if they want to lock down block to specific location
+};
+
+#endif /* REGION_H */

vpr/src/base/vpr_constraints.cpp

@@ -0,0 +1,19 @@
+#include "vpr_constraints.h"
+
+void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId partition) {
+    constrained_atoms.insert({blk_id, partition});
+}
+
+PartitionId VprConstraints::get_atom_partition(AtomBlockId blk_id) {
+    PartitionId part_id;
+    part_id = constrained_atoms.at(blk_id);
+    return part_id;
+}
+
+void VprConstraints::add_partition(Partition part) {
+    partitions.push_back(part);
+}
+
+vtr::vector<PartitionId, Partition> VprConstraints::get_partitions() {
+    return partitions;
+}