[SQUASH ME] Removed the prepacker from the global scope.

Author: AlexandreSinger

vpr/src/base/vpr_context.h

@@ -79,13 +79,6 @@ struct AtomContext : public Context {
 
     /// @brief Mappings to/from the Atom Netlist to physically described .blif models
     AtomLookup lookup;
-
-    /// @brief Prepacker object which performs prepacking and stores the pack
-    ///        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;
 };
 
 /**

vpr/src/pack/cluster.cpp

@@ -186,11 +186,17 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
     }
 
     // Assign gain scores to atoms and sort them based on the scores.
-    auto seed_atoms = initialize_seed_atoms(packer_opts.cluster_seed_type, max_molecule_stats, atom_criticality);
+    auto seed_atoms = initialize_seed_atoms(packer_opts.cluster_seed_type,
+                                            max_molecule_stats,
+                                            prepacker,
+                                            atom_criticality);
 
     /* index of next most timing critical block */
     int seed_index = 0;
-    istart = get_highest_gain_seed_molecule(seed_index, seed_atoms, cluster_legalizer);
+    istart = get_highest_gain_seed_molecule(seed_index,
+                                            seed_atoms,
+                                            prepacker,
+                                            cluster_legalizer);
 
     print_pack_status_header();
 
@@ -279,6 +285,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                      packer_opts.feasible_block_array_size,
                                                      &cluster_stats.num_unrelated_clustering_attempts,
                                                      cur_cluster_placement_stats_ptr,
+                                                     prepacker,
                                                      cluster_legalizer,
                                                      clb_inter_blk_nets,
                                                      legalization_cluster_id,
@@ -308,6 +315,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 prev_molecule = next_molecule;
 
                 try_fill_cluster(cluster_legalizer,
+                                 prepacker,
                                  packer_opts,
                                  cur_cluster_placement_stats_ptr,
                                  prev_molecule,
@@ -343,7 +351,10 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
             if (is_cluster_legal) {
                 // Pick new seed.
-                istart = get_highest_gain_seed_molecule(seed_index, seed_atoms, cluster_legalizer);
+                istart = get_highest_gain_seed_molecule(seed_index,
+                                                        seed_atoms,
+                                                        prepacker,
+                                                        cluster_legalizer);
                 // Update cluster stats.
                 if (packer_opts.timing_driven && num_blocks_hill_added > 0)
                     cluster_stats.blocks_since_last_analysis += num_blocks_hill_added;

vpr/src/pack/cluster_legalizer.cpp

@@ -955,6 +955,7 @@ static void update_molecule_chain_info(t_pack_molecule* chain_molecule, const t_
  */
 static void revert_place_atom_block(const AtomBlockId blk_id,
                                     t_lb_router_data* router_data,
+                                    const Prepacker& prepacker,
                                     vtr::vector_map<AtomBlockId, LegalizationClusterId>& atom_cluster) {
     auto& atom_ctx = g_vpr_ctx.mutable_atom();
 
@@ -971,7 +972,7 @@ static void revert_place_atom_block(const AtomBlockId blk_id,
          */
 
         t_pb* next = pb->parent_pb;
-        revalid_molecules(pb);
+        revalid_molecules(pb, prepacker);
         free_pb(pb);
         pb = next;
 
@@ -988,7 +989,7 @@ static void revert_place_atom_block(const AtomBlockId blk_id,
                     /* If the code gets here, then that means that placing the initial seed molecule
                      * failed, don't free the actual complex block itself as the seed needs to find
                      * another placement */
-                    revalid_molecules(pb);
+                    revalid_molecules(pb, prepacker);
                     free_pb(pb);
                 }
             }
@@ -1114,6 +1115,7 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
     // TODO: Remove these global accesses.
     // AtomContext used for:
     //  - printing verbose statements
+    //  - Looking up the primitive pb
     const AtomContext& atom_ctx = g_vpr_ctx.atom();
     // FloorplanningContext used for:
     //  - Checking if the atom can be placed in the cluster for floorplanning
@@ -1332,7 +1334,7 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
                         continue;
 
                     /* invalidate all molecules that share atom block with current molecule */
-                    t_pack_molecule* cur_molecule = atom_ctx.prepacker.get_atom_molecule(atom_blk_id);
+                    t_pack_molecule* cur_molecule = prepacker.get_atom_molecule(atom_blk_id);
                     // TODO: This should really be named better. Something like
                     //       "is_clustered". and then it should be set to true.
                     //       Right now, valid implies "not clustered" which is
@@ -1359,7 +1361,7 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(t_pack_molecule* molecul
             for (int i = 0; i < failed_location; i++) {
                 AtomBlockId atom_blk_id = molecule->atom_block_ids[i];
                 if (atom_blk_id) {
-                    revert_place_atom_block(atom_blk_id, cluster.router_data, atom_cluster);
+                    revert_place_atom_block(atom_blk_id, cluster.router_data, prepacker, atom_cluster);
                 }
             }
 
@@ -1504,7 +1506,7 @@ void ClusterLegalizer::destroy_cluster(LegalizationClusterId cluster_id) {
         for (int i = 0; i < molecule_size; i++) {
             AtomBlockId atom_blk_id = mol->atom_block_ids[i];
             if (atom_blk_id) {
-                revert_place_atom_block(atom_blk_id, cluster.router_data, atom_cluster);
+                revert_place_atom_block(atom_blk_id, cluster.router_data, prepacker, atom_cluster);
             }
         }
     }
@@ -1558,18 +1560,18 @@ bool ClusterLegalizer::check_cluster_legality(LegalizationClusterId cluster_id)
     return try_intra_lb_route(cluster.router_data, log_verbosity, &mode_status);
 }
 
-void ClusterLegalizer::init(const AtomNetlist& atom_netlist,
-                            const Prepacker& prepacker,
-                            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,
-                            int t_log_verbosity,
-                            int t_force_site) {
+ClusterLegalizer::ClusterLegalizer(const AtomNetlist& atom_netlist,
+                                   const Prepacker& t_prepacker,
+                                   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,
+                                   int t_log_verbosity,
+                                   int t_force_site) : prepacker(t_prepacker) {
     // Ensure that this is not being initialized twice.
     VTR_ASSERT(cluster_placement_stats == nullptr &&
                primitives_list == nullptr &&

vpr/src/pack/cluster_legalizer.h

@@ -90,27 +90,28 @@ class ClusterLegalizer {
                                           const t_ext_pin_util& max_external_pin_util);
 public:
 
-    // Default constructor. Use the init method to initialize the legalizer.
-    ClusterLegalizer() = default;
+    // Explicitly deleted default constructor. Need to use other constructor to
+    // initialize state correctly.
+    ClusterLegalizer() = delete;
 
     /*
      * @brief Initialize the ClusterLegalizer class. Must be called before use.
      *
      * Allocates internal state.
      * FIXME: See if we can simplify the parameters. Can any of these be inferred?
      */
-    void init(const AtomNetlist& atom_netlist,
-              const Prepacker& prepacker,
-              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,
-              int t_log_verbosity,
-              int t_force_site = -1);
+    ClusterLegalizer(const AtomNetlist& atom_netlist,
+                     const Prepacker& t_prepacker,
+                     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,
+                     int t_log_verbosity,
+                     int t_force_site = -1);
 
     // This class allocates and deallocates memory within. This class should not
     // be copied or moved to prevent it from double freeing / losing pointers.
@@ -297,5 +298,7 @@ class ClusterLegalizer {
 
     // TODO: Figure out what this does and why...
     int force_site;
+
+    const Prepacker& prepacker;
 };