[SQUASH ME] Removed Most Globals

AlexandreSinger · AlexandreSinger · commit b56a1273e703 · 2024-08-30T16:18:13.000-04:00
diff --git a/vpr/src/base/read_netlist.cpp b/vpr/src/base/read_netlist.cpp
@@ -77,7 +77,6 @@ ClusteredNetlist read_netlist(const char* net_file,
     std::vector<std::string> circuit_inputs, circuit_outputs, circuit_clocks;
 
     auto& atom_ctx = g_vpr_ctx.mutable_atom();
-    ClusteringHelperContext& mutable_helper_ctx = g_vpr_ctx.mutable_cl_helper();
 
     int num_primitives = 0;
 
@@ -250,13 +249,6 @@ ClusteredNetlist read_netlist(const char* net_file,
     /* load mapping between atom pins and pb_graph_pins */
     load_atom_pin_mapping(clb_nlist);
 
-    /* Load the mapping between clusters and their atoms */
-    mutable_helper_ctx.atoms_lookup.resize(clb_nlist.blocks().size());
-    for (AtomBlockId atom_blk_id : atom_ctx.nlist.blocks()) {
-        ClusterBlockId atom_cluster_blk_id = atom_ctx.lookup.atom_clb(atom_blk_id);
-        mutable_helper_ctx.atoms_lookup[atom_cluster_blk_id].insert(atom_blk_id);
-    }
-
     clock_t end = clock();
 
     VTR_LOG("Finished loading packed FPGA netlist file (took %g seconds).\n", (float)(end - begin) / CLOCKS_PER_SEC);
diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp
@@ -15,6 +15,7 @@
 #include <cstring>
 #include <cmath>
 
+#include "vpr_context.h"
 #include "vtr_assert.h"
 #include "vtr_math.h"
 #include "vtr_log.h"
@@ -695,6 +696,7 @@ void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
                    "Must have valid .net filename to load packing");
 
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
 
     /* Ensure we have a clean start with void net remapping information */
     cluster_ctx.post_routing_clb_pin_nets.clear();
@@ -705,8 +707,15 @@ void vpr_load_packing(t_vpr_setup& vpr_setup, const t_arch& arch) {
                                          vpr_setup.FileNameOpts.verify_file_digests,
                                          vpr_setup.PackerOpts.pack_verbosity);
 
+    /* Load the mapping between clusters and their atoms */
+    cluster_ctx.atoms_lookup.resize(cluster_ctx.clb_nlist.blocks().size());
+    for (AtomBlockId atom_blk_id : atom_ctx.nlist.blocks()) {
+        ClusterBlockId atom_cluster_blk_id = atom_ctx.lookup.atom_clb(atom_blk_id);
+        cluster_ctx.atoms_lookup[atom_cluster_blk_id].insert(atom_blk_id);
+    }
+
     process_constant_nets(g_vpr_ctx.mutable_atom().nlist,
-                          g_vpr_ctx.atom().lookup,
+                          atom_ctx.lookup,
                           cluster_ctx.clb_nlist,
                           vpr_setup.constant_net_method,
                           vpr_setup.PackerOpts.pack_verbosity);
diff --git a/vpr/src/base/vpr_constraints_writer.cpp b/vpr/src/base/vpr_constraints_writer.cpp
@@ -58,7 +58,6 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints,
                                              bool subtile) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& block_locs = g_vpr_ctx.placement().block_locs();
-    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
     int part_id = 0;
     /*
@@ -87,7 +86,7 @@ void setup_vpr_floorplan_constraints_one_loc(VprConstraints& constraints,
         part.set_part_region(pr);
         constraints.mutable_place_constraints().add_partition(part);
 
-        const std::unordered_set<AtomBlockId>& atoms = helper_ctx.atoms_lookup[blk_id];
+        const std::unordered_set<AtomBlockId>& atoms = cluster_ctx.atoms_lookup[blk_id];
         for (AtomBlockId atom_id : atoms) {
             constraints.mutable_place_constraints().add_constrained_atom(atom_id, partid);
         }
@@ -101,7 +100,6 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints,
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& block_locs = g_vpr_ctx.placement().block_locs();
     auto& device_ctx = g_vpr_ctx.device();
-    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
 
     const int n_layers = device_ctx.grid.get_num_layers();
 
@@ -164,7 +162,7 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints,
      * appropriate region accordingly
      */
     for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
-        const std::unordered_set<AtomBlockId>& atoms = helper_ctx.atoms_lookup[blk_id];
+        const std::unordered_set<AtomBlockId>& atoms = cluster_ctx.atoms_lookup[blk_id];
         int x = block_locs[blk_id].loc.x;
         int y = block_locs[blk_id].loc.y;
         int width = device_ctx.grid.width();
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -85,6 +85,7 @@ struct AtomContext : public Context {
     ///        molecules. Has a method to get the pack molecule of an AtomBlock.
     /// TODO: This is mainly only used in the clusterer. It can probably be
     ///       removed from the AtomContext entirely.
+    /// FIXME: Move this to the clustering helper context. It makes more sense there.
     Prepacker prepacker;
 };
 
@@ -300,6 +301,11 @@ struct ClusteringContext : public Context {
      */
     std::map<ClusterBlockId, std::map<int, ClusterNetId>> post_routing_clb_pin_nets;
     std::map<ClusterBlockId, std::map<int, int>> pre_routing_net_pin_mapping;
+
+    // A vector of unordered_sets of AtomBlockIds that are inside each clustered
+    // block [0 .. num_clustered_blocks-1]
+    // This is populated when the packing is loaded.
+    vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
 };
 
 /**
@@ -310,40 +316,14 @@ struct ClusteringContext : public Context {
  * in packing or placement stages.
  */
 struct ClusteringHelperContext : public Context {
-    // A map used to save the number of used instances from each logical block type.
-    std::map<t_logical_block_type_ptr, size_t> num_used_type_instances;
-
     /// @brief Class used to construct legal clusters.
     /// FIXME: Move this to the cluster context?
     ClusterLegalizer cluster_legalizer;
 
-    // total number of CLBs
-    // TODO: Rename to num_legalized_clusters.
-    //  - Maybe even remove this if it becomes trivial.
-    int total_clb_num;
-
     // 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.
     std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;
-
-    // the utilization of external input/output pins during packing (between 0 and 1)
-    // FIXME: This one is weird and may take some work to fix.
-    //  - Putting this in the class and then creating an accessor may fix this
-    //    issue.
-    t_ext_pin_util_targets target_external_pin_util;
-
-    // During clustering, a block is related to un-clustered primitives with nets.
-    // This relation has three types: low fanout, high fanout, and transitive
-    // high_fanout_thresholds stores the threshold for nets to a block type to be considered high fanout
-    t_pack_high_fanout_thresholds high_fanout_thresholds;
-
-    // A vector of unordered_sets of AtomBlockIds that are inside each clustered block [0 .. num_clustered_blocks-1]
-    // FIXME: This should be moved to a better place. It is populated in read
-    //        netlist and used all over the place.
-    //   - Ultimately this information can be read from the legalizer if the
-    //     legalizer can be kept alive for longer.
-    vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
 };
 
 /**
diff --git a/vpr/src/pack/cluster.cpp b/vpr/src/pack/cluster.cpp
@@ -75,6 +75,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          bool balance_block_type_utilization,
                                                          AttractionInfo& attraction_groups,
                                                          bool& floorplan_regions_overfull,
+                                                         const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                                                          t_clustering_data& clustering_data) {
     /* Does the actual work of clustering multiple netlist blocks *
      * into clusters.                                                  */
@@ -134,7 +135,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     // Index 2 holds the number of LEs that are used for registers only.
     std::vector<int> le_count(3, 0);
 
-    helper_ctx.total_clb_num = 0;
+    int total_clb_num = 0;
 
     /* TODO: This is memory inefficient, fix if causes problems */
     /* Store stats on nets used by packed block, useful for determining transitively connected blocks
@@ -218,7 +219,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
             LegalizationClusterId legalization_cluster_id;
 
-            VTR_LOGV(verbosity > 2, "Complex block %d:\n", helper_ctx.total_clb_num);
+            VTR_LOGV(verbosity > 2, "Complex block %d:\n", total_clb_num);
 
             start_new_cluster(helper_ctx.cluster_legalizer,
                               legalization_cluster_id,
@@ -233,7 +234,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
             //initial molecule in cluster has been processed
             cluster_stats.num_molecules_processed++;
             cluster_stats.mols_since_last_print++;
-            print_pack_status(helper_ctx.total_clb_num,
+            print_pack_status(total_clb_num,
                               cluster_stats.num_molecules,
                               cluster_stats.num_molecules_processed,
                               cluster_stats.mols_since_last_print,
@@ -242,14 +243,14 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                               attraction_groups);
 
             VTR_LOGV(verbosity > 2,
-                     "Complex block %d: '%s' (%s) ", helper_ctx.total_clb_num,
+                     "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);
             VTR_LOGV(verbosity > 2, ".");
             //Progress dot for seed-block
             fflush(stdout);
 
-            int high_fanout_threshold = helper_ctx.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(helper_ctx.cluster_legalizer.get_cluster_type(legalization_cluster_id)->name);
             update_cluster_stats(istart,
                                  is_clock,  //Set of clock nets
                                  is_global, //Set of global nets (currently all clocks)
@@ -260,7 +261,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                  *timing_info,
                                  attraction_groups,
                                  net_output_feeds_driving_block_input);
-            helper_ctx.total_clb_num++;
+            total_clb_num++;
 
             if (packer_opts.timing_driven) {
                 cluster_stats.blocks_since_last_analysis++;
@@ -312,7 +313,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                  next_molecule,
                                  num_repeated_molecules,
                                  cluster_stats,
-                                 helper_ctx.total_clb_num,
+                                 total_clb_num,
                                  legalization_cluster_id,
                                  attraction_groups,
                                  clb_inter_blk_nets,
@@ -344,7 +345,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 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);
             } else {
-                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, saved_seed_index, num_used_type_instances, helper_ctx.total_clb_num, seed_index);
+                free_data_and_requeue_used_mols_if_illegal(legalization_cluster_id, saved_seed_index, num_used_type_instances, total_clb_num, seed_index);
             }
         }
     }
@@ -357,6 +358,11 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     //check_floorplan_regions(floorplan_regions_overfull);
     floorplan_regions_overfull = floorplan_constraints_regions_overfull();
 
+    // 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);
+
     return num_used_type_instances;
 }
 
diff --git a/vpr/src/pack/cluster.h b/vpr/src/pack/cluster.h
@@ -22,6 +22,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          bool balance_block_type_utilization,
                                                          AttractionInfo& attraction_groups,
                                                          bool& floorplan_regions_overfull,
+                                                         const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                                                          t_clustering_data& clustering_data);
 
 void print_pb_type_count(const ClusteredNetlist& clb_nlist);
diff --git a/vpr/src/pack/cluster_legalizer.cpp b/vpr/src/pack/cluster_legalizer.cpp
@@ -1435,8 +1435,9 @@ e_block_pack_status ClusterLegalizer::add_mol_to_cluster(t_pack_molecule* molecu
     // FIXME: Handle destroyed clusters better.
     VTR_ASSERT(cluster.pb != nullptr && "Cannot destory an already destroyed cluster");
     // Set the target_external_pin_util.
-    // FIXME: Remove this access somehow.
-    t_ext_pin_util target_ext_pin_util = g_vpr_ctx.cl_helper().target_external_pin_util.get_pin_util(cluster.type->name);
+    //  - FIXME: Double check if this can be a reference or not. pass by value
+    //           may be expensive.
+    t_ext_pin_util target_ext_pin_util = target_external_pin_util.get_pin_util(cluster.type->name);
     
     e_block_pack_status pack_status = try_pack_molecule(molecule,
                                                         cluster,
@@ -1532,6 +1533,8 @@ void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
                             const std::vector<t_logical_block_type>& logical_block_types,
                             std::vector<t_lb_type_rr_node>* t_lb_type_rr_graphs,
                             size_t t_num_models,
+                            const std::vector<std::string>& target_external_pin_util_str,
+                            const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                             ClusterLegalizationStrategy t_cluster_legalization_strategy,
                             bool t_enable_pin_feasibility_filter,
                             int t_feasible_block_array_size,
@@ -1555,9 +1558,11 @@ void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
         primitives_list[i] = nullptr;
     }
     // Calculate the max cluster size
+    //  - Limit maximum number of elements for each cluster to MAX_SHORT
     max_cluster_size = calc_max_cluster_size(logical_block_types);
-    //  - Limit maximum number of elements for each cluster.
     VTR_ASSERT(max_cluster_size < MAX_SHORT);
+    // Get the target external pin utilization
+    target_external_pin_util = t_ext_pin_util_targets(target_external_pin_util_str);
     // Get a reference to the rr graphs.
     lb_type_rr_graphs = t_lb_type_rr_graphs;
     // Get the number of models in the architecture.
@@ -1570,6 +1575,7 @@ void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
     std::vector<AtomBlockId> noc_atoms = find_noc_router_atoms(atom_netlist);
     update_noc_reachability_partitions(noc_atoms,
                                        atom_netlist,
+                                       high_fanout_thresholds,
                                        atom_noc_grp_id);
     // Copy the options passed by the user
     cluster_legalization_strategy = t_cluster_legalization_strategy;
diff --git a/vpr/src/pack/cluster_legalizer.h b/vpr/src/pack/cluster_legalizer.h
@@ -113,6 +113,8 @@ class ClusterLegalizer {
               const std::vector<t_logical_block_type>& logical_block_types,
               std::vector<t_lb_type_rr_node>* t_lb_type_rr_graphs,
               size_t t_num_models,
+              const std::vector<std::string>& target_external_pin_util_str,
+              const t_pack_high_fanout_thresholds& high_fanout_thresholds,
               ClusterLegalizationStrategy t_cluster_legalization_strategy,
               bool t_enable_pin_feasibility_filter,
               int t_feasible_block_array_size,
@@ -219,6 +221,10 @@ class ClusterLegalizer {
         return atom_cluster[blk_id];
     }
 
+    inline t_ext_pin_util_targets& get_target_external_pin_util() {
+        return target_external_pin_util;
+    }
+
     inline size_t get_max_cluster_size() const {
         return max_cluster_size;
     }
@@ -302,6 +308,10 @@ class ClusterLegalizer {
 
     // FIXME: cluster_placement_stats should be private.
 
+    /// @brief The utilization of external input/output pins during packing
+    ///        (between 0 and 1).
+    t_ext_pin_util_targets target_external_pin_util;
+
     // TODO: This should also be a vector.
     t_pb_graph_node** primitives_list = nullptr;
 
diff --git a/vpr/src/pack/cluster_util.cpp b/vpr/src/pack/cluster_util.cpp
@@ -255,11 +255,7 @@ void free_clustering_data(const t_packer_opts& packer_opts,
 //check the clustering and output it
 void check_and_output_clustering(const t_packer_opts& packer_opts,
                                  const std::unordered_set<AtomNetId>& is_clock,
-                                 const t_arch* arch,
-                                 const int& num_clb) {
-    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
-
-    VTR_ASSERT(num_clb == (int)helper_ctx.cluster_legalizer.clusters().size());
+                                 const t_arch* arch) {
     check_clustering();
 
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_CLUSTERS)) {
diff --git a/vpr/src/pack/cluster_util.h b/vpr/src/pack/cluster_util.h
@@ -116,8 +116,7 @@ void free_clustering_data(const t_packer_opts& packer_opts,
 //check clustering legality and output it
 void check_and_output_clustering(const t_packer_opts& packer_opts,
                                  const std::unordered_set<AtomNetId>& is_clock,
-                                 const t_arch* arch,
-                                 const int& num_clb);
+                                 const t_arch* arch);
 
 bool is_atom_blk_in_pb(const AtomBlockId blk_id, const t_pb* pb);
 
diff --git a/vpr/src/pack/noc_aware_cluster_util.cpp b/vpr/src/pack/noc_aware_cluster_util.cpp
@@ -2,6 +2,7 @@
 #include "noc_aware_cluster_util.h"
 #include "atom_netlist.h"
 #include "globals.h"
+#include "vpr_types.h"
 
 #include <queue>
 
@@ -25,11 +26,10 @@ std::vector<AtomBlockId> find_noc_router_atoms(const AtomNetlist& atom_netlist)
 
 void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms,
                                         const AtomNetlist& atom_netlist,
+                                        const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                                         vtr::vector<AtomBlockId, NocGroupId>& atom_noc_grp_id) {
-    const ClusteringHelperContext& helper_ctx = g_vpr_ctx.cl_helper();
     const auto& grid = g_vpr_ctx.device().grid;
 
-    const auto& high_fanout_thresholds = helper_ctx.high_fanout_thresholds;
     t_logical_block_type_ptr logic_block_type = infer_logic_block_type(grid);
     const char* logical_block_name = logic_block_type != nullptr ? logic_block_type->name : "";
     const size_t high_fanout_threshold = high_fanout_thresholds.get_threshold(logical_block_name);
diff --git a/vpr/src/pack/noc_aware_cluster_util.h b/vpr/src/pack/noc_aware_cluster_util.h
@@ -22,6 +22,7 @@
 
 class AtomNetlist;
 class AtomBlockId;
+class t_pack_high_fanout_thresholds;
 
 /**
  * @brief Iterates over all atom blocks and check whether
@@ -42,6 +43,7 @@ std::vector<AtomBlockId> find_noc_router_atoms(const AtomNetlist& atom_netlist);
  */
 void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms,
                                         const AtomNetlist& atom_netlist,
+                                        const t_pack_high_fanout_thresholds& high_fanout_threshold,
                                         vtr::vector<AtomBlockId, NocGroupId>& atom_noc_grp_id);
 
 #endif
diff --git a/vpr/src/pack/pack.cpp b/vpr/src/pack/pack.cpp
diff --git a/vpr/src/pack/re_cluster.cpp b/vpr/src/pack/re_cluster.cpp
diff --git a/vpr/src/pack/re_cluster_util.cpp b/vpr/src/pack/re_cluster_util.cpp
diff --git a/vpr/src/place/place_constraints.cpp b/vpr/src/place/place_constraints.cpp
diff --git a/vpr/src/util/vpr_utils.cpp b/vpr/src/util/vpr_utils.cpp
