Clusterer feasibility changes

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

@@ -3,7 +3,7 @@
 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);
+static void print_constraints(FILE* fp, VprConstraints constraints);
 
 void print_region(FILE* fp, Region region) {
     vtr::Rect<int> rect = region.get_region_rect();
@@ -42,10 +42,14 @@ void print_partition_region(FILE* fp, PartitionRegion pr) {
     }
 }
 
-void print_constraints(FILE* fp, VprConstraints constraints, int num_parts) {
+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);
 
@@ -67,16 +71,15 @@ void print_constraints(FILE* fp, VprConstraints constraints, int num_parts) {
     }
 }
 
-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,6 @@
 #include "vpr_constraints.h"
 #include "vtr_vector.h"
 
-void echo_constraints(char* filename, VprConstraints constraints, int num_parts);
+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_region.cpp

@@ -8,6 +8,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

vpr/src/base/partition_region.h

@@ -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
      *

vpr/src/base/vpr_constraints.cpp

@@ -47,3 +47,13 @@ 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;
+}

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

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);
     }
 }

vpr/src/base/vpr_context.h

@@ -24,6 +24,7 @@
 #include "place_macro.h"
 #include "compressed_grid.h"
 #include "metadata_storage.h"
+#include "vpr_constraints.h"
 
 /**
  * @brief A Context is collection of state relating to a particular part of VPR
@@ -369,6 +370,35 @@ struct RoutingContext : public Context {
         cached_router_lookahead_;
 };
 
+/**
+ * @brief State relating to VPR's floorplanning constraints
+ *
+ * This should contain only data structures related to constraining blocks
+ * to certain regions on the chip.
+ */
+struct FloorplanningContext : public Context {
+    /**
+     * @brief Stores groups of constrained atoms, areas where the atoms are constrained to
+     *
+     * Provides all information needed about floorplanning constraints, including
+     * which atoms are constrained and the regions they are constrained to.
+     *
+     * The constraints are input into vpr and do not change.
+     */
+    VprConstraints constraints;
+
+    /**
+     * @brief Constraints for each cluster
+     *
+     * Each cluster will have a PartitionRegion specifying its regions constraints
+     * according to the constrained atoms packed into it. This structure allows the floorplanning
+     * constraints for a given cluster to be found easily given its ClusterBlockId.
+     *
+     * The constraints on each cluster are computed during the clustering process and can change.
+     */
+    vtr::vector<ClusterBlockId, PartitionRegion> cluster_constraints;
+};
+
 /**
  * @brief This object encapsulates VPR's state.
  *
@@ -440,6 +470,9 @@ class VprContext : public Context {
     const RoutingContext& routing() const { return routing_; }
     RoutingContext& mutable_routing() { return routing_; }
 
+    const FloorplanningContext& floorplanning() const { return constraints_; }
+    FloorplanningContext& mutable_floorplanning() { return constraints_; }
+
   private:
     DeviceContext device_;
 
@@ -451,6 +484,7 @@ class VprContext : public Context {
     ClusteringContext clustering_;
     PlacementContext placement_;
     RoutingContext routing_;
+    FloorplanningContext constraints_;
 };
 
 #endif

vpr/src/base/vpr_types.h

@@ -164,6 +164,7 @@ enum e_block_pack_status {
     BLK_PASSED,
     BLK_FAILED_FEASIBLE,
     BLK_FAILED_ROUTE,
+    BLK_FAILED_FLOORPLANNING,
     BLK_STATUS_UNDEFINED
 };