Clusterer feasibility changes

libs/libvtrutil/src/vtr_geometry.h

@@ -208,6 +208,16 @@ Rect<T> bounding_box(const Rect<T>& lhs, const Rect<T>& rhs);
 template<class T>
 Rect<T> intersection(const Rect<T>& lhs, const Rect<T>& rhs);
 
+//Prints a rectangle
+template<class T>
+static void print_rect(FILE* fp, const Rect<T> rect);
+
+//Sample on a uniformly spaced grid within a rectangle
+//  sample(vtr::Rect(l, h), 0, 0, M) == l
+//  sample(vtr::Rect(l, h), M, M, M) == h
+//To avoid the edges, use `sample(r, x+1, y+1, N+1) for x, y, in 0..N-1
+//Only defined for integral types
+
 /**
  * @brief Sample on a uniformly spaced grid within a rectangle
  *
@@ -216,6 +226,7 @@ Rect<T> intersection(const Rect<T>& lhs, const Rect<T>& rhs);
  * To avoid the edges, use `sample(r, x+1, y+1, N+1) for x, y, in 0..N-1
  * Only defined for integral types
  */
+
 template<typename T, typename std::enable_if<std::is_integral<T>::value>::type...>
 Point<T> sample(const vtr::Rect<T>& r, T x, T y, T d);
 

libs/libvtrutil/src/vtr_geometry.tpp

@@ -189,6 +189,13 @@ Rect<T> intersection(const Rect<T>& lhs, const Rect<T>& rhs) {
                    std::min(lhs.xmax(), rhs.xmax()),
                    std::min(lhs.ymax(), rhs.ymax()));
 }
+template<class T>
+static void print_rect(FILE* fp, const Rect<T> rect) {
+    fprintf(fp, "\txmin: %d\n", rect.xmin());
+    fprintf(fp, "\tymin: %d\n", rect.ymin());
+    fprintf(fp, "\txmax: %d\n", rect.xmax());
+    fprintf(fp, "\tymax: %d\n", rect.ymax());
+}
 //Only defined for integral types
 template<typename T, typename std::enable_if<std::is_integral<T>::value>::type...>
 Point<T> sample(const vtr::Rect<T>& r, T x, T y, T d) {

vpr/src/base/SetupGrid.cpp

@@ -191,9 +191,7 @@ static DeviceGrid auto_size_device_grid(const std::vector<t_grid_def>& grid_layo
             //Check if it satisfies the block counts
             if (grid_satisfies_instance_counts(grid, minimum_instance_counts, maximum_device_utilization)) {
                 //Re-build the grid at the final size with out-of-range
-                //warnings turned on (so users are aware of out-of-range issues
-                //at the final device sizes)
-                grid = build_device_grid(grid_def, width, height, true, limiting_resources);
+                grid = build_device_grid(grid_def, width, height, false, limiting_resources);
                 return grid;
             }
 

vpr/src/base/constraints_load.cpp

@@ -1,82 +1,14 @@
 #include "constraints_load.h"
 
-static void print_region(FILE* fp, Region region);
-static void print_partition(FILE* fp, Partition part);
-static void print_partition_region(FILE* fp, PartitionRegion pr);
-static void print_constraints(FILE* fp, VprConstraints constraints, int num_parts);
-
-void print_region(FILE* fp, Region region) {
-    vtr::Rect<int> rect = region.get_region_rect();
-    int xmin = rect.xmin();
-    int xmax = rect.xmax();
-    int ymin = rect.ymin();
-    int ymax = rect.ymax();
-    int subtile = region.get_sub_tile();
-
-    fprintf(fp, "\tRegion: \n");
-    fprintf(fp, "\txmin: %d\n", xmin);
-    fprintf(fp, "\txmax: %d\n", xmax);
-    fprintf(fp, "\tymin: %d\n", ymin);
-    fprintf(fp, "\tymax: %d\n", ymax);
-    fprintf(fp, "\tsubtile: %d\n\n", subtile);
-}
-
-void print_partition(FILE* fp, Partition part) {
-    std::string name = part.get_name();
-    fprintf(fp, "partition_name: %s\n", name.c_str());
-
-    PartitionRegion pr = part.get_part_region();
-
-    print_partition_region(fp, pr);
-}
-
-void print_partition_region(FILE* fp, PartitionRegion pr) {
-    std::vector<Region> part_region = pr.get_partition_region();
-
-    int pr_size = part_region.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]);
-    }
-}
-
-void print_constraints(FILE* fp, VprConstraints constraints, int num_parts) {
-    Partition temp_part;
-    std::vector<AtomBlockId> atoms;
-
-    for (int i = 0; i < num_parts; i++) {
-        PartitionId part_id(i);
-
-        temp_part = constraints.get_partition(part_id);
-
-        fprintf(fp, "\npartition_id: %zu\n", size_t(part_id));
-        print_partition(fp, temp_part);
-
-        atoms = constraints.get_part_atoms(part_id);
-
-        int atoms_size = atoms.size();
-
-        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];
-            fprintf(fp, "\t#%zu\n", size_t(atom_id));
-        }
-    }
-}
-
-void echo_constraints(char* filename, VprConstraints constraints, int num_parts) {
+void echo_constraints(char* filename, VprConstraints constraints) {
     FILE* fp;
     fp = vtr::fopen(filename, "w");
 
     fprintf(fp, "--------------------------------------------------------------\n");
     fprintf(fp, "Constraints\n");
     fprintf(fp, "--------------------------------------------------------------\n");
     fprintf(fp, "\n");
-    fprintf(fp, "\n Number of partitions is %d \n", num_parts);
-    print_constraints(fp, constraints, num_parts);
+    print_constraints(fp, constraints);
 
     fclose(fp);
 }

vpr/src/base/constraints_load.h

@@ -7,6 +7,7 @@
 #include "vpr_constraints.h"
 #include "vtr_vector.h"
 
-void echo_constraints(char* filename, VprConstraints constraints, int num_parts);
+///@brief Used to print vpr's floorplanning constraints to an echo file "vpr_constraints.echo"
+void echo_constraints(char* filename, VprConstraints constraints);
 
 #endif

vpr/src/base/echo_files.cpp

@@ -74,6 +74,9 @@ void alloc_and_load_echo_file_info() {
     //Vpr constraints
     setEchoFileName(E_ECHO_VPR_CONSTRAINTS, "vpr_constraints.echo");
 
+    //Packing
+    setEchoFileName(E_ECHO_CLUSTERS, "clusters.echo");
+
     //Intra-block routing
     setEchoFileName(E_ECHO_INTRA_LB_FAILED_ROUTE, "intra_lb_failed_route.echo");
 

vpr/src/base/echo_files.h

@@ -12,6 +12,9 @@ enum e_echo_files {
     E_ECHO_PRE_PACKING_MOLECULES_AND_PATTERNS,
     E_ECHO_VPR_CONSTRAINTS,
 
+    //Packing
+    E_ECHO_CLUSTERS,
+
     // Intra-block routing
     E_ECHO_INTRA_LB_FAILED_ROUTE,
 

vpr/src/base/partition.cpp

@@ -1,4 +1,5 @@
 #include "partition.h"
+#include "partition_region.h"
 #include <algorithm>
 #include <vector>
 
@@ -17,3 +18,12 @@ const PartitionRegion Partition::get_part_region() {
 void Partition::set_part_region(PartitionRegion pr) {
     part_region = pr;
 }
+
+void print_partition(FILE* fp, Partition part) {
+    std::string name = part.get_name();
+    fprintf(fp, "partition_name: %s\n", name.c_str());
+
+    PartitionRegion pr = part.get_part_region();
+
+    print_partition_region(fp, pr);
+}

vpr/src/base/partition.h

@@ -53,4 +53,7 @@ class Partition {
     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);
+
 #endif /* PARTITION_H */

vpr/src/base/partition_region.cpp

@@ -1,4 +1,5 @@
 #include "partition_region.h"
+#include "region.h"
 
 void PartitionRegion::add_to_part_region(Region region) {
     partition_region.push_back(region);
@@ -8,6 +9,10 @@ std::vector<Region> PartitionRegion::get_partition_region() {
     return partition_region;
 }
 
+bool PartitionRegion::empty() {
+    return partition_region.size() == 0;
+}
+
 PartitionRegion intersection(PartitionRegion& pr1, PartitionRegion& pr2) {
     /**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
@@ -29,3 +34,15 @@ PartitionRegion intersection(PartitionRegion& pr1, PartitionRegion& pr2) {
 
     return pr;
 }
+
+void print_partition_region(FILE* fp, PartitionRegion pr) {
+    std::vector<Region> part_region = pr.get_partition_region();
+
+    int pr_size = part_region.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]);
+    }
+}

vpr/src/base/partition_region.h

@@ -6,7 +6,7 @@
 
 /**
  * @file
- * @brief This file defines the PartitionRegions class. The PartitionRegions class is used to store the union
+ * @brief This file defines the PartitionRegion class. The PartitionRegion class is used to store the union
  * of regions that a partition can be placed in.
  */
 
@@ -24,6 +24,11 @@ class PartitionRegion {
      */
     std::vector<Region> get_partition_region();
 
+    /**
+     * @brief Check if the PartitionRegion is empty (meaning there is no constraint on the object the PartitionRegion belongs to)
+     */
+    bool empty();
+
     /**
      * @brief Global friend function that returns the intersection of two PartitionRegions
      *
@@ -36,4 +41,7 @@ class PartitionRegion {
     std::vector<Region> partition_region; ///< 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);
+
 #endif /* PARTITION_REGIONS_H */

vpr/src/base/region.cpp

@@ -82,3 +82,9 @@ Region intersection(Region r1, Region r2) {
 
     return intersect;
 }
+
+void print_region(FILE* fp, Region region) {
+    fprintf(fp, "\tRegion: \n");
+    print_rect(fp, region.get_region_rect());
+    fprintf(fp, "\tsubtile: %d\n\n", region.get_sub_tile());
+}

vpr/src/base/region.h

@@ -76,4 +76,7 @@ bool do_regions_intersect(Region r1, Region r2);
  */
 Region intersection(Region r1, Region r2);
 
+///@brief Used to print data from a Region
+void print_region(FILE* fp, Region region);
+
 #endif /* REGION_H */

vpr/src/base/vpr_constraints.cpp

@@ -1,4 +1,5 @@
 #include "vpr_constraints.h"
+#include "partition.h"
 
 void VprConstraints::add_constrained_atom(const AtomBlockId blk_id, const PartitionId part_id) {
     constrained_atoms.insert({blk_id, part_id});
@@ -47,3 +48,42 @@ std::vector<AtomBlockId> VprConstraints::get_part_atoms(PartitionId part_id) {
 
     return part_atoms;
 }
+
+int VprConstraints::get_num_partitions() {
+    return partitions.size();
+}
+
+PartitionRegion VprConstraints::get_partition_pr(PartitionId part_id) {
+    PartitionRegion pr;
+    pr = partitions[part_id].get_part_region();
+    return pr;
+}
+
+void print_constraints(FILE* fp, VprConstraints constraints) {
+    Partition temp_part;
+    std::vector<AtomBlockId> atoms;
+
+    int num_parts = constraints.get_num_partitions();
+
+    fprintf(fp, "\n Number of partitions is %d \n", num_parts);
+
+    for (int i = 0; i < num_parts; i++) {
+        PartitionId part_id(i);
+
+        temp_part = constraints.get_partition(part_id);
+
+        fprintf(fp, "\npartition_id: %zu\n", size_t(part_id));
+        print_partition(fp, temp_part);
+
+        atoms = constraints.get_part_atoms(part_id);
+
+        int atoms_size = atoms.size();
+
+        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];
+            fprintf(fp, "\t#%zu\n", size_t(atom_id));
+        }
+    }
+}

vpr/src/base/vpr_constraints.h

@@ -18,6 +18,21 @@
  * It also specifies which regions the partitions should be placed in. Atoms cannot be placed in more than one partition.
  * If an atom is assigned to more than one partition, the last partition is was assigned to will be the partition it is placed in.
  *
+ * Related Classes
+ * ===============
+ * The following definitions are useful to understanding this class:
+ *
+ * Partition: a grouping of atoms that are constrained to a portion of an FPGA
+ * See vpr/base/partition.h for more detail
+ *
+ * Region: the x and y bounds of a rectangular region, optionally including a subtile value,
+ * that atoms in a partition are constrained to
+ * See vpr/base/region.h for more detail
+ *
+ * PartitionRegion: the union of regions that a partition can be placed in
+ * See vpr/base/partition_region.h for more detail
+ *
+ *
  */
 
 class VprConstraints {
@@ -33,7 +48,7 @@ class VprConstraints {
     /**
      * @brief Return id of the partition the atom belongs to
      *
-     * If an atom is not in a partition (unconstrained), PartitionId::Invalid() is returned.
+     * If an atom is not in a partition (unconstrained), PartitionId::INVALID() is returned.
      *
      *   @param blk_id      The atom for which the partition id is needed
      */
@@ -60,6 +75,18 @@ class VprConstraints {
      */
     std::vector<AtomBlockId> get_part_atoms(PartitionId part_id);
 
+    /**
+     * @brief Returns the number of partitions in the object
+     */
+    int get_num_partitions();
+
+    /**
+     * @brief Returns the PartitionRegion belonging to the specified Partition
+     *
+     *   @param part_id The id of the partition whose PartitionRegion is needed
+     */
+    PartitionRegion get_partition_pr(PartitionId part_id);
+
   private:
     /**
      * Store all constrained atoms
@@ -72,4 +99,7 @@ class VprConstraints {
     vtr::vector<PartitionId, Partition> partitions;
 };
 
+///@brief used to print floorplanning constraints data from a VprConstraints object
+void print_constraints(FILE* fp, VprConstraints constraints);
+
 #endif /* VPR_CONSTRAINTS_H */

vpr/src/base/vpr_constraints_reader.cpp

@@ -31,10 +31,13 @@ void load_vpr_constraints_file(const char* read_vpr_constraints_name) {
             read_vpr_constraints_name);
     }
 
-    VprConstraints constraints = reader.constraints_;
-    int num_parts = reader.num_partitions_;
+    //Update the floorplanning constraints in the floorplanning constraints context
+    auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
+    floorplanning_ctx.constraints = reader.constraints_;
+
+    VprConstraints ctx_constraints = floorplanning_ctx.constraints;
 
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_VPR_CONSTRAINTS)) {
-        echo_constraints(getEchoFileName(E_ECHO_VPR_CONSTRAINTS), constraints, num_parts);
+        echo_constraints(getEchoFileName(E_ECHO_VPR_CONSTRAINTS), ctx_constraints);
     }
 }