Change GreedySeedSelector to work with molecules instead of atoms

Author: AmirhosseinPoolad

vpr/src/pack/greedy_clusterer.cpp

@@ -144,8 +144,7 @@ GreedyClusterer::do_clustering(ClusterLegalizer& cluster_legalizer,
                                      pre_cluster_timing_manager_);
 
     // Pick the first seed molecule.
-    PackMoleculeId seed_mol_id = seed_selector.get_next_seed(prepacker,
-                                                             cluster_legalizer);
+    PackMoleculeId seed_mol_id = seed_selector.get_next_seed(cluster_legalizer);
 
     /****************************************************************
      * Clustering
@@ -213,8 +212,7 @@ GreedyClusterer::do_clustering(ClusterLegalizer& cluster_legalizer,
                           cluster_legalizer);
 
         // Pick new seed.
-        seed_mol_id = seed_selector.get_next_seed(prepacker,
-                                                  cluster_legalizer);
+        seed_mol_id = seed_selector.get_next_seed(cluster_legalizer);
     }
 
     // If this architecture has LE physical block, report its usage.

vpr/src/pack/greedy_seed_selector.cpp

@@ -9,6 +9,8 @@
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
+#include <vector>
 #include "PreClusterTimingManager.h"
 #include "atom_netlist.h"
 #include "cluster_legalizer.h"
@@ -129,11 +131,12 @@ static inline float get_seed_gain(AtomBlockId blk_id,
  *        criticalities.
  */
 static inline void print_seed_gains(const char* fname,
-                                    const std::vector<AtomBlockId>& seed_atoms,
-                                    const vtr::vector<AtomBlockId, float>& atom_gain,
+                                    const std::vector<PackMoleculeId>& seed_mols,
+                                    const vtr::vector<PackMoleculeId, float>& molecule_gain,
                                     const vtr::vector<AtomBlockId, float>& atom_criticality,
                                     const AtomNetlist& atom_netlist,
-                                    const LogicalModels& models) {
+                                    const LogicalModels& models,
+                                    const Prepacker& prepacker) {
     FILE* fp = vtr::fopen(fname, "w");
 
     // For pretty formatting determine the maximum name length
@@ -148,16 +151,18 @@ static inline void print_seed_gains(const char* fname,
 
     fprintf(fp, "%-*s %-*s %8s %8s\n", max_name_len, "atom_block_name", max_type_len, "atom_block_type", "gain", "criticality");
     fprintf(fp, "\n");
-    for (auto blk_id : seed_atoms) {
-        std::string name = atom_netlist.block_name(blk_id);
-        fprintf(fp, "%-*s ", max_name_len, name.c_str());
+    for (auto mol_id : seed_mols) {
+        for (AtomBlockId blk_id : prepacker.get_molecule(mol_id).atom_block_ids) {
+            std::string name = atom_netlist.block_name(blk_id);
+            fprintf(fp, "%-*s ", max_name_len, name.c_str());
 
-        std::string model_name = models.model_name(atom_netlist.block_model(blk_id));
-        fprintf(fp, "%-*s ", max_type_len, model_name.c_str());
+            std::string model_name = models.model_name(atom_netlist.block_model(blk_id));
+            fprintf(fp, "%-*s ", max_type_len, model_name.c_str());
 
-        fprintf(fp, "%*f ", std::max((int)strlen("gain"), 8), atom_gain[blk_id]);
-        fprintf(fp, "%*f ", std::max((int)strlen("criticality"), 8), atom_criticality[blk_id]);
-        fprintf(fp, "\n");
+            fprintf(fp, "%*f ", std::max((int)strlen("gain"), 8), molecule_gain[mol_id]);
+            fprintf(fp, "%*f ", std::max((int)strlen("criticality"), 8), atom_criticality[blk_id]);
+            fprintf(fp, "\n");
+        }
     }
 
     fclose(fp);
@@ -169,7 +174,7 @@ GreedySeedSelector::GreedySeedSelector(const AtomNetlist& atom_netlist,
                                        const t_molecule_stats& max_molecule_stats,
                                        const LogicalModels& models,
                                        const PreClusterTimingManager& pre_cluster_timing_manager)
-    : seed_atoms_(atom_netlist.blocks().begin(), atom_netlist.blocks().end()) {
+    : seed_mols_(prepacker.molecules().begin(), prepacker.molecules().end()) {
     // Seed atoms list is initialized with all atoms in the atom netlist.
 
     // Pre-compute the criticality of each atom
@@ -186,17 +191,28 @@ GreedySeedSelector::GreedySeedSelector(const AtomNetlist& atom_netlist,
     // Maintain a lookup table of the seed gain for each atom. This will be
     // used to sort the seed atoms.
     // Initially all gains are zero.
-    vtr::vector<AtomBlockId, float> atom_gains(atom_netlist.blocks().size(), 0.f);
-
-    // Get the seed gain of each atom.
-    for (AtomBlockId blk_id : atom_netlist.blocks()) {
-        atom_gains[blk_id] = get_seed_gain(blk_id,
-                                           atom_netlist,
-                                           prepacker,
-                                           models,
-                                           seed_type,
-                                           max_molecule_stats,
-                                           atom_criticality);
+    vtr::vector<PackMoleculeId, float> molecule_gains(seed_mols_.size(), 0.f);
+
+    // Get the seed gain of each molecule.
+    for (PackMoleculeId mol_id : seed_mols_) {
+        // Gain of each molecule is the maximum gain of its atoms
+        float mol_gain = std::numeric_limits<float>::lowest();
+        const std::vector<AtomBlockId>& molecule_atoms = prepacker.get_molecule(mol_id).atom_block_ids;
+        for (AtomBlockId blk_id : molecule_atoms) {
+            // If the molecule does not fit the entire pack pattern, it's possible to have invalid block ids in the molecule_atoms vector
+            if (blk_id == AtomBlockId::INVALID()) {
+                continue;
+            }
+            float atom_gain = get_seed_gain(blk_id,
+                                            atom_netlist,
+                                            prepacker,
+                                            models,
+                                            seed_type,
+                                            max_molecule_stats,
+                                            atom_criticality);
+            mol_gain = std::max(mol_gain, atom_gain);
+        }
+        molecule_gains[mol_id] = mol_gain;
     }
 
     // Sort seeds in descending order of seed gain (i.e. highest seed gain first)
@@ -207,15 +223,15 @@ GreedySeedSelector::GreedySeedSelector(const AtomNetlist& atom_netlist,
     // std::sort which does not specify how equal values are handled). Using a stable
     // sort ensures that regardless of the underlying sorting algorithm the same seed
     // order is produced regardless of compiler.
-    auto by_descending_gain = [&](const AtomBlockId lhs, const AtomBlockId rhs) {
-        return atom_gains[lhs] > atom_gains[rhs];
+    auto by_descending_gain = [&](const PackMoleculeId lhs, const PackMoleculeId rhs) {
+        return molecule_gains[lhs] > molecule_gains[rhs];
     };
-    std::stable_sort(seed_atoms_.begin(), seed_atoms_.end(), by_descending_gain);
+    std::stable_sort(seed_mols_.begin(), seed_mols_.end(), by_descending_gain);
 
     // Print the seed gains if requested.
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_CLUSTERING_BLOCK_CRITICALITIES)) {
         print_seed_gains(getEchoFileName(E_ECHO_CLUSTERING_BLOCK_CRITICALITIES),
-                         seed_atoms_, atom_gains, atom_criticality, atom_netlist, models);
+                         seed_mols_, molecule_gains, atom_criticality, atom_netlist, models, prepacker);
     }
 
     // Set the starting seed index (the index of the first molecule to propose).
@@ -224,25 +240,20 @@ GreedySeedSelector::GreedySeedSelector(const AtomNetlist& atom_netlist,
     seed_index_ = 0;
 }
 
-PackMoleculeId GreedySeedSelector::get_next_seed(const Prepacker& prepacker,
-                                                 const ClusterLegalizer& cluster_legalizer) {
-    while (seed_index_ < seed_atoms_.size()) {
+PackMoleculeId GreedySeedSelector::get_next_seed(const ClusterLegalizer& cluster_legalizer) {
+    while (seed_index_ < seed_mols_.size()) {
         // Get the current seed atom at the seed index and increment the
         // seed index.
         // All previous seed indices have been either proposed already or
         // are already clustered. This process assumes that once an atom
         // is clustered it will never become unclustered.
-        AtomBlockId seed_blk_id = seed_atoms_[seed_index_++];
+        PackMoleculeId seed_molecule_id = seed_mols_[seed_index_++];
 
         // If this atom has been clustered, it cannot be proposed as a seed.
         // Skip to the next seed.
-        if (cluster_legalizer.is_atom_clustered(seed_blk_id))
+        if (cluster_legalizer.is_mol_clustered(seed_molecule_id)) {
             continue;
-
-        // Get the molecule that contains this atom and return it as the
-        // next seed.
-        PackMoleculeId seed_molecule_id = prepacker.get_atom_molecule(seed_blk_id);
-        VTR_ASSERT(!cluster_legalizer.is_mol_clustered(seed_molecule_id));
+        }
         return seed_molecule_id;
     }
 

vpr/src/pack/greedy_seed_selector.h

@@ -75,8 +75,7 @@ class GreedySeedSelector {
      *              clusters. This is used to check if a molecule has already
      *              been clustered or not.
      */
-    PackMoleculeId get_next_seed(const Prepacker& prepacker,
-                                 const ClusterLegalizer& cluster_legalizer);
+    PackMoleculeId get_next_seed(const ClusterLegalizer& cluster_legalizer);
 
     // TODO: Maybe create an update_seed_gains method to update the seed atoms
     //       list using current clustering information.
@@ -87,13 +86,8 @@ class GreedySeedSelector {
     ///        are proposed.
     size_t seed_index_;
 
-    /// @brief A list of seed atoms, sorted in decreasing order of gain. This
+    /// @brief A list of seed molecules, sorted in decreasing order of gain. This
     ///        is computed in the constructor and is traversed when a new seed
     ///        is being proposed.
-    // FIXME: This should really be seed molecules. It looks like the only
-    //        reason it isn't is because of the atom criticality. May want to
-    //        create the concept of molecule criticality. Currently, the max
-    //        criticality of any block in the molecule is technically being
-    //        used.
-    std::vector<AtomBlockId> seed_atoms_;
+    std::vector<PackMoleculeId> seed_mols_;
 };