[APPack] Updated Comments and Small Bug Fix

Author: AlexandreSinger

vpr/src/pack/appack_context.h

@@ -87,9 +87,11 @@ struct t_appack_options {
     std::vector<float> max_unrelated_tile_distance;
 
     // 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
+    // have failed. This attempts to cluster in molecules that are not attracted
+    // (using the packer's heuristics) to the molecules within a given cluster.
+    // This parameter sets how many times we will attempt unrelated
+    // clustering between failures of unrelated clustering. If a molecule used
+    // for unrelated clustering failed to 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
@@ -131,8 +133,9 @@ struct APPackContext : public Context {
                                                 device_grid);
         }
 
-        // By default, when unrelated clustering is on, search for unrelated molecules
-        // that are within 1 tile from the centroid of the cluster.
+        // Set the max unrelated tile distances for all logical block types.
+        // By default, we set this to a low value to only allow unrelated molecules
+        // that are very close to the cluster being created.
         // NOTE: Molecules within the same tile as the centroid are considered to have
         //       0 distance. The distance is computed relative to the bounds of the
         //       tile containing the centroid.

vpr/src/pack/appack_max_dist_th_manager.h

@@ -139,7 +139,7 @@ class APPackMaxDistThManager {
     ///        This is initialized in the constructor and accessed during packing.
     std::vector<float> logical_block_dist_thresholds_;
 
-    /// @brief This is the maximum minhattan distance possible on the device. This
+    /// @brief This is the maximum manhattan distance possible on the device. This
     ///        is the distance of traveling from the bottom-left corner of the device
     ///        to the top right.
     float max_distance_on_device_;

vpr/src/pack/greedy_candidate_selector.cpp

@@ -1296,6 +1296,15 @@ PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster_appa
             continue;
         }
 
+        // If the distance from the cluster to the current tile is larger than
+        // the best molecule's distance plus the farthest distance within the
+        // 1x1 tile (2.0), there cannot exist a molecule within the tile with a
+        // better distance than what we have found.
+        if (dist >= best_distance + 2.0) {
+            search_queue.pop();
+            break;
+        }
+
         // If this position has been visited, skip it.
         if (visited[node_loc.x][node_loc.y]) {
             search_queue.pop();
@@ -1352,11 +1361,11 @@ PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster_appa
         //       since they should be closer.
         if (node_loc.x >= 1)
             search_queue.push({node_loc.x - 1, node_loc.y, node_loc.layer_num});
-        if (node_loc.x <= (int)visited.dim_size(0) - 2)
+        if (node_loc.x <= (int)appack_unrelated_clustering_data_.dim_size(0) - 2)
             search_queue.push({node_loc.x + 1, node_loc.y, node_loc.layer_num});
         if (node_loc.y >= 1)
             search_queue.push({node_loc.x, node_loc.y - 1, node_loc.layer_num});
-        if (node_loc.y <= (int)visited.dim_size(1) - 2)
+        if (node_loc.y <= (int)appack_unrelated_clustering_data_.dim_size(1) - 2)
             search_queue.push({node_loc.x, node_loc.y + 1, node_loc.layer_num});
 
         // Pop the position off the queue.

vpr/src/pack/pack.cpp

@@ -367,11 +367,11 @@ bool try_pack(const t_packer_opts& packer_opts,
                 if (appack_ctx.appack_options.use_appack) {
                     // Only do unrelated clustering on the overused type instances.
                     for (const auto& p : block_type_utils) {
-                        // Any overutalized block types will use the default options.
+                        // Any overutilized block types will use the default options.
                         if (p.second > 1.0f)
                             continue;
 
-                        // Any underutalized block types should not do unrelated clustering.
+                        // Any underutilized block types should not do unrelated clustering.
                         // We can turn this off by just setting the max attempts to 0.
                         // TODO: These may become over-utilized in the future. Should
                         //       investigate turning these on if needed.