Merge pull request #2898 from AlexandreSinger/feature-cluster-legalizer

[Pack] Cleaned Up Cluster Legalizer Constructor

Author: vaughnbetz

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -100,8 +100,7 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                                         prepacker,
                                                                         vpr_setup,
                                                                         *device_ctx.arch,
-                                                                        device_ctx.grid,
-                                                                        device_ctx.logical_block_types);
+                                                                        device_ctx.grid);
     full_legalizer->legalize(p_placement);
 }
 

vpr/src/analytical_place/full_legalizer.cpp

@@ -54,25 +54,22 @@ std::unique_ptr<FullLegalizer> make_full_legalizer(e_ap_full_legalizer full_lega
                                                    const Prepacker& prepacker,
                                                    t_vpr_setup& vpr_setup,
                                                    const t_arch& arch,
-                                                   const DeviceGrid& device_grid,
-                                                   const std::vector<t_logical_block_type>& logical_block_types) {
+                                                   const DeviceGrid& device_grid) {
     switch (full_legalizer_type) {
         case e_ap_full_legalizer::Naive:
             return std::make_unique<NaiveFullLegalizer>(ap_netlist,
                                                         atom_netlist,
                                                         prepacker,
                                                         vpr_setup,
                                                         arch,
-                                                        device_grid,
-                                                        logical_block_types);
+                                                        device_grid);
         case e_ap_full_legalizer::APPack:
             return std::make_unique<APPack>(ap_netlist,
                                             atom_netlist,
                                             prepacker,
                                             vpr_setup,
                                             arch,
-                                            device_grid,
-                                            logical_block_types);
+                                            device_grid);
         default:
              VPR_FATAL_ERROR(VPR_ERROR_AP,
                              "Unrecognized full legalizer type");
@@ -285,15 +282,11 @@ void NaiveFullLegalizer::create_clusters(const PartialPlacement& p_placement) {
     t_pack_high_fanout_thresholds high_fanout_thresholds(vpr_setup_.PackerOpts.high_fanout_threshold);
     ClusterLegalizer cluster_legalizer(atom_netlist_,
                                        prepacker_,
-                                       logical_block_types_,
                                        vpr_setup_.PackerRRGraph,
-                                       arch_.models,
-                                       arch_.model_library,
                                        vpr_setup_.PackerOpts.target_external_pin_util,
                                        high_fanout_thresholds,
                                        ClusterLegalizationStrategy::FULL,
                                        vpr_setup_.PackerOpts.enable_pin_feasibility_filter,
-                                       vpr_setup_.PackerOpts.feasible_block_array_size,
                                        vpr_setup_.PackerOpts.pack_verbosity);
     // Create clusters for each tile.
     //  Start by giving each root tile a unique ID.
@@ -522,8 +515,6 @@ void APPack::legalize(const PartialPlacement& p_placement) {
              &vpr_setup_.AnalysisOpts,
              arch_,
              vpr_setup_.RoutingArch,
-             vpr_setup_.user_models,
-             vpr_setup_.library_models,
              vpr_setup_.PackerRRGraph,
              flat_placement_info);
 

vpr/src/analytical_place/full_legalizer.h

@@ -10,7 +10,6 @@
 #pragma once
 
 #include <memory>
-#include <vector>
 #include "ap_flow_enums.h"
 
 // Forward declarations
@@ -22,7 +21,6 @@ class PartialPlacement;
 class PlaceMacros;
 class Prepacker;
 struct t_arch;
-struct t_logical_block_type;
 struct t_vpr_setup;
 
 /**
@@ -41,15 +39,13 @@ class FullLegalizer {
                   const Prepacker& prepacker,
                   t_vpr_setup& vpr_setup,
                   const t_arch& arch,
-                  const DeviceGrid& device_grid,
-                  const std::vector<t_logical_block_type>& logical_block_types)
+                  const DeviceGrid& device_grid)
             : ap_netlist_(ap_netlist),
               atom_netlist_(atom_netlist),
               prepacker_(prepacker),
               vpr_setup_(vpr_setup),
               arch_(arch),
-              device_grid_(device_grid),
-              logical_block_types_(logical_block_types) {}
+              device_grid_(device_grid) {}
 
     /**
      * @brief Perform legalization on the given partial placement solution
@@ -79,9 +75,6 @@ class FullLegalizer {
 
     /// @brief The device grid which records where clusters can be placed.
     const DeviceGrid& device_grid_;
-
-    /// @brief A list of the logical block types in the architecture.
-    const std::vector<t_logical_block_type>& logical_block_types_;
 };
 
 std::unique_ptr<FullLegalizer> make_full_legalizer(e_ap_full_legalizer full_legalizer_type,
@@ -90,8 +83,7 @@ std::unique_ptr<FullLegalizer> make_full_legalizer(e_ap_full_legalizer full_lega
                                                    const Prepacker& prepacker,
                                                    t_vpr_setup& vpr_setup,
                                                    const t_arch& arch,
-                                                   const DeviceGrid& device_grid,
-                                                   const std::vector<t_logical_block_type>& logical_block_types);
+                                                   const DeviceGrid& device_grid);
 
 /**
  * @brief The Naive Full Legalizer.

vpr/src/base/vpr_api.cpp

@@ -648,8 +648,6 @@ bool vpr_pack(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
     return try_pack(&vpr_setup.PackerOpts, &vpr_setup.AnalysisOpts,
                     arch, vpr_setup.RoutingArch,
-                    vpr_setup.user_models,
-                    vpr_setup.library_models,
                     vpr_setup.PackerRRGraph, g_vpr_ctx.atom().flat_placement_info);
 }
 

vpr/src/base/vpr_types.h

@@ -93,8 +93,6 @@ constexpr bool VTR_ENABLE_DEBUG_LOGGING_CONST_EXPR = true;
 constexpr bool VTR_ENABLE_DEBUG_LOGGING_CONST_EXPR = false;
 #endif
 
-#define MAX_SHORT 32767
-
 /* Values large enough to be way out of range for any data, but small enough
  * to allow a small number to be added to them without going out of range. */
 #define HUGE_POSITIVE_FLOAT 1.e30

vpr/src/pack/cluster_legalizer.cpp

@@ -38,43 +38,6 @@
 #include "vtr_vector.h"
 #include "vtr_vector_map.h"
 
-/**
- * @brief Counts the total number of logic models that the architecture can
- *        implement.
- *
- * @param user_models A linked list of logic models.
- * @return The total number of models in the linked list
- */
-static size_t count_models(const t_model* user_models) {
-    if (user_models == nullptr)
-        return 0;
-
-    size_t n_models = 0;
-    const t_model* cur_model = user_models;
-    while (cur_model != nullptr) {
-        n_models++;
-        cur_model = cur_model->next;
-    }
-
-    return n_models;
-}
-
-/*
- * @brief Gets the max cluster size that any logical block can have.
- *
- * This is the maximum number of primitives any cluster can contain.
- */
-static size_t calc_max_cluster_size(const std::vector<t_logical_block_type>& logical_block_types) {
-    size_t max_cluster_size = 0;
-    for (const t_logical_block_type& blk_type : logical_block_types) {
-        if (is_empty_type(&blk_type))
-            continue;
-        int cur_cluster_size = get_max_primitives_in_pb_type(blk_type.pb_type);
-        max_cluster_size = std::max<int>(max_cluster_size, cur_cluster_size);
-    }
-    return max_cluster_size;
-}
-
 /*
  * @brief Allocates the stats stored within the pb of a cluster.
  *
@@ -471,15 +434,11 @@ try_place_atom_block_rec(const t_pb_graph_node* pb_graph_node,
                          const AtomBlockId blk_id,
                          t_pb* cb,
                          t_pb** parent,
-                         const int max_models,
-                         const int max_cluster_size,
                          const LegalizationClusterId cluster_id,
                          vtr::vector_map<AtomBlockId, LegalizationClusterId>& atom_cluster,
-                         const t_intra_cluster_placement_stats* cluster_placement_stats_ptr,
                          const PackMoleculeId molecule_id,
                          t_lb_router_data* router_data,
                          int verbosity,
-                         const int feasible_block_array_size,
                          const Prepacker& prepacker,
                          const vtr::vector_map<MoleculeChainId, t_clustering_chain_info>& clustering_chain_info) {
     const AtomContext& atom_ctx = g_vpr_ctx.atom();
@@ -493,10 +452,10 @@ try_place_atom_block_rec(const t_pb_graph_node* pb_graph_node,
     if (pb_graph_node->parent_pb_graph_node != cb->pb_graph_node) {
         t_pb* my_parent = nullptr;
         block_pack_status = try_place_atom_block_rec(pb_graph_node->parent_pb_graph_node, blk_id, cb,
-                                                     &my_parent, max_models, max_cluster_size, cluster_id,
+                                                     &my_parent, cluster_id,
                                                      atom_cluster,
-                                                     cluster_placement_stats_ptr, molecule_id, router_data,
-                                                     verbosity, feasible_block_array_size,
+                                                     molecule_id, router_data,
+                                                     verbosity,
                                                      prepacker, clustering_chain_info);
         parent_pb = my_parent;
     } else {
@@ -1272,15 +1231,11 @@ e_block_pack_status ClusterLegalizer::try_pack_molecule(PackMoleculeId molecule_
                                                          atom_blk_id,
                                                          cluster.pb,
                                                          &parent,
-                                                         num_models_,
-                                                         max_cluster_size_,
                                                          cluster_id,
                                                          atom_cluster_,
-                                                         cluster.placement_stats,
                                                          molecule_id,
                                                          cluster.router_data,
                                                          log_verbosity_,
-                                                         feasible_block_array_size_,
                                                          prepacker_,
                                                          clustering_chain_info_);
         }
@@ -1644,15 +1599,11 @@ bool ClusterLegalizer::check_cluster_legality(LegalizationClusterId cluster_id)
 
 ClusterLegalizer::ClusterLegalizer(const AtomNetlist& atom_netlist,
                                    const Prepacker& prepacker,
-                                   const std::vector<t_logical_block_type>& logical_block_types,
                                    std::vector<t_lb_type_rr_node>* lb_type_rr_graphs,
-                                   const t_model* user_models,
-                                   const t_model* library_models,
                                    const std::vector<std::string>& target_external_pin_util_str,
                                    const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                                    ClusterLegalizationStrategy cluster_legalization_strategy,
                                    bool enable_pin_feasibility_filter,
-                                   int feasible_block_array_size,
                                    int log_verbosity) : prepacker_(prepacker) {
     // Verify that the inputs are valid.
     VTR_ASSERT_SAFE(lb_type_rr_graphs != nullptr);
@@ -1669,14 +1620,8 @@ ClusterLegalizer::ClusterLegalizer(const AtomNetlist& atom_netlist,
     clustering_chain_info_.resize(prepacker_.get_num_molecule_chains());
     // Pre-compute the max size of any molecule.
     max_molecule_size_ = prepacker.get_max_molecule_size();
-    // Calculate the max cluster size
-    //  - Limit maximum number of elements for each cluster to MAX_SHORT
-    max_cluster_size_ = calc_max_cluster_size(logical_block_types);
-    VTR_ASSERT(max_cluster_size_ < MAX_SHORT);
     // Get a reference to the rr graphs.
     lb_type_rr_graphs_ = lb_type_rr_graphs;
-    // Get the number of models in the architecture.
-    num_models_ = count_models(user_models) + count_models(library_models);
     // Find all NoC router atoms.
     std::vector<AtomBlockId> noc_atoms = find_noc_router_atoms(atom_netlist);
     update_noc_reachability_partitions(noc_atoms,
@@ -1686,7 +1631,6 @@ ClusterLegalizer::ClusterLegalizer(const AtomNetlist& atom_netlist,
     // Copy the options passed by the user
     cluster_legalization_strategy_ = cluster_legalization_strategy;
     enable_pin_feasibility_filter_ = enable_pin_feasibility_filter;
-    feasible_block_array_size_ = feasible_block_array_size;
     log_verbosity_ = log_verbosity;
 }