[SQUASH ME] Removed the legalizer from the global scope

Author: AlexandreSinger

vpr/src/base/vpr_context.h

@@ -5,7 +5,6 @@
 #include <vector>
 #include <mutex>
 
-#include "cluster_legalizer.h"
 #include "prepack.h"
 #include "vpr_types.h"
 #include "vtr_ndmatrix.h"
@@ -316,10 +315,6 @@ struct ClusteringContext : public Context {
  * in packing or placement stages.
  */
 struct ClusteringHelperContext : public Context {
-    /// @brief Class used to construct legal clusters.
-    /// FIXME: Move this to the cluster context?
-    ClusterLegalizer cluster_legalizer;
-
     // A vector of routing resource nodes within each of logic cluster_ctx.blocks types [0 .. num_logical_block_type-1]
     // FIXME: This is only used for a handoff between the vpr_setup and the packer.
     //        This can be made cleaner.

vpr/src/pack/cluster.cpp

@@ -69,6 +69,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          const t_analysis_opts& analysis_opts,
                                                          const t_arch* arch,
                                                          Prepacker& prepacker,
+                                                         ClusterLegalizer& cluster_legalizer,
                                                          const std::unordered_set<AtomNetId>& is_clock,
                                                          const std::unordered_set<AtomNetId>& is_global,
                                                          bool allow_unrelated_clustering,
@@ -120,7 +121,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& device_ctx = g_vpr_ctx.mutable_device();
-    auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
 
     std::shared_ptr<PreClusterDelayCalculator> clustering_delay_calc;
     std::shared_ptr<SetupTimingInfo> timing_info;
@@ -151,7 +151,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     cluster_stats.num_molecules = prepacker.get_num_molecules();
 
     if (packer_opts.hill_climbing_flag) {
-        size_t max_cluster_size = helper_ctx.cluster_legalizer.get_max_cluster_size();
+        size_t max_cluster_size = cluster_legalizer.get_max_cluster_size();
         clustering_data.hill_climbing_inputs_avail = new int[max_cluster_size + 1];
         for (size_t i = 0; i < max_cluster_size + 1; i++)
             clustering_data.hill_climbing_inputs_avail[i] = 0;
@@ -190,7 +190,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     /* index of next most timing critical block */
     int seed_index = 0;
-    istart = get_highest_gain_seed_molecule(seed_index, seed_atoms);
+    istart = get_highest_gain_seed_molecule(seed_index, seed_atoms, cluster_legalizer);
 
     print_pack_status_header();
 
@@ -214,14 +214,13 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             if (is_cluster_legal)
                 break;
             // Set the legalization strategy of the cluster legalizer.
-            // FIXME: Pass in the cluster legalizer.
-            helper_ctx.cluster_legalizer.set_legalization_strategy(strategy);
+            cluster_legalizer.set_legalization_strategy(strategy);
 
             LegalizationClusterId legalization_cluster_id;
 
             VTR_LOGV(verbosity > 2, "Complex block %d:\n", total_clb_num);
 
-            start_new_cluster(helper_ctx.cluster_legalizer,
+            start_new_cluster(cluster_legalizer,
                               legalization_cluster_id,
                               istart,
                               num_used_type_instances,
@@ -240,18 +239,20 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                               cluster_stats.mols_since_last_print,
                               device_ctx.grid.width(),
                               device_ctx.grid.height(),
-                              attraction_groups);
+                              attraction_groups,
+                              cluster_legalizer);
 
             VTR_LOGV(verbosity > 2,
                      "Complex block %d: '%s' (%s) ", total_clb_num,
-                     helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id)->name,
-                     helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
+                     cluster_legalizer.get_cluster_pb(legalization_cluster_id)->name,
+                     cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
             VTR_LOGV(verbosity > 2, ".");
             //Progress dot for seed-block
             fflush(stdout);
 
-            int high_fanout_threshold = high_fanout_thresholds.get_threshold(helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
+            int high_fanout_threshold = high_fanout_thresholds.get_threshold(cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
             update_cluster_stats(istart,
+                                 cluster_legalizer,
                                  is_clock,  //Set of clock nets
                                  is_global, //Set of global nets (currently all clocks)
                                  packer_opts.global_clocks,
@@ -268,17 +269,17 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 /*it doesn't make sense to do a timing analysis here since there*
                  *is only one atom block clustered it would not change anything      */
             }
-            // FIXME: This access should be a getter.
-            cur_cluster_placement_stats_ptr = &(helper_ctx.cluster_legalizer.cluster_placement_stats[helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)->index]);
+            cur_cluster_placement_stats_ptr = cluster_legalizer.get_cluster_placement_stats(legalization_cluster_id);
             cluster_stats.num_unrelated_clustering_attempts = 0;
-            next_molecule = get_molecule_for_cluster(helper_ctx.cluster_legalizer.get_cluster_pb(legalization_cluster_id),
+            next_molecule = get_molecule_for_cluster(cluster_legalizer.get_cluster_pb(legalization_cluster_id),
                                                      attraction_groups,
                                                      allow_unrelated_clustering,
                                                      packer_opts.prioritize_transitive_connectivity,
                                                      packer_opts.transitive_fanout_threshold,
                                                      packer_opts.feasible_block_array_size,
                                                      &cluster_stats.num_unrelated_clustering_attempts,
                                                      cur_cluster_placement_stats_ptr,
+                                                     cluster_legalizer,
                                                      clb_inter_blk_nets,
                                                      legalization_cluster_id,
                                                      verbosity,
@@ -306,7 +307,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             while (next_molecule != nullptr && num_repeated_molecules < max_num_repeated_molecules) {
                 prev_molecule = next_molecule;
 
-                try_fill_cluster(helper_ctx.cluster_legalizer,
+                try_fill_cluster(cluster_legalizer,
                                  packer_opts,
                                  cur_cluster_placement_stats_ptr,
                                  prev_molecule,
@@ -337,15 +338,14 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 // If the legalizer did not check everything for every molecule,
                 // need to check that the full cluster is legal (need to perform
                 // intra-lb routing).
-                is_cluster_legal = helper_ctx.cluster_legalizer.check_cluster_legality(legalization_cluster_id);
+                is_cluster_legal = cluster_legalizer.check_cluster_legality(legalization_cluster_id);
             }
 
             if (is_cluster_legal) {
-                // helper_ctx.legalized_clusters.push_back(legalization_cluster_id);
-                istart = save_cluster_routing_and_pick_new_seed(packer_opts, seed_atoms, num_blocks_hill_added, seed_index, cluster_stats);
-                store_cluster_info_and_free(packer_opts, legalization_cluster_id, logic_block_type, le_pb_type, le_count, clb_inter_blk_nets);
+                istart = save_cluster_routing_and_pick_new_seed(packer_opts, seed_atoms, cluster_legalizer, num_blocks_hill_added, seed_index, cluster_stats);
+                store_cluster_info_and_free(packer_opts, legalization_cluster_id, logic_block_type, le_pb_type, le_count, cluster_legalizer, clb_inter_blk_nets);
             } else {
-                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, saved_seed_index, num_used_type_instances, total_clb_num, seed_index);
+                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, cluster_legalizer, saved_seed_index, num_used_type_instances, total_clb_num, seed_index);
             }
         }
     }
@@ -361,7 +361,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     // Ensure that we have kept track of the number of clusters correctly.
     // TODO: The total_clb_num variable could probably just be replaced by
     //       clusters().size().
-    VTR_ASSERT(helper_ctx.cluster_legalizer.clusters().size() == (size_t)total_clb_num);
+    VTR_ASSERT(cluster_legalizer.clusters().size() == (size_t)total_clb_num);
 
     return num_used_type_instances;
 }

vpr/src/pack/cluster.h

@@ -11,11 +11,13 @@
 #include "cluster_util.h"
 
 class Prepacker;
+class ClusterLegalizer;
 
 std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& packer_opts,
                                                          const t_analysis_opts& analysis_opts,
                                                          const t_arch* arch,
                                                          Prepacker& prepacker,
+                                                         ClusterLegalizer& cluster_legalizer,
                                                          const std::unordered_set<AtomNetId>& is_clock,
                                                          const std::unordered_set<AtomNetId>& is_global,
                                                          bool allow_unrelated_clustering,