[WIP] Iterative Re-Packing

AlexandreSinger · AlexandreSinger · commit c9551f665d02 · 2025-06-24T15:58:38.000-04:00
diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h
@@ -188,6 +188,10 @@ class t_ext_pin_util_targets {
      */
     void set_block_pin_util(const std::string& block_type_name, t_ext_pin_util target);
 
+    inline void reset_all_block_pin_utils() {
+        overrides_.clear();
+    }
+
     /**
      * @brief Sets the default pin util
      * @return Returns true if a default was previously set
diff --git a/vpr/src/pack/appack_context.h b/vpr/src/pack/appack_context.h
@@ -82,7 +82,8 @@ struct t_appack_options {
     // 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 = 5.0f;
+    // static constexpr float max_unrelated_tile_distance = 5.0f;
+    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
@@ -93,7 +94,8 @@ struct t_appack_options {
     // 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 = 10;
+    // static constexpr int max_unrelated_clustering_attempts = 10;
+    std::vector<int> max_unrelated_clustering_attempts;
 
     // TODO: Investigate adding flat placement info to seed selection.
 };
@@ -122,6 +124,9 @@ struct APPackContext : public Context {
                                                 logical_block_types,
                                                 device_grid);
         }
+
+        appack_options.max_unrelated_tile_distance.resize(logical_block_types.size(), 1.0);
+        appack_options.max_unrelated_clustering_attempts.resize(logical_block_types.size(), 10);
     }
 
     /**
diff --git a/vpr/src/pack/appack_max_dist_th_manager.h b/vpr/src/pack/appack_max_dist_th_manager.h
@@ -91,6 +91,11 @@ class APPackMaxDistThManager {
         return logical_block_dist_thresholds_[logical_block_ty.index];
     }
 
+    inline void set_max_dist_threshold(const t_logical_block_type& logical_block_ty,
+                                       float new_threshold) {
+        logical_block_dist_thresholds_[logical_block_ty.index] = new_threshold;
+    }
+
   private:
     /**
      * @brief Helper method that initializes the thresholds of all logical
diff --git a/vpr/src/pack/greedy_candidate_selector.cpp b/vpr/src/pack/greedy_candidate_selector.cpp
@@ -755,7 +755,8 @@ PackMoleculeId GreedyCandidateSelector::get_next_candidate_for_cluster(
     if (allow_unrelated_clustering_ && best_molecule == PackMoleculeId::INVALID()) {
         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) {
+            t_logical_block_type_ptr cluster_type = cluster_legalizer.get_cluster_type(cluster_id);
+            if (num_unrelated_clustering_attempts_ < appack_options.max_unrelated_clustering_attempts[cluster_type->index]) {
                 best_molecule = get_unrelated_candidate_for_cluster_appack(cluster_gain_stats,
                                                                            cluster_id,
                                                                            cluster_legalizer);
@@ -1252,14 +1253,17 @@ PackMoleculeId GreedyCandidateSelector::get_unrelated_candidate_for_cluster_appa
     // Push the position of the cluster to the queue.
     search_queue.push(cluster_gain_stats.flat_cluster_position);
 
+    t_logical_block_type_ptr cluster_type = cluster_legalizer.get_cluster_type(cluster_id);
+    float max_dist = appack_ctx_.appack_options.max_unrelated_tile_distance[cluster_type->index];
+
     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) {
+        if (dist > max_dist) {
             search_queue.pop();
             continue;
         }
diff --git a/vpr/src/pack/pack.cpp b/vpr/src/pack/pack.cpp
@@ -170,6 +170,8 @@ bool try_pack(const t_packer_opts& packer_opts,
         /// @brief Region constraints: Turns on more attraction groups for all regions
         ///        and increases the target density of clb blocks.
         ATTRACTION_GROUPS_ALL_REGIONS_AND_INCREASED_TARGET_DENSITY,
+        INCREASE_TARGET_DENSITY,
+        AP_INCREASE_MAX_DISPLACEMENT,
         /// @brief The failure state.
         FAILURE
     };
@@ -192,6 +194,21 @@ bool try_pack(const t_packer_opts& packer_opts,
         //Try to size/find a device
         bool fits_on_device = try_size_device_grid(arch, num_used_type_instances, packer_opts.target_device_utilization, packer_opts.device_layout);
 
+        std::vector<t_logical_block_type_ptr> overused_type_instances;
+        overused_type_instances.reserve(num_used_type_instances.size());
+        for (const auto& p : num_used_type_instances) {
+            unsigned num_used_instances = p.second;
+
+            unsigned num_available_instances = 0;
+            for (auto type : p.first->equivalent_tiles)
+                num_available_instances += device_ctx.grid.num_instances(type, -1);
+
+            if (num_used_instances > num_available_instances) {
+                overused_type_instances.push_back(p.first);
+            }
+        }
+
+
         /* We use this bool to determine the cause for the clustering not being dense enough. If the clustering
          * is not dense enough and there are floorplan constraints, it is presumed that the constraints are the cause
          * of the floorplan not fitting, so attraction groups are turned on for later iterations.
@@ -209,7 +226,25 @@ bool try_pack(const t_packer_opts& packer_opts,
             // not overfilled, the next state is success.
             next_packer_state = e_packer_state::SUCCESS;
         } else {
-            if (floorplan_not_fitting) {
+            if (appack_ctx.appack_options.use_appack) {
+                switch (current_packer_state) {
+                    case e_packer_state::DEFAULT:
+                        next_packer_state = e_packer_state::UNRELATED_AND_BALANCED;
+                        break;
+                    case e_packer_state::UNRELATED_AND_BALANCED:
+                        // FIXME: Check if the overfilled block type has a non-1 target density. If not this has no point.
+                        next_packer_state = e_packer_state::INCREASE_TARGET_DENSITY;
+                        break;
+                    case e_packer_state::INCREASE_TARGET_DENSITY:
+                        // FIXME: Check if the max displacement of the issue block type is not already huge.
+                        next_packer_state = e_packer_state::AP_INCREASE_MAX_DISPLACEMENT;
+                        break;
+                    case e_packer_state::AP_INCREASE_MAX_DISPLACEMENT:
+                    default:
+                        next_packer_state = e_packer_state::FAILURE;
+                        break;
+                }
+            } else if (floorplan_not_fitting) {
                 // If there are overfilled region constraints.
                 /*
                  * When running with tight floorplan constraints, some regions may become overfull with clusters (i.e.
@@ -270,6 +305,16 @@ bool try_pack(const t_packer_opts& packer_opts,
                     VTR_ASSERT(balance_block_type_util == false);
                     balance_block_type_util = true;
                 }
+                if (appack_ctx.appack_options.use_appack) {
+                    // Only do unrelated clustering on the overused type instances.
+                    // FIXME: Make this cleaner so we do not have the magic number 10.
+                    std::fill(appack_ctx.appack_options.max_unrelated_clustering_attempts.begin(),
+                              appack_ctx.appack_options.max_unrelated_clustering_attempts.end(),
+                              0);
+                    for (t_logical_block_type_ptr block_type : overused_type_instances) {
+                        appack_ctx.appack_options.max_unrelated_clustering_attempts[block_type->index] = 10;
+                    }
+                }
                 VTR_LOG("Packing failed to fit on device. Re-packing with: unrelated_logic_clustering=%s balance_block_type_util=%s\n",
                         (allow_unrelated_clustering ? "true" : "false"),
                         (balance_block_type_util ? "true" : "false"));
@@ -308,6 +353,23 @@ bool try_pack(const t_packer_opts& packer_opts,
                 cluster_legalizer.get_target_external_pin_util().set_block_pin_util("clb", pin_util);
                 break;
             }
+            case e_packer_state::INCREASE_TARGET_DENSITY: {
+                t_ext_pin_util pin_util(1.0, 1.0);
+                for (t_logical_block_type_ptr type : overused_type_instances) {
+                    cluster_legalizer.get_target_external_pin_util().set_block_pin_util(type->name, pin_util);
+                }
+                VTR_LOG("Increasing target density.\n");
+                break;
+            }
+            case e_packer_state::AP_INCREASE_MAX_DISPLACEMENT: {
+                VTR_ASSERT(appack_ctx.appack_options.use_appack);
+                for (t_logical_block_type_ptr logical_block_ty : overused_type_instances) {
+                    float max_distance = device_ctx.grid.width() + device_ctx.grid.height();
+                    appack_ctx.max_distance_threshold_manager.set_max_dist_threshold(*logical_block_ty, max_distance);
+                }
+                VTR_LOG("APPACK: Increasing max displacement.\n");
+                break;
+            }
             case e_packer_state::DEFAULT:
             case e_packer_state::SUCCESS:
             case e_packer_state::FAILURE:
