[APPack] Flat-Placement Informed Unrelated Clustering

Used flat placement information provided by APPack to try and select
better unrelated candidates. This searches for candidates as close to
the flat placement position of the cluster.

There are two parameters that control how this is performed:

1) max_unrelated_tile_distance decides how far the algorithm will search
   for unrelated candidates. The algorithm will check for candidates in
   the same tile as the cluster, and then will search farther and
   farther out

2) max_unrelated_clustering_attempts decides how many failing attempts
   the cluster will try unrelated clustering. This matches the option of
   the same name in the candidate selector class; but this was made
   separate since likely it will be different for APPack.

Author: AlexandreSinger

vpr/src/pack/appack_context.h

@@ -53,7 +53,7 @@ struct t_appack_options {
         CENTROID, /**< The location of the cluster is the centroid of the molecules which have been packed into it. */
         SEED      /**< The location of the cluster is the location of the first molecule packed into it. */
     };
-    e_cl_loc_ty cluster_location_ty = e_cl_loc_ty::CENTROID;
+    static constexpr e_cl_loc_ty cluster_location_ty = e_cl_loc_ty::CENTROID;
 
     // =========== Candidate gain attenuation ============================== //
     // These terms are used to update the gain of a given candidate based on
@@ -67,11 +67,11 @@ struct t_appack_options {
     // Distance threshold which decides when to use quadratic decay or inverted
     // sqrt decay. If the distance is less than this threshold, quadratic decay
     // is used. Inverted sqrt is used otherwise.
-    float dist_th = 5.0f;
+    static constexpr float dist_th = 5.0f;
     // Horizontal offset to the inverted sqrt decay.
-    float sqrt_offset = -1.1f;
+    static constexpr float sqrt_offset = -1.1f;
     // Scaling factor for the quadratic decay term.
-    float quad_fac = 0.1543f;
+    static constexpr float quad_fac = 0.1543f;
 
     // =========== Candidate selection distance ============================ //
     // When selecting candidates, what distance from the cluster will we
@@ -81,7 +81,32 @@ struct t_appack_options {
     //       types of molecules / clusters. For example, CLBs vs DSPs
     float max_candidate_distance = std::numeric_limits<float>::max();
 
-    // TODO: Investigate adding flat placement info to unrelated clustering.
+    // =========== Unrelated clustering ==================================== //
+    // After searching for candidates by connectivity and timing, the user may
+    // turn on unrelated clustering, which will allow molecules which are
+    // unrelated to the cluster being created to be attempted to be packed in.
+    // APPack uses flat placement information to decide which unrelated
+    // molecules to try.
+
+    // APPack will search for unrelated molecules in the tile which contains
+    // the flat location of the cluster. It will then look farther out, tile
+    // by tile. This parameter is the maximum distance from the cluster's tile
+    // that APPack will search. Setting this to 0 would only allow APPack to
+    // search within the cluster's tile. Setting this to a higher number would
+    // allow APPack to search farther away; but may bring in molecules which
+    // do not "want" to be in the cluster.
+    static constexpr float max_unrelated_tile_distance = 1.0f;
+
+    // Unrelated clustering occurs after all other candidate selection methods
+    // have failed. This parameter sets how many time we will attempt unrelated
+    // clustering between failures of unrelated clustering. If this is set to
+    // 1, and unrelated clustering failed for a cluster, it will not be attempted
+    // again for that cluster (note: if it succeeds, the number of attempts get
+    // reset).
+    // NOTE: A similar option exists in the candidate selector class. This was
+    //       duplicated since it is very likely that APPack would need a
+    //       different value for this option than the non-APPack flow.
+    static constexpr int max_unrelated_clustering_attempts = 2;
 
     // TODO: Investigate adding flat placement info to seed selection.
 };

vpr/src/pack/greedy_candidate_selector.cpp

@@ -8,6 +8,7 @@
 #include "greedy_candidate_selector.h"
 #include <algorithm>
 #include <cmath>
+#include <queue>
 #include <vector>
 #include "appack_context.h"
 #include "flat_placement_types.h"
@@ -16,13 +17,12 @@
 #include "attraction_groups.h"
 #include "cluster_legalizer.h"
 #include "cluster_placement.h"
-#include "globals.h"
 #include "greedy_clusterer.h"
 #include "prepack.h"
 #include "timing_info.h"
-#include "vpr_context.h"
 #include "vpr_types.h"
 #include "vtr_assert.h"
+#include "vtr_ndmatrix.h"
 #include "vtr_vector.h"
 
 /*
@@ -105,44 +105,93 @@ GreedyCandidateSelector::GreedyCandidateSelector(
     , timing_info_(timing_info)
     , appack_ctx_(appack_ctx)
     , rng_(0) {
-    // Initialize the list of molecules to pack, the clustering data, and the
-    // net info.
 
-    // Initialize unrelated clustering data.
+    // Initialize unrelated clustering data if unrelated clustering is enabled.
     if (allow_unrelated_clustering_) {
-        /* alloc and load list of molecules to pack */
-        unrelated_clustering_data_.resize(max_molecule_stats.num_used_ext_inputs + 1);
+        initialize_unrelated_clustering_data(max_molecule_stats);
+    }
+
+    /* TODO: This is memory inefficient, fix if causes problems */
+    /* Store stats on nets used by packed block, useful for determining transitively connected blocks
+     * (eg. [A1, A2, ..]->[B1, B2, ..]->C implies cluster [A1, A2, ...] and C have a weak link) */
+    clb_inter_blk_nets_.resize(atom_netlist.blocks().size());
+}
+
+void GreedyCandidateSelector::initialize_unrelated_clustering_data(const t_molecule_stats& max_molecule_stats) {
+    // Create a sorted list of molecules, sorted on decreasing molecule base
+    // gain. (Highest gain).
+    std::vector<PackMoleculeId> molecules_vector;
+    molecules_vector.assign(prepacker_.molecules().begin(), prepacker_.molecules().end());
+    std::stable_sort(molecules_vector.begin(),
+                     molecules_vector.end(),
+                     [&](PackMoleculeId a_id, PackMoleculeId b_id) {
+                         const t_pack_molecule& a = prepacker_.get_molecule(a_id);
+                         const t_pack_molecule& b = prepacker_.get_molecule(b_id);
+
+                         return a.base_gain > b.base_gain;
+                     });
+
+    if (appack_ctx_.appack_options.use_appack) {
+        /**
+         * For APPack, we build a spatial data structure where for each 1x1 grid
+         * position on the FPGA, we maintain lists of molecule candidates.
+         * The lists are in order of number of used external pins by the molecule.
+         * Within each list, the molecules are sorted by their base gain.
+         */
+        // Get the max x, y, and layer from the flat placement.
+        t_flat_pl_loc max_loc({0.0f, 0.0f, 0.0f});
+        for (PackMoleculeId mol_id : molecules_vector) {
+            t_flat_pl_loc mol_pos = get_molecule_pos(mol_id, prepacker_, appack_ctx_);
+            max_loc.x = std::max(max_loc.x, mol_pos.x);
+            max_loc.y = std::max(max_loc.y, mol_pos.y);
+            max_loc.layer = std::max(max_loc.layer, mol_pos.layer);
+        }
 
-        // Create a sorted list of molecules, sorted on decreasing molecule base
-        // gain. (Highest gain).
-        std::vector<PackMoleculeId> molecules_vector;
-        molecules_vector.assign(prepacker.molecules().begin(), prepacker.molecules().end());
-        std::stable_sort(molecules_vector.begin(),
-                         molecules_vector.end(),
-                         [&](PackMoleculeId a_id, PackMoleculeId b_id) {
-                             const t_pack_molecule& a = prepacker.get_molecule(a_id);
-                             const t_pack_molecule& b = prepacker.get_molecule(b_id);
+        VTR_ASSERT_MSG(max_loc.layer == 0,
+                       "APPack unrelated clustering does not support 3D "
+                       "FPGAs yet");
+
+        // Initialize the data structure with empty arrays with enough space
+        // for each molecule.
+        size_t flat_grid_width = max_loc.x + 1;
+        size_t flat_grid_height = max_loc.y + 1;
+        appack_unrelated_clustering_data_ =
+            vtr::NdMatrix<std::vector<std::vector<PackMoleculeId>>, 2>({flat_grid_width,
+                                                                        flat_grid_height});
+        for (size_t x = 0; x < flat_grid_width; x++) {
+            for (size_t y = 0; y < flat_grid_height; y++) {
+                appack_unrelated_clustering_data_[x][y].resize(max_molecule_stats.num_used_ext_pins + 1);
+            }
+        }
+
+        // Fill the grid with molecule information.
+        for (PackMoleculeId mol_id : molecules_vector) {
+            t_flat_pl_loc mol_pos = get_molecule_pos(mol_id, prepacker_, appack_ctx_);
 
-                             return a.base_gain > b.base_gain;
-                         });
+            //Figure out how many external inputs are used by this molecule
+            t_molecule_stats molecule_stats = prepacker_.calc_molecule_stats(mol_id, atom_netlist_);
+            int ext_inps = molecule_stats.num_used_ext_inputs;
+
+            //Insert the molecule into the unclustered lists by number of external inputs
+            auto& tile_uc_data = appack_unrelated_clustering_data_[mol_pos.x][mol_pos.y];
+            tile_uc_data[ext_inps].push_back(mol_id);
+        }
+    } else {
+        /* alloc and load list of molecules to pack */
+        unrelated_clustering_data_.resize(max_molecule_stats.num_used_ext_inputs + 1);
 
         // Push back the each molecule into the unrelated clustering data vector
         // for their external inputs. This creates individual sorted lists of
         // molecules for each number of used external inputs.
         for (PackMoleculeId mol_id : molecules_vector) {
             //Figure out how many external inputs are used by this molecule
-            t_molecule_stats molecule_stats = prepacker.calc_molecule_stats(mol_id, atom_netlist);
+            t_molecule_stats molecule_stats = prepacker_.calc_molecule_stats(mol_id, atom_netlist_);
             int ext_inps = molecule_stats.num_used_ext_inputs;
 
             //Insert the molecule into the unclustered lists by number of external inputs
             unrelated_clustering_data_[ext_inps].push_back(mol_id);
         }
     }
-
-    /* TODO: This is memory inefficient, fix if causes problems */
-    /* Store stats on nets used by packed block, useful for determining transitively connected blocks
-     * (eg. [A1, A2, ..]->[B1, B2, ..]->C implies cluster [A1, A2, ...] and C have a weak link) */
-    clb_inter_blk_nets_.resize(atom_netlist.blocks().size());
 }
 
 GreedyCandidateSelector::~GreedyCandidateSelector() {
@@ -281,6 +330,7 @@ void GreedyCandidateSelector::update_cluster_gain_stats_candidate_success(
     // Whenever a new molecule has been clustered, reset the number of
     // unrelated clustering attempts.
     num_unrelated_clustering_attempts_ = 0;
+    // cluster_gain_stats.unrelated_molecules_attempted.clear();
 
     // If using APPack, update the position of the cluster based on the addition
     // of this molecule.
@@ -673,15 +723,23 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster(
     // If we are allowing unrelated clustering and no molecule has been found,
     // get unrelated candidate for cluster.
     if (allow_unrelated_clustering_ && best_molecule == PackMoleculeId::INVALID()) {
-        if (num_unrelated_clustering_attempts_ < max_unrelated_clustering_attempts_) {
-            best_molecule = get_unrelated_candidate_for_cluster(cluster_id,
-                                                                cluster_legalizer);
-            num_unrelated_clustering_attempts_++;
-            VTR_LOGV(best_molecule && log_verbosity_ > 2,
-                     "\tFound unrelated molecule to cluster\n");
+        const t_appack_options& appack_options = appack_ctx_.appack_options;
+        if (appack_options.use_appack) {
+            if (num_unrelated_clustering_attempts_ < appack_options.max_unrelated_clustering_attempts) {
+                best_molecule = get_unrelated_candidate_for_cluster_appack(cluster_gain_stats,
+                                                                           cluster_id,
+                                                                           cluster_legalizer);
+                num_unrelated_clustering_attempts_++;
+            }
         } else {
-            num_unrelated_clustering_attempts_ = 0;
+            if (num_unrelated_clustering_attempts_ < max_unrelated_clustering_attempts_) {
+                best_molecule = get_unrelated_candidate_for_cluster(cluster_id,
+                                                                    cluster_legalizer);
+                num_unrelated_clustering_attempts_++;
+            }
         }
+        VTR_LOGV(best_molecule && log_verbosity_ > 2,
+                 "\tFound unrelated molecule to cluster\n");
     } else {
         VTR_LOGV(!best_molecule && log_verbosity_ > 2,
                  "\tNo related molecule found and unrelated clustering disabled\n");
@@ -1154,6 +1212,112 @@ PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster(
     return PackMoleculeId::INVALID();
 }
 
+PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster_appack(
+    ClusterGainStats& cluster_gain_stats,
+    LegalizationClusterId cluster_id,
+    const ClusterLegalizer& cluster_legalizer) {
+
+    /**
+     * For APPack, we want to find a close candidate with the highest number
+     * of available inputs which could be packed into the given cluster.
+     * We will search for candidates in a BFS manner, where we will search in
+     * the same 1x1 grid location of the cluster for a compatible candidate, and
+     * will then search out if none can be found.
+     *
+     * Here, a molecule is compatible if:
+     *  - It has not been clustered already
+     *  - The number of inputs it has available is less than or equal to the
+     *    number of inputs available in the cluster.
+     *  - It has not tried to be packed in this cluster before.
+     *  - It is compatible with the cluster.
+     */
+
+    VTR_ASSERT_MSG(allow_unrelated_clustering_,
+                   "Cannot get unrelated candidates when unrelated clustering "
+                   "is disabled");
+
+    VTR_ASSERT_MSG(appack_ctx_.appack_options.use_appack,
+                   "APPack is disabled, cannot get unrelated clusters using "
+                   "flat placement information");
+
+    // The cluster will likely have more inputs available than a single molecule
+    // would have available (clusters have more pins). Clamp the inputs available
+    // to the max number of inputs a molecule could have.
+    size_t inputs_avail = cluster_legalizer.get_num_cluster_inputs_available(cluster_id);
+    VTR_ASSERT_SAFE(!appack_unrelated_clustering_data_.empty());
+    size_t max_molecule_inputs_avail = appack_unrelated_clustering_data_[0][0].size() - 1;
+    if (inputs_avail >= max_molecule_inputs_avail) {
+        inputs_avail = max_molecule_inputs_avail;
+    }
+
+    // Create a queue of locations to search and a map of visited grid locations.
+    std::queue<t_flat_pl_loc> search_queue;
+    vtr::NdMatrix<bool, 2> visited({appack_unrelated_clustering_data_.dim_size(0),
+                                    appack_unrelated_clustering_data_.dim_size(1)},
+                                   false);
+    // Push the position of the cluster to the queue.
+    search_queue.push(cluster_gain_stats.flat_cluster_position);
+
+    while (!search_queue.empty()) {
+        // Pop a position to search from the queue.
+        const t_flat_pl_loc& node_loc = search_queue.front();
+        VTR_ASSERT_SAFE(node_loc.layer == 0);
+
+        // If this position is too far from the source, skip it.
+        float dist = get_manhattan_distance(node_loc, cluster_gain_stats.flat_cluster_position);
+        if (dist > 1) {
+            search_queue.pop();
+            continue;
+        }
+
+        // If this position has been visited, skip it.
+        if (visited[node_loc.x][node_loc.y]) {
+            search_queue.pop();
+            continue;
+        }
+        visited[node_loc.x][node_loc.y] = true;
+
+        // Explore this position from highest number of inputs available to lowest.
+        const auto& uc_data = appack_unrelated_clustering_data_[node_loc.x][node_loc.y];
+        VTR_ASSERT_SAFE(inputs_avail < uc_data.size());
+        for (int ext_inps = inputs_avail; ext_inps >= 0; ext_inps--) {
+            // Get the molecule by the number of external inputs.
+            for (PackMoleculeId mol_id : uc_data[ext_inps]) {
+                // If this molecule has been clustered, skip it.
+                if (cluster_legalizer.is_mol_clustered(mol_id))
+                    continue;
+                // If this molecule has tried to be packed before and failed
+                // do not try it. This also means that this molecule may be
+                // related to this cluster in some way.
+                if (cluster_gain_stats.mol_failures.find(mol_id) != cluster_gain_stats.mol_failures.end())
+                    continue;
+                // If this molecule is not compatible with the current cluster
+                // skip it.
+                if (!cluster_legalizer.is_molecule_compatible(mol_id, cluster_id))
+                    continue;
+                // Return this molecule as the unrelated candidate.
+                return mol_id;
+            }
+        }
+
+        // Push the neighbors of the position to the queue.
+        if (node_loc.x >= 1.0f)
+            search_queue.push({node_loc.x - 1, node_loc.y, node_loc.layer});
+        if (node_loc.x <= visited.dim_size(0) - 2)
+            search_queue.push({node_loc.x + 1, node_loc.y, node_loc.layer});
+        if (node_loc.y >= 1.0f)
+            search_queue.push({node_loc.x, node_loc.y - 1, node_loc.layer});
+        if (node_loc.y <= visited.dim_size(1) - 2)
+            search_queue.push({node_loc.x, node_loc.y + 1, node_loc.layer});
+
+        // Pop the position off the queue.
+        search_queue.pop();
+    }
+
+    // No molecule could be found. Return an invalid ID.
+    return PackMoleculeId::INVALID();
+}
+
 void GreedyCandidateSelector::update_candidate_selector_finalize_cluster(
     ClusterGainStats& cluster_gain_stats,
     LegalizationClusterId cluster_id) {