[SQUASH ME] Removed Max Cluster Size and NoC Grp ID global variables

AlexandreSinger · AlexandreSinger · commit 2e66dc25a256 · 2024-08-30T11:35:48.000-04:00
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -317,9 +317,6 @@ struct ClusteringHelperContext : public Context {
     /// FIXME: Move this to the cluster context?
     ClusterLegalizer cluster_legalizer;
 
-    // FIXME: This can be removed by adding an accessor to the cluster legalizer.
-    int max_cluster_size;
-
     // total number of CLBs
     // TODO: Rename to num_legalized_clusters.
     //  - Maybe even remove this if it becomes trivial.
@@ -347,11 +344,6 @@ struct ClusteringHelperContext : public Context {
     //   - 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;
-
-    /** Stores the NoC group ID of each atom block. Atom blocks that belong
-     * to different NoC groups can't be clustered with each other into the
-     * same clustered block.*/
-    vtr::vector<AtomBlockId, NocGroupId> atom_noc_grp_id;
 };
 
 /**
diff --git a/vpr/src/pack/cluster.cpp b/vpr/src/pack/cluster.cpp
@@ -100,7 +100,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     t_cluster_progress_stats cluster_stats;
 
     //int num_molecules, num_molecules_processed, mols_since_last_print, blocks_since_last_analysis,
-    int num_blocks_hill_added, max_pb_depth;
+    int num_blocks_hill_added;
 
     const int verbosity = packer_opts.pack_verbosity;
 
@@ -143,23 +143,16 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     istart = nullptr;
 
-    /* determine bound on cluster size and primitive input size */
-    helper_ctx.max_cluster_size = 0;
-    max_pb_depth = 0;
-
     const t_molecule_stats max_molecule_stats = prepacker.calc_max_molecule_stats(atom_ctx.nlist);
 
     prepacker.mark_all_molecules_valid();
 
     cluster_stats.num_molecules = prepacker.get_num_molecules();
 
-    // FIXME: The cluster legalizer has max_cluster size within it. We should
-    //        use it!
-    get_max_cluster_size_and_pb_depth(helper_ctx.max_cluster_size, max_pb_depth);
-
     if (packer_opts.hill_climbing_flag) {
-        clustering_data.hill_climbing_inputs_avail = new int[helper_ctx.max_cluster_size + 1];
-        for (int i = 0; i < helper_ctx.max_cluster_size + 1; i++)
+        size_t max_cluster_size = helper_ctx.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;
     } else {
         clustering_data.hill_climbing_inputs_avail = nullptr; /* if used, die hard */
@@ -183,9 +176,6 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     cluster_stats.blocks_since_last_analysis = 0;
     num_blocks_hill_added = 0;
 
-    VTR_ASSERT(helper_ctx.max_cluster_size < MAX_SHORT);
-    /* Limit maximum number of elements for each cluster */
-
     //Default criticalities set to zero (e.g. if not timing driven)
     vtr::vector<AtomBlockId, float> atom_criticality(atom_ctx.nlist.blocks().size(), 0.);
 
diff --git a/vpr/src/pack/cluster_legalizer.cpp b/vpr/src/pack/cluster_legalizer.cpp
@@ -22,6 +22,7 @@
 #include "globals.h"
 #include "logic_types.h"
 #include "netlist_utils.h"
+#include "noc_aware_cluster_util.h"
 #include "noc_data_types.h"
 #include "pack_types.h"
 #include "partition.h"
@@ -39,7 +40,7 @@
 /*
  * @brief Gets the max cluster size that any logical block can have.
  */
-static size_t get_max_cluster_size(const std::vector<t_logical_block_type>& logical_block_types) {
+static size_t calc_max_cluster_size(const std::vector<t_logical_block_type>& logical_block_types) {
     size_t max_cluster_size = 0;
     for (const t_logical_block_type& blk_type : logical_block_types) {
         if (is_empty_type(&blk_type))
@@ -1089,9 +1090,6 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
     //  - Checking if the atom can be placed in the cluster for floorplanning
     //    constraints.
     const FloorplanningContext& floorplanning_ctx = g_vpr_ctx.floorplanning();
-    // ClusteringHelperContext used for:
-    //  - Getting the atom noc group IDs
-    const ClusteringHelperContext& cl_helper_ctx = g_vpr_ctx.cl_helper();
     if (log_verbosity > 3) {
         AtomBlockId root_atom = molecule->atom_block_ids[molecule->root];
         VTR_LOG("\t\tTry pack molecule: '%s' (%s)",
@@ -1157,8 +1155,7 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
         if (atom_blk_id) {
             bool block_pack_noc_grp_status = check_cluster_noc_group(atom_blk_id,
                                                                      new_cluster_noc_grp_id,
-                                                                     // FIXME: Get this global access out of here!
-                                                                     cl_helper_ctx.atom_noc_grp_id,
+                                                                     atom_noc_grp_id,
                                                                      log_verbosity);
             if (!block_pack_noc_grp_status) {
                 // Record the failure of this molecule in the current pb stats
@@ -1558,13 +1555,22 @@ void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
         primitives_list[i] = nullptr;
     }
     // Calculate the max cluster size
-    max_cluster_size = get_max_cluster_size(logical_block_types);
+    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 a reference to the rr graphs.
     lb_type_rr_graphs = t_lb_type_rr_graphs;
     // Get the number of models in the architecture.
     // FIXME: This should probably be caclulated in here since it is possible
     //        this gets messed up.
     num_models = t_num_models;
+    // Find all NoC router atoms.
+    //  - TODO: There is a bit of global state in these methods that we can
+    //          remove somewhat easily.
+    std::vector<AtomBlockId> noc_atoms = find_noc_router_atoms(atom_netlist);
+    update_noc_reachability_partitions(noc_atoms,
+                                       atom_netlist,
+                                       atom_noc_grp_id);
     // Copy the options passed by the user
     cluster_legalization_strategy = t_cluster_legalization_strategy;
     enable_pin_feasibility_filter = t_enable_pin_feasibility_filter;
diff --git a/vpr/src/pack/cluster_legalizer.h b/vpr/src/pack/cluster_legalizer.h
@@ -219,6 +219,10 @@ class ClusterLegalizer {
         return atom_cluster[blk_id];
     }
 
+    inline size_t get_max_cluster_size() const {
+        return max_cluster_size;
+    }
+
     // FIXME: Consider renaming?
     //  - is_atom_clustered?
     //  - Maybe use the inverse. May be more likely to ask if an atom is unclustered?
@@ -291,6 +295,11 @@ class ClusterLegalizer {
 
     vtr::vector_map<AtomBlockId, LegalizationClusterId> atom_cluster;
 
+    /// @brief Stores the NoC group ID of each atom block. Atom blocks that
+    ///        belong to different NoC groups can't be clustered with each other
+    ///        into the same clustered block.
+    vtr::vector<AtomBlockId, NocGroupId> atom_noc_grp_id;
+
     // FIXME: cluster_placement_stats should be private.
 
     // TODO: This should also be a vector.
diff --git a/vpr/src/pack/cluster_util.cpp b/vpr/src/pack/cluster_util.cpp
@@ -6,7 +6,6 @@
 #include "PreClusterDelayCalculator.h"
 #include "atom_netlist.h"
 #include "cluster_legalizer.h"
-#include "cluster_router.h"
 #include "cluster_placement.h"
 #include "concrete_timing_info.h"
 #include "output_clustering.h"
@@ -277,26 +276,6 @@ void check_and_output_clustering(const t_packer_opts& packer_opts,
     // VTR_ASSERT(cluster_ctx.clb_nlist.blocks().size() == intra_lb_routing.size());
 }
 
-void get_max_cluster_size_and_pb_depth(int& max_cluster_size,
-                                       int& max_pb_depth) {
-    auto& device_ctx = g_vpr_ctx.mutable_device();
-    int cur_cluster_size, cur_pb_depth;
-
-    for (const auto& type : device_ctx.logical_block_types) {
-        if (is_empty_type(&type))
-            continue;
-
-        cur_cluster_size = get_max_primitives_in_pb_type(type.pb_type);
-        cur_pb_depth = get_max_depth_of_pb_type(type.pb_type);
-        if (cur_cluster_size > max_cluster_size) {
-            max_cluster_size = cur_cluster_size;
-        }
-        if (cur_pb_depth > max_pb_depth) {
-            max_pb_depth = cur_pb_depth;
-        }
-    }
-}
-
 /*print the header for the clustering progress table*/
 void print_pack_status_header() {
     VTR_LOG("Starting Clustering - Clustering Progress: \n");
diff --git a/vpr/src/pack/cluster_util.h b/vpr/src/pack/cluster_util.h
@@ -119,9 +119,6 @@ void check_and_output_clustering(const t_packer_opts& packer_opts,
                                  const t_arch* arch,
                                  const int& num_clb);
 
-void get_max_cluster_size_and_pb_depth(int& max_cluster_size,
-                                       int& max_pb_depth);
-
 bool is_atom_blk_in_pb(const AtomBlockId blk_id, const t_pb* pb);
 
 void add_molecule_to_pb_stats_candidates(t_pack_molecule* molecule,
diff --git a/vpr/src/pack/noc_aware_cluster_util.cpp b/vpr/src/pack/noc_aware_cluster_util.cpp
@@ -1,21 +1,20 @@
 
 #include "noc_aware_cluster_util.h"
+#include "atom_netlist.h"
 #include "globals.h"
 
 #include <queue>
 
-std::vector<AtomBlockId> find_noc_router_atoms() {
-    const auto& atom_ctx = g_vpr_ctx.atom();
-
+std::vector<AtomBlockId> find_noc_router_atoms(const AtomNetlist& atom_netlist) {
     // NoC router atoms are expected to have a specific blif model
     const std::string noc_router_blif_model_name = "noc_router_adapter_block";
 
     // stores found NoC router atoms
     std::vector<AtomBlockId> noc_router_atoms;
 
     // iterate over all atoms and find those whose blif model matches
-    for (auto atom_id : atom_ctx.nlist.blocks()) {
-        const t_model* model = atom_ctx.nlist.block_model(atom_id);
+    for (auto atom_id : atom_netlist.blocks()) {
+        const t_model* model = atom_netlist.block_model(atom_id);
         if (noc_router_blif_model_name == model->name) {
             noc_router_atoms.push_back(atom_id);
         }
@@ -24,22 +23,23 @@ std::vector<AtomBlockId> find_noc_router_atoms() {
     return noc_router_atoms;
 }
 
-void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms) {
-    const auto& atom_ctx = g_vpr_ctx.atom();
-    auto& cl_helper_ctx = g_vpr_ctx.mutable_cl_helper();
-    const auto& high_fanout_thresholds = g_vpr_ctx.cl_helper().high_fanout_thresholds;
+void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms,
+                                        const AtomNetlist& atom_netlist,
+                                        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);
 
     // get the total number of atoms
-    const size_t n_atoms = atom_ctx.nlist.blocks().size();
+    const size_t n_atoms = atom_netlist.blocks().size();
 
     vtr::vector<AtomBlockId, bool> atom_visited(n_atoms, false);
 
-    cl_helper_ctx.atom_noc_grp_id.resize(n_atoms, NocGroupId::INVALID());
+    atom_noc_grp_id.resize(n_atoms, NocGroupId::INVALID());
 
     int noc_grp_id_cnt = 0;
 
@@ -68,24 +68,24 @@ void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atom
             AtomBlockId current_atom = q.front();
             q.pop();
 
-            cl_helper_ctx.atom_noc_grp_id[current_atom] = noc_grp_id;
+            atom_noc_grp_id[current_atom] = noc_grp_id;
 
-            for(auto pin : atom_ctx.nlist.block_pins(current_atom)) {
-                AtomNetId net_id = atom_ctx.nlist.pin_net(pin);
-                size_t net_fanout = atom_ctx.nlist.net_sinks(net_id).size();
+            for(auto pin : atom_netlist.block_pins(current_atom)) {
+                AtomNetId net_id = atom_netlist.pin_net(pin);
+                size_t net_fanout = atom_netlist.net_sinks(net_id).size();
 
                 if (net_fanout >= high_fanout_threshold) {
                     continue;
                 }
 
-                AtomBlockId driver_atom_id = atom_ctx.nlist.net_driver_block(net_id);
+                AtomBlockId driver_atom_id = atom_netlist.net_driver_block(net_id);
                 if (!atom_visited[driver_atom_id]) {
                     q.push(driver_atom_id);
                     atom_visited[driver_atom_id] = true;
                 }
 
-                for (auto sink_pin : atom_ctx.nlist.net_sinks(net_id)) {
-                    AtomBlockId sink_atom_id = atom_ctx.nlist.pin_block(sink_pin);
+                for (auto sink_pin : atom_netlist.net_sinks(net_id)) {
+                    AtomBlockId sink_atom_id = atom_netlist.pin_block(sink_pin);
                     if (!atom_visited[sink_atom_id]) {
                         q.push(sink_atom_id);
                         atom_visited[sink_atom_id] = true;
@@ -96,4 +96,4 @@ void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atom
         }
 
     }
-}
+}
diff --git a/vpr/src/pack/noc_aware_cluster_util.h b/vpr/src/pack/noc_aware_cluster_util.h
@@ -17,16 +17,19 @@
  */
 
 #include <vector>
+#include "noc_data_types.h"
+#include "vtr_vector.h"
 
-#include "vpr_types.h"
+class AtomNetlist;
+class AtomBlockId;
 
 /**
  * @brief Iterates over all atom blocks and check whether
  * their blif model is the same as a NoC routers.
  *
  * @return The atom block IDs of the NoC router blocks in the netlist.
  */
-std::vector<AtomBlockId> find_noc_router_atoms();
+std::vector<AtomBlockId> find_noc_router_atoms(const AtomNetlist& atom_netlist);
 
 
 /**
@@ -37,6 +40,8 @@ std::vector<AtomBlockId> find_noc_router_atoms();
  *
  * @param noc_atoms The atom block IDs of the NoC router blocks in the netlist.
  */
-void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms);
+void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms,
+                                        const AtomNetlist& atom_netlist,
+                                        vtr::vector<AtomBlockId, NocGroupId>& atom_noc_grp_id);
 
 #endif
diff --git a/vpr/src/pack/pack.cpp b/vpr/src/pack/pack.cpp
@@ -13,7 +13,6 @@
 #include "pack.h"
 #include "cluster.h"
 #include "SetupGrid.h"
-#include "noc_aware_cluster_util.h"
 
 /* #define DUMP_PB_GRAPH 1 */
 /* #define DUMP_BLIF_INPUT 1 */
@@ -107,15 +106,14 @@ bool try_pack(t_packer_opts* packer_opts,
     int pack_iteration = 1;
     bool floorplan_regions_overfull = false;
 
-    // find all NoC router atoms
-    // FIXME: This belongs in the legalizer.
-    auto noc_atoms = find_noc_router_atoms();
-    update_noc_reachability_partitions(noc_atoms);
-
     while (true) {
         free_clustering_data(*packer_opts, clustering_data);
 
         // Initialize the cluster legalizer.
+        // FIXME: To make things faster, maybe the reset method brings it back
+        //        to its init state?
+        //    - That way we can initialize once. But perhaps this is not worth
+        //      the effort.
         helper_ctx.cluster_legalizer.init(atom_ctx.nlist,
                                           atom_ctx.prepacker,
                                           device_ctx.logical_block_types,
diff --git a/vpr/src/pack/re_cluster_util.cpp b/vpr/src/pack/re_cluster_util.cpp
