Clusterer feasibility changes

vpr/src/base/SetupGrid.cpp

@@ -406,6 +406,8 @@ static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t grid_widt
         size_t incry = p.parse_formula(yspec.incr_expr, vars);
         size_t repeaty = p.parse_formula(yspec.repeat_expr, vars);
 
+        warn_out_of_range = false;
+
         //Check start against the device dimensions
         // Start locations outside the device will never create block instances
         if (startx > grid_width - 1) {

vpr/src/base/constraints_load.cpp

@@ -67,16 +67,18 @@ 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");
 
+    int num_of_parts = constraints.get_num_partitions();
+
     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);
+    fprintf(fp, "\n Number of partitions is %d \n", num_of_parts);
+    print_constraints(fp, constraints, num_of_parts);
 
     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/vpr_constraints_reader.cpp

@@ -38,6 +38,6 @@ void load_vpr_constraints_file(const char* read_vpr_constraints_name) {
     VprConstraints ctx_constraints = floorplanning_ctx.constraints;
 
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_VPR_CONSTRAINTS)) {
-        echo_constraints(getEchoFileName(E_ECHO_VPR_CONSTRAINTS), ctx_constraints, ctx_constraints.get_num_partitions());
+        echo_constraints(getEchoFileName(E_ECHO_VPR_CONSTRAINTS), ctx_constraints);
     }
 }

vpr/src/base/vpr_context.h

@@ -382,6 +382,8 @@ struct FloorplanningContext : public Context {
      *
      * 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;
 
@@ -391,6 +393,8 @@ struct FloorplanningContext : public Context {
      * 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;
 };

vpr/src/pack/cluster.cpp

@@ -188,10 +188,14 @@ static t_pack_molecule* get_molecule_by_num_ext_inputs(const int ext_inps,
 static t_pack_molecule* get_free_molecule_with_most_ext_inputs_for_cluster(t_pb* cur_pb,
                                                                            t_cluster_placement_stats* cluster_placement_stats_ptr);
 
+static void print_pack_status_header();
+
 static void print_pack_status(int num_clb,
                               int tot_num_molecules,
                               int num_molecules_processed,
-                              std::map<t_logical_block_type_ptr, size_t> clb_types);
+                              int& mols_since_last_print,
+                              int device_width,
+                              int device_height);
 
 static enum e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placement_stats_ptr,
                                                   const std::multimap<AtomBlockId, t_pack_molecule*>& atom_molecules,
@@ -401,15 +405,16 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
      *****************************************************************/
     VTR_ASSERT(packer_opts.packer_algorithm == PACK_GREEDY);
 
-    int num_molecules, num_molecules_processed, blocks_since_last_analysis, num_clb,
-        num_blocks_hill_added, max_cluster_size, cur_cluster_size,
+    int num_molecules, num_molecules_processed, mols_since_last_print, blocks_since_last_analysis,
+        num_clb, num_blocks_hill_added, max_cluster_size, cur_cluster_size,
         max_pb_depth, cur_pb_depth, num_unrelated_clustering_attempts,
         seedindex, savedseedindex /* index of next most timing critical block */,
         detailed_routing_stage, *hill_climbing_inputs_avail;
 
     const int verbosity = packer_opts.pack_verbosity;
 
     num_molecules_processed = 0;
+    mols_since_last_print = 0;
 
     std::map<t_logical_block_type_ptr, size_t> num_used_type_instances;
 
@@ -553,6 +558,8 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     istart = get_highest_gain_seed_molecule(&seedindex, atom_molecules, seed_atoms);
 
+    print_pack_status_header();
+
     /****************************************************************
      * Clustering
      *****************************************************************/
@@ -581,6 +588,13 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
             //initial molecule in cluster has been processed
             num_molecules_processed++;
+            mols_since_last_print++;
+            print_pack_status(num_clb,
+                              num_molecules,
+                              num_molecules_processed,
+                              mols_since_last_print,
+                              device_ctx.grid.width(),
+                              device_ctx.grid.height());
 
             VTR_LOGV(verbosity > 2,
                      "Complex block %d: '%s' (%s) ", num_clb,
@@ -689,6 +703,12 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
                 //Since molecule passed, update num_molecules_processed
                 num_molecules_processed++;
+                mols_since_last_print++;
+                print_pack_status(num_clb, num_molecules,
+                                  num_molecules_processed,
+                                  mols_since_last_print,
+                                  device_ctx.grid.width(),
+                                  device_ctx.grid.height());
 
                 update_cluster_stats(next_molecule, clb_index,
                                      is_clock, //Set of all clocks
@@ -762,7 +782,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 update_le_count(cur_pb, logic_block_type, le_pb_type, le_count);
 
                 //print clustering progress incrementally
-                print_pack_status(num_clb, num_molecules, num_molecules_processed, num_used_type_instances);
+                //print_pack_status(num_clb, num_molecules, num_molecules_processed, mols_since_last_print, device_ctx.grid.width(), device_ctx.grid.height());
 
                 free_pb_stats_recursive(cur_pb);
             } else {
@@ -820,20 +840,44 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     return num_used_type_instances;
 }
 
+/*print the header for the clustering progress table*/
+static void print_pack_status_header() {
+    VTR_LOG("Starting Clustering - Clustering Progress: \n");
+    VTR_LOG("-------------------   --------------------------   ---------\n");
+    VTR_LOG("Molecules processed   Number of clusters created   FPGA size\n");
+    VTR_LOG("-------------------   --------------------------   ---------\n");
+}
+
+/*incrementally print progress updates during clustering*/
 static void print_pack_status(int num_clb,
                               int tot_num_molecules,
                               int num_molecules_processed,
-                              std::map<t_logical_block_type_ptr, size_t> clb_types) {
-    //print an update every 10 clusters
-    if (num_clb % 50 == 0) {
-        VTR_LOG("\nCreated %d clusters\n", num_clb);
-        VTR_LOG("Processed %d out of %d molecules\n", num_molecules_processed, tot_num_molecules);
-        VTR_LOG("Cluster types:\n");
+                              int& mols_since_last_print,
+                              int device_width,
+                              int device_height) {
+    const float print_frequency = 0.04;
+
+    double percentage = (num_molecules_processed / (double)tot_num_molecules) * 100;
+
+    int int_percentage = int(percentage);
+
+    int int_molecule_increment = (int)(print_frequency * tot_num_molecules);
+
+    if (mols_since_last_print == int_molecule_increment) {
+        VTR_LOG(
+            "%6d/%-6d  %3d%%   "
+            "%26d   "
+            "%3d x %-3d   ",
+            num_molecules_processed,
+            tot_num_molecules,
+            int_percentage,
+            num_clb,
+            device_width,
+            device_height);
 
-        for (auto i = clb_types.begin(); i != clb_types.end(); i++) {
-            VTR_LOG("\t %s: # blocks %zu \n", i->first->name, size_t(i->second));
-        }
         VTR_LOG("\n");
+        fflush(stdout);
+        mols_since_last_print = 0;
     }
 }
 
@@ -1403,9 +1447,13 @@ static enum e_block_pack_status try_pack_molecule(t_cluster_placement_stats* clu
                     }
 
                     //update cluster PartitionRegion if atom with floorplanning constraints was added
+                    /* TODO: Create temp_cluster_pr in start_new_cluster and pass to this function
+                     * by reference so that this check is not needed */
                     if (cluster_pr_needs_update) {
                         floorplanning_ctx.cluster_constraints[clb_index] = temp_cluster_pr;
-                        VTR_LOG("\nUpdated PartitionRegion of cluster %d\n", clb_index);
+                        if (verbosity > 2) {
+                            VTR_LOG("\nUpdated PartitionRegion of cluster %d\n", clb_index);
+                        }
                     }
 
                     for (i = 0; i < molecule_size; i++) {
@@ -2225,8 +2273,6 @@ static void start_new_cluster(t_cluster_placement_stats* cluster_placement_stats
 
     if (num_used_type_instances[block_type] > num_instances) {
         device_ctx.grid = create_device_grid(device_layout_name, arch->grid_layouts, num_used_type_instances, target_device_utilization);
-        VTR_LOGV(verbosity > 0, "Not enough resources expand FPGA size to (%d x %d)\n",
-                 device_ctx.grid.width(), device_ctx.grid.height());
     }
 }
 
@@ -2548,6 +2594,7 @@ static void check_clustering() {
     }
 }
 
+/*Print the contents of each cluster to an echo file*/
 static void echo_clusters(char* filename) {
     FILE* fp;
     fp = vtr::fopen(filename, "w");

vpr/src/pack/output_clustering.cpp

@@ -131,6 +131,7 @@ static void print_stats() {
 }
 
 static void print_clustering_stats_header() {
+    VTR_LOG("Final Clustering Statistics: \n");
     VTR_LOG("----------   --------   ------------------------------------   --------------------------\n");
     VTR_LOG("Block Type   # Blocks   Avg. # of input clocks and pins used   Avg. # of output pins used\n");
     VTR_LOG("----------   --------   ------------------------------------   --------------------------\n");