[AP][APPack] Density Estimation Upstream

This was code written for a TODAES publication which found that APPack
struggled when the device was aggressively sized.

This PR brings in improvments to APPack which allow it to estimate how
much space is available on the device and use that information to select
different parameters to more aggressively pack. For example, if it
detects that the device is limited in CLBs, it will increase the max
displacement threshold for CLBs proportional to how limited the CLBs
are. If the limitation is extreme, it automatically turns on unrelated
clustering early.

This should help the auto-selected device sizes be more aligned with the
traditional flow as well.

Author: AlexandreSinger

vpr/src/base/vpr_api.cpp

@@ -757,7 +757,8 @@ bool vpr_pack(t_vpr_setup& vpr_setup, const t_arch& arch) {
     // that downstream stages (e.g. RAM mapper) can query realistic device
     // dimensions before packing. The packer may later grow or shrink the device
     // size to match the actual resource requirements after packing completes.
-    DeviceSizeEstimator device_size_estimator(vpr_setup, arch, prepacker);
+    DeviceSizeEstimator device_size_estimator(vpr_setup, arch, prepacker,
+                                              /*always_estimate_resource_requirement=*/g_vpr_ctx.atom().flat_placement_info().valid);
 
     // Infer logical RAMs and assign to physical types to prioritize during packing.
     // For the auto-device flow, reuse the groups already computed by the estimator.
@@ -778,7 +779,8 @@ bool vpr_pack(t_vpr_setup& vpr_setup, const t_arch& arch) {
                     pre_cluster_timing_manager,
                     g_vpr_ctx.atom().flat_placement_info(),
                     vpr_setup,
-                    ram_mapper);
+                    ram_mapper,
+                    device_size_estimator.estimated_type_instance_counts());
 }
 
 void vpr_load_packing(const t_vpr_setup& vpr_setup, const t_arch& arch) {

vpr/src/pack/appack_context.h

@@ -104,7 +104,8 @@ struct APPackContext : public Context {
                                                 device_grid);
 
             unrelated_clustering_manager.init(ap_opts.appack_unrelated_clustering_args,
-                                              logical_block_types);
+                                              logical_block_types,
+                                              device_grid);
         }
     }
 

vpr/src/pack/appack_max_dist_th_manager.cpp

@@ -24,7 +24,8 @@ void APPackMaxDistThManager::init(const std::vector<std::string>& max_dist_ths,
                                   const DeviceGrid& device_grid) {
     // Compute the max device distance based on the width and height of the
     // device. This is the L1 (manhattan) distance.
-    max_distance_on_device_ = device_grid.width() + device_grid.height();
+    float layer_span_contr = device_grid.get_num_layers() > 1 ? device_grid.get_num_layers() : 0;
+    max_distance_on_device_ = device_grid.width() + device_grid.height() + layer_span_contr;
 
     // Automatically set the max distance thresholds.
     auto_set_max_distance_thresholds(logical_block_types, device_grid);

vpr/src/pack/appack_max_dist_th_manager.h

@@ -45,7 +45,7 @@ class APPackMaxDistThManager {
     // Logic blocks (such as CLBs and LABs) tend to have more resources on the
     // device, thus they have tighter thresholds. This was found to work well.
     static constexpr float logic_block_max_dist_th_scale_ = 0.02f;
-    static constexpr float logic_block_max_dist_th_offset_ = 10.0f;
+    static constexpr float logic_block_max_dist_th_offset_ = 5.0f;
 
     // Memory blocks (i.e. blocks that contain pb_types of the memory class)
     // seem to have very touchy packing; thus these do not have the max

vpr/src/pack/appack_unrelated_clustering_manager.cpp

@@ -8,38 +8,17 @@
 #include "appack_unrelated_clustering_manager.h"
 #include "ap_argparse_utils.h"
 #include "arch_util.h"
+#include "device_grid.h"
 #include "vpr_error.h"
+#include "vpr_utils.h"
 
 void APPackUnrelatedClusteringManager::init(
     const std::vector<std::string>& unrelated_clustering_args,
-    const std::vector<t_logical_block_type>& logical_block_types) {
+    const std::vector<t_logical_block_type>& logical_block_types,
+    const DeviceGrid& device_grid) {
 
-    // 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.
-    max_unrelated_tile_distance_.resize(logical_block_types.size(),
-                                        default_max_unrelated_tile_distance_);
-    max_unrelated_clustering_attempts_.resize(logical_block_types.size(),
-                                              default_max_unrelated_clustering_attempts_);
-
-    // For memories (such as BRAMs and MLABs), we do not perform unrelated clustering.
-    for (const t_logical_block_type& lb_ty : logical_block_types) {
-        // Skip the empty logical block type. This should not have any blocks.
-        if (lb_ty.is_empty())
-            continue;
-
-        // If the logical block type contains a pb_type which is a memory class,
-        // it is assumed to be a BRAM or an MLAB.
-        bool has_memory = pb_type_contains_memory_pbs(lb_ty.pb_type);
-        if (!has_memory)
-            continue;
-
-        // Do not do unrelated clustering on memories. It is not worth it.
-        max_unrelated_clustering_attempts_[lb_ty.index] = 0;
-    }
+    // Automatically set the unrelated clustering parameters.
+    auto_set_unrelated_clustering_params(logical_block_types, device_grid);
 
     // At this point, the data structures have been initialized properly.
     is_initialized_ = true;
@@ -81,3 +60,45 @@ void APPackUnrelatedClusteringManager::init(
         max_unrelated_clustering_attempts_[lb_ty_index] = logical_block_max_unrel_attempts;
     }
 }
+
+void APPackUnrelatedClusteringManager::auto_set_unrelated_clustering_params(
+    const std::vector<t_logical_block_type>& logical_block_types,
+    const DeviceGrid& device_grid) {
+
+    // 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.
+    max_unrelated_tile_distance_.resize(logical_block_types.size(),
+                                        default_max_unrelated_tile_distance_);
+    max_unrelated_clustering_attempts_.resize(logical_block_types.size(),
+                                              default_max_unrelated_clustering_attempts_);
+
+    // Find which (if any) of the logical block types most looks like a CLB block.
+    t_logical_block_type_ptr logic_block_type = infer_logic_block_type(device_grid);
+
+    for (const t_logical_block_type& lb_ty : logical_block_types) {
+        // Skip the empty logical block type. This should not have any blocks.
+        if (lb_ty.is_empty())
+            continue;
+
+        // If the logical block type contains a pb_type which is a memory class,
+        // it is assumed to be a BRAM or an MLAB.
+        bool has_memory = pb_type_contains_memory_pbs(lb_ty.pb_type);
+        if (!has_memory)
+            continue;
+
+        // Do not do unrelated clustering on memories. It is not worth it.
+        max_unrelated_clustering_attempts_[lb_ty.index] = 0;
+
+        // Logic blocks (such as CLBs and LABs) were found to benefit from
+        // different unrelated clustering parameters than the default.
+        bool is_logic_block_type = (lb_ty.index == logic_block_type->index);
+        if (is_logic_block_type) {
+            max_unrelated_tile_distance_[lb_ty.index] = logic_block_max_unrelated_tile_distance_;
+            max_unrelated_clustering_attempts_[lb_ty.index] = logic_block_max_unrelated_clustering_attempts_;
+        }
+    }
+}

vpr/src/pack/appack_unrelated_clustering_manager.h

@@ -12,6 +12,9 @@
 #include "physical_types.h"
 #include "vtr_assert.h"
 
+// Forward declarations.
+class DeviceGrid;
+
 /**
  * @brief Manager class for unrelated clustering in APPack.
  *
@@ -55,6 +58,12 @@ class APPackUnrelatedClusteringManager {
      */
     static constexpr int default_max_unrelated_clustering_attempts_ = 1;
 
+    // Logic blocks (such as CLBs and LABs) were found to benefit from a larger
+    // search distance and number of attempts than the default. These numbers
+    // were found empirically to work well.
+    static constexpr float logic_block_max_unrelated_tile_distance_ = 4.0f;
+    static constexpr int logic_block_max_unrelated_clustering_attempts_ = 1;
+
   public:
     /**
      * @brief When the packing is particularly difficult, and it has failed enough
@@ -77,9 +86,11 @@ class APPackUnrelatedClusteringManager {
      *      behavior.
      *  @param logical_block_types
      *      A vector of all logical block types in the architecture.
+     *  @param device_grid
      */
     void init(const std::vector<std::string>& unrelated_clustering_args,
-              const std::vector<t_logical_block_type>& logical_block_types);
+              const std::vector<t_logical_block_type>& logical_block_types,
+              const DeviceGrid& device_grid);
 
     /**
      * @brief Get the max search distance for the given logical block type.
@@ -137,6 +148,14 @@ class APPackUnrelatedClusteringManager {
     }
 
   private:
+    /**
+     * @brief Helper method that initializes the unrelated clustering parameters
+     *        of all logical block types to reasonable numbers based on the
+     *        characteristics of the logical block type.
+     */
+    void auto_set_unrelated_clustering_params(const std::vector<t_logical_block_type>& logical_block_types,
+                                              const DeviceGrid& device_grid);
+
     /// @brief A flag which shows if the data within this class has been initialized
     ///        or not.
     bool is_initialized_ = false;

vpr/src/pack/device_size_estimate.cpp

@@ -252,14 +252,16 @@ static bool primitive_has_external_output(const t_pb_graph_node* prim) {
     return false;
 }
 
-std::map<t_logical_block_type_ptr, size_t> DeviceSizeEstimator::estimate_resource_requirement(const Prepacker& prepacker) {
+std::map<t_logical_block_type_ptr, size_t> DeviceSizeEstimator::estimate_resource_requirement(const Prepacker& prepacker, bool store_ram_groups) {
     vtr::ScopedStartFinishTimer timer("Estimate Resource Requirement");
     const auto& atom_ctx = g_vpr_ctx.atom();
 
     // Group RAM atoms and assign to minimum-area types.
-    // Results are stored in ram_groups_ for later use by RamMapper.
-    ram_groups_ = group_ram_atoms(atom_ctx.netlist(), prepacker);
-    assign_ram_groups_by_min_area(ram_groups_, false /*is_fixed_device*/);
+    // If requested, results are stored in ram_groups_ for later use by RamMapper.
+    vtr::vector<LogicalRamGroupId, LogicalRamGroup> ram_groups = group_ram_atoms(atom_ctx.netlist(), prepacker);
+    assign_ram_groups_by_min_area(ram_groups, false /*is_fixed_device*/);
+    if (store_ram_groups)
+        ram_groups_ = ram_groups;
 
     // Group non-RAM molecules by their logical block type.
     vtr::vector<LogicalModelId, std::vector<t_logical_block_type_ptr>>
@@ -306,8 +308,8 @@ std::map<t_logical_block_type_ptr, size_t> DeviceSizeEstimator::estimate_resourc
     }
 
     // Estimate instance counts for RAM types using logical RAM groups.
-    for (LogicalRamGroupId ram_group_id : ram_groups_.keys()) {
-        const LogicalRamGroup& ram_group = ram_groups_[ram_group_id];
+    for (LogicalRamGroupId ram_group_id : ram_groups.keys()) {
+        const LogicalRamGroup& ram_group = ram_groups[ram_group_id];
         t_logical_block_type_ptr logical_type = ram_group.pre_assigned_type ? ram_group.pre_assigned_type : ram_group.candidate_types[0];
         size_t inferred_number_of_instances = std::ceil(vtr::safe_ratio<float>(ram_group.total_memory_slices, ram_group.candidate_capacity.at(logical_type)));
         num_type_instances[logical_type] += inferred_number_of_instances;
@@ -378,7 +380,8 @@ static std::pair<size_t, size_t> read_rr_graph_grid_dims(const std::string& file
 
 DeviceSizeEstimator::DeviceSizeEstimator(t_vpr_setup& vpr_setup,
                                          const t_arch& arch,
-                                         const Prepacker& prepacker) {
+                                         const Prepacker& prepacker,
+                                         bool always_estimate_resource_requirement) {
     vtr::ScopedStartFinishTimer timer("Estimate Device Size");
     const std::string& device_layout = vpr_setup.PackerOpts.device_layout;
     const t_packer_opts& packer_opts = vpr_setup.PackerOpts;
@@ -416,6 +419,8 @@ DeviceSizeEstimator::DeviceSizeEstimator(t_vpr_setup& vpr_setup,
         // resizing during and after packing.
         device_ctx.grid = create_device_grid(device_layout, arch.grid_layouts, width, height);
         device_ctx.grid.set_fixed_by_rr_graph(true);
+        if (always_estimate_resource_requirement)
+            estimated_num_type_instances_ = estimate_resource_requirement(prepacker, /*store_ram_groups=*/false);
         return;
     }
 
@@ -426,6 +431,8 @@ DeviceSizeEstimator::DeviceSizeEstimator(t_vpr_setup& vpr_setup,
         device_ctx.grid = create_device_grid(device_layout, arch.grid_layouts,
                                              num_type_instances,
                                              packer_opts.target_device_utilization);
+        if (always_estimate_resource_requirement)
+            estimated_num_type_instances_ = estimate_resource_requirement(prepacker, /*store_ram_groups=*/false);
         return;
     }
 
@@ -437,12 +444,15 @@ DeviceSizeEstimator::DeviceSizeEstimator(t_vpr_setup& vpr_setup,
                                              {}, packer_opts.target_device_utilization,
                                              vpr_setup.device_width);
         report_device_grid_stats(device_ctx.grid);
+        if (always_estimate_resource_requirement)
+            estimated_num_type_instances_ = estimate_resource_requirement(prepacker, /*store_ram_groups=*/false);
         return;
     }
 
     VTR_LOG("Device layout '%s' selected. Need to estimate device size.\n", device_layout.c_str());
 
     std::map<t_logical_block_type_ptr, size_t> num_type_instances = estimate_resource_requirement(prepacker);
+    estimated_num_type_instances_ = num_type_instances;
     VTR_LOG("Estimated resource requirements:\n");
     for (auto& [type_ptr, count] : num_type_instances)
         VTR_LOG("  %s: %zu requested instances\n", type_ptr->name.c_str(), count);

vpr/src/pack/device_size_estimate.h

@@ -32,32 +32,65 @@ struct t_vpr_setup;
  */
 class DeviceSizeEstimator {
   public:
+    /**
+     * @param always_estimate_resource_requirement
+     *      If true, the resource requirement estimate (see
+     *      estimated_type_instance_counts()) is computed even when the
+     *      device size itself does not need estimating (fixed device layout,
+     *      RR graph provided, or auto layout with a fixed width). Defaults to
+     *      false since this estimate involves a mini-packing simulation, and
+     *      most callers only need the device grid sized, not the raw
+     *      per-type estimate.
+     */
     DeviceSizeEstimator(t_vpr_setup& vpr_setup,
                         const t_arch& arch,
-                        const Prepacker& prepacker);
+                        const Prepacker& prepacker,
+                        bool always_estimate_resource_requirement = false);
 
     /// @brief Returns the RAM groups computed during estimation.
     ///        Empty if the device layout was fixed (no estimation needed).
     const vtr::vector<LogicalRamGroupId, LogicalRamGroup>& ram_groups() const {
         return ram_groups_;
     }
 
+    /// @brief Returns the estimated number of instances required for each
+    ///        logical block type, computed during device size estimation.
+    ///        Empty unless estimation was performed (device layout was
+    ///        "auto" with no fixed width, or always_estimate_resource_requirement
+    ///        was set to true in the constructor).
+    const std::map<t_logical_block_type_ptr, size_t>& estimated_type_instance_counts() const {
+        return estimated_num_type_instances_;
+    }
+
   private:
     /**
      * @brief Estimates the number of instances required for each logical block
      *        type to fit the design.
      *
-     * Groups RAM atoms, assigns them to minimum-area types (stored in
-     * ram_groups_ for RamMapper), and runs a mini-packing simulation for
-     * non-RAM types using pin capacity and cluster placement feasibility
-     * constraints to get required number of instances for each type.
+     * Groups RAM atoms, assigns them to minimum-area types, and runs a
+     * mini-packing simulation for non-RAM types using pin capacity and
+     * cluster placement feasibility constraints to get required number of
+     * instances for each type.
      *
+     * @param prepacker
+     *      Used to query molecule structure and placement feasibility.
+     * @param store_ram_groups
+     *      If true, the RAM groups computed as part of this estimate are
+     *      published to ram_groups_ for reuse by RamMapper. Callers that
+     *      only want the type instance estimate (e.g. for a fixed device,
+     *      where RamMapper must instead do its own capacity-aware grouping)
+     *      should pass false so ram_groups() is left untouched.
      * @return Map from logical block type to estimated cluster instance count.
      */
     std::map<t_logical_block_type_ptr, size_t> estimate_resource_requirement(
-        const Prepacker& prepacker);
+        const Prepacker& prepacker,
+        bool store_ram_groups = true);
 
     /// @brief RAM groups computed during estimation; exposed via ram_groups()
     ///        for reuse by RamMapper to avoid redundant grouping and area assignment.
     vtr::vector<LogicalRamGroupId, LogicalRamGroup> ram_groups_;
+
+    /// @brief Estimated cluster instance counts per logical block type;
+    ///        exposed via estimated_type_instance_counts().
+    std::map<t_logical_block_type_ptr, size_t> estimated_num_type_instances_;
 };