[AP] Optimized Primitive Vector Class

The primitive vector class was assumed to be quite sparse, and as such
used an unordered map as its internal data structure.

Found through experimentation that most of the time in the partial
legalizer was being spent in the operations of the primitive vector
class. Also, while improving the mass abstraction, I found a need to
separate logical models from the dimensions of the primitive vector to
allow multiple models to point to the same dimension in the primitive
vector.

This PR kills two birds with one stone by turning the unordered map into
a VTR vector map and creating a new PrimitiveVectorDim which can allow
the models to be separate from the dimensions.

Future PRs will make use of this feature to improve the mass
abstraction.

Author: AlexandreSinger

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -151,6 +151,7 @@ static PartialPlacement run_global_placer(const t_ap_opts& ap_opts,
                                                                          device_ctx.grid,
                                                                          device_ctx.logical_block_types,
                                                                          device_ctx.physical_tile_types,
+                                                                         device_ctx.arch->models,
                                                                          pre_cluster_timing_manager,
                                                                          place_delay_model,
                                                                          ap_opts.ap_timing_tradeoff,

vpr/src/analytical_place/ap_mass_report.cpp

@@ -18,6 +18,7 @@
 #include "logic_types.h"
 #include "physical_types.h"
 #include "physical_types_util.h"
+#include "primitive_dim_manager.h"
 #include "primitive_vector.h"
 #include "vpr_context.h"
 #include "vpr_error.h"
@@ -245,30 +246,30 @@ void print_physical_tiles(std::ofstream& os,
  *      The output file stream to print the primtive vector to.
  *  @param primitive_vec
  *      The primitive vector to print.
- *  @param models
- *      All models in the architecture (used to get the name of the model.
+ *  @param dim_manager
+ *      The manager class which handles all of the dims of this vector.
  *  @param prefix
  *      The prefix to print ahead of each entry in the primitive vector print.
  */
 void print_primitive_vector(std::ofstream& os,
                             const PrimitiveVector& primitive_vec,
-                            const LogicalModels& models,
+                            const PrimitiveDimManager& dim_manager,
                             const std::string& prefix) {
-    std::vector<int> contained_models = primitive_vec.get_non_zero_dims();
+    std::vector<PrimitiveVectorDim> contained_dims = primitive_vec.get_non_zero_dims();
 
-    // Get the max name length of the contained models for pretty printing.
+    // Get the max name length of the contained dim name for pretty printing.
     size_t max_model_name_len = 0;
-    for (int model_id : contained_models) {
-        std::string model_name = models.model_name((LogicalModelId)model_id);
+    for (PrimitiveVectorDim dim : contained_dims) {
+        std::string dim_name = dim_manager.get_dim_name(dim);
         max_model_name_len = std::max(max_model_name_len,
-                                      model_name.size());
+                                      dim_name.size());
     }
 
-    // Print the capacity of each model.
-    for (int model_id : contained_models) {
-        std::string model_name = models.model_name((LogicalModelId)model_id);
-        os << prefix << std::setw(max_model_name_len) << model_name;
-        os << ": " << primitive_vec.get_dim_val(model_id);
+    // Print the capacity of each dim.
+    for (PrimitiveVectorDim dim : contained_dims) {
+        std::string dim_name = dim_manager.get_dim_name(dim);
+        os << prefix << std::setw(max_model_name_len) << dim_name;
+        os << ": " << primitive_vec.get_dim_val(dim);
         os << "\n";
     }
 }
@@ -279,7 +280,7 @@ void print_primitive_vector(std::ofstream& os,
 void print_logical_block_type_capacities(std::ofstream& os,
                                          const std::vector<t_logical_block_type>& logical_block_types,
                                          const std::vector<PrimitiveVector>& logical_block_type_capacities,
-                                         const LogicalModels& models) {
+                                         const PrimitiveDimManager& dim_manager) {
     os << "=================================================================\n";
     os << "Logical Block Type Capacities:\n";
     os << "=================================================================\n";
@@ -293,7 +294,7 @@ void print_logical_block_type_capacities(std::ofstream& os,
 
         // Print the capacity of the logical block type.
         const PrimitiveVector& cap = logical_block_type_capacities[block_type.index];
-        print_primitive_vector(os, cap, models, "\t");
+        print_primitive_vector(os, cap, dim_manager, "\t");
         os << "\n";
     }
 }
@@ -304,7 +305,7 @@ void print_logical_block_type_capacities(std::ofstream& os,
 void print_physical_tile_type_capacities(std::ofstream& os,
                                          const std::vector<t_physical_tile_type>& physical_tile_types,
                                          const std::vector<PrimitiveVector>& physical_tile_type_capacities,
-                                         const LogicalModels& models) {
+                                         const PrimitiveDimManager& dim_manager) {
     os << "=================================================================\n";
     os << "Physical Tile Type Capacities:\n";
     os << "=================================================================\n";
@@ -318,7 +319,7 @@ void print_physical_tile_type_capacities(std::ofstream& os,
 
         // Print the capacity of the tile type.
         const PrimitiveVector& cap = physical_tile_type_capacities[tile_type.index];
-        print_primitive_vector(os, cap, models, "\t");
+        print_primitive_vector(os, cap, dim_manager, "\t");
         os << "\n";
     }
 }
@@ -345,6 +346,7 @@ void print_netlist_mass_utilization(std::ofstream& os,
                                     const APNetlist& ap_netlist,
                                     const vtr::vector<APBlockId, PrimitiveVector>& block_mass,
                                     const std::vector<PrimitiveVector>& physical_tile_type_capacities,
+                                    const PrimitiveDimManager& dim_manager,
                                     const DeviceGrid& device_grid,
                                     const LogicalModels& models) {
     os << "=================================================================\n";
@@ -371,44 +373,49 @@ void print_netlist_mass_utilization(std::ofstream& os,
     // Get the mass of all blocks in the netlist.
     PrimitiveVector total_netlist_mass = calc_total_netlist_mass(ap_netlist, block_mass);
 
-    PrimitiveVector netlist_per_model_counts;
+    PrimitiveVector netlist_per_dim_counts;
     for (APBlockId ap_blk_id : ap_netlist.blocks()) {
-        for (int dim : block_mass[ap_blk_id].get_non_zero_dims()) {
-            netlist_per_model_counts.add_val_to_dim(1, dim);
+        for (PrimitiveVectorDim dim : block_mass[ap_blk_id].get_non_zero_dims()) {
+            netlist_per_dim_counts.add_val_to_dim(1, dim);
         }
     }
 
     // Get the max string length of any model to make the printing prettier.
-    size_t max_model_name_len = 0;
-    for (LogicalModelId model_id : models.all_models()) {
-        max_model_name_len = std::max(max_model_name_len, std::strlen(models.model_name(model_id).c_str()));
+    size_t max_dim_name_len = 0;
+    for (PrimitiveVectorDim dim : dim_manager.dims()) {
+        std::string dim_name = dim_manager.get_dim_name(dim);
+        max_dim_name_len = std::max(max_dim_name_len, dim_name.size());
     }
 
     // Print a breakdown of the mass utilization of the netlist.
-    os << std::setw(max_model_name_len) << "Model";
+    os << std::setw(max_dim_name_len) << "Dim";
     os << ": Total Netlist Mass | Total Grid Mass | Mass Utilization\n";
     for (LogicalModelId model_id : models.all_models()) {
-        float model_netlist_mass = total_netlist_mass.get_dim_val((size_t)model_id);
-        float model_grid_capacity = total_grid_capacity.get_dim_val((size_t)model_id);
-        os << std::setw(max_model_name_len) << models.model_name(model_id);
-        os << ": " << std::setw(18) << model_netlist_mass;
-        os << " | " << std::setw(15) << model_grid_capacity;
-        os << " | " << std::setw(16) << model_netlist_mass / model_grid_capacity;
+        PrimitiveVectorDim dim = dim_manager.get_model_dim(model_id);
+        std::string dim_name = dim_manager.get_dim_name(dim);
+        float dim_netlist_mass = total_netlist_mass.get_dim_val(dim);
+        float dim_grid_capacity = total_grid_capacity.get_dim_val(dim);
+        os << std::setw(max_dim_name_len) << dim_name;
+        os << ": " << std::setw(18) << dim_netlist_mass;
+        os << " | " << std::setw(15) << dim_grid_capacity;
+        os << " | " << std::setw(16) << dim_netlist_mass / dim_grid_capacity;
         os << "\n";
     }
     os << "\n";
 
-    os << std::setw(max_model_name_len) << "Model";
+    os << std::setw(max_dim_name_len) << "Dim";
     os << ": Total Netlist Mass | Number of Blocks | Average Mass per Block\n";
     for (LogicalModelId model_id : models.all_models()) {
-        float model_netlist_mass = total_netlist_mass.get_dim_val((size_t)model_id);
-        float num_blocks = netlist_per_model_counts.get_dim_val((size_t)model_id);
+        PrimitiveVectorDim dim = dim_manager.get_model_dim(model_id);
+        std::string dim_name = dim_manager.get_dim_name(dim);
+        float dim_netlist_mass = total_netlist_mass.get_dim_val(dim);
+        float num_blocks = netlist_per_dim_counts.get_dim_val(dim);
         float average_mass_per_block = 0.0f;
         if (num_blocks > 0.0f) {
-            average_mass_per_block = model_netlist_mass / num_blocks;
+            average_mass_per_block = dim_netlist_mass / num_blocks;
         }
-        os << std::setw(max_model_name_len) << models.model_name(model_id);
-        os << ": " << std::setw(18) << model_netlist_mass;
+        os << std::setw(max_dim_name_len) << dim_name;
+        os << ": " << std::setw(18) << dim_netlist_mass;
         os << " | " << std::setw(16) << num_blocks;
         os << " | " << std::setw(22) << average_mass_per_block;
         os << "\n";
@@ -442,9 +449,9 @@ void print_expected_device_utilization(std::ofstream& os,
         // instances to support the most utilized model.
         const PrimitiveVector block_type_cap = logical_block_type_capacities[block_type.index];
         unsigned num_blocks_of_this_type = 0;
-        for (int model_id : block_type_cap.get_non_zero_dims()) {
-            float netlist_model_mass = total_netlist_mass.get_dim_val(model_id);
-            float model_mass_per_block = block_type_cap.get_dim_val(model_id);
+        for (PrimitiveVectorDim dim : block_type_cap.get_non_zero_dims()) {
+            float netlist_model_mass = total_netlist_mass.get_dim_val(dim);
+            float model_mass_per_block = block_type_cap.get_dim_val(dim);
             unsigned num_blocks_needed_for_model = std::ceil(netlist_model_mass / model_mass_per_block);
             num_blocks_of_this_type = std::max(num_blocks_of_this_type, num_blocks_needed_for_model);
         }
@@ -498,6 +505,7 @@ void print_expected_device_utilization(std::ofstream& os,
 void generate_ap_mass_report(const std::vector<PrimitiveVector>& logical_block_type_capacities,
                              const std::vector<PrimitiveVector>& physical_tile_type_capacities,
                              const vtr::vector<APBlockId, PrimitiveVector>& block_mass,
+                             const PrimitiveDimManager& dim_manager,
                              const APNetlist& ap_netlist) {
 
     vtr::ScopedStartFinishTimer timer("Generating AP Mass Report");
@@ -524,17 +532,17 @@ void generate_ap_mass_report(const std::vector<PrimitiveVector>& logical_block_t
     // Print information on the physical tiles.
     print_physical_tiles(os, physical_tile_types);
 
-    // TODO: Print a lookup between the model names and IDs
+    // TODO: Print a lookup between the model names and IDs and Primitive Dim
 
     // Print the computed capacities of each logical block type.
-    print_logical_block_type_capacities(os, logical_block_types, logical_block_type_capacities, models);
+    print_logical_block_type_capacities(os, logical_block_types, logical_block_type_capacities, dim_manager);
 
     // Print the computed capacities of each physical tile type.
-    print_physical_tile_type_capacities(os, physical_tile_types, physical_tile_type_capacities, models);
+    print_physical_tile_type_capacities(os, physical_tile_types, physical_tile_type_capacities, dim_manager);
 
     // Print information on how much mass is utilized by the netlist relative
     // to the device.
-    print_netlist_mass_utilization(os, ap_netlist, block_mass, physical_tile_type_capacities, device_grid, models);
+    print_netlist_mass_utilization(os, ap_netlist, block_mass, physical_tile_type_capacities, dim_manager, device_grid, models);
 
     // Print the expected device utilization, given the mass of the netlist
     // and the capacity of the device grid.

vpr/src/analytical_place/ap_mass_report.h

@@ -9,11 +9,12 @@
  */
 
 #include <vector>
-#include <ap_netlist_fwd.h>
+#include "ap_netlist_fwd.h"
+#include "primitive_vector_fwd.h"
 #include "vtr_vector.h"
 
 // Forward declarations
-class PrimitiveVector;
+class PrimitiveDimManager;
 
 /**
  * @brief Generate a mass report for the given AP netlist with the given block
@@ -30,4 +31,5 @@ class PrimitiveVector;
 void generate_ap_mass_report(const std::vector<PrimitiveVector>& logical_block_type_capacities,
                              const std::vector<PrimitiveVector>& physical_tile_type_capacities,
                              const vtr::vector<APBlockId, PrimitiveVector>& block_mass,
+                             const PrimitiveDimManager& dim_manager,
                              const APNetlist& ap_netlist);

vpr/src/analytical_place/flat_placement_density_manager.cpp

@@ -12,9 +12,12 @@
 #include "atom_netlist.h"
 #include "flat_placement_bins.h"
 #include "flat_placement_mass_calculator.h"
+#include "logic_types.h"
 #include "partial_placement.h"
 #include "physical_types.h"
 #include "prepack.h"
+#include "primitive_dim_manager.h"
+#include "primitive_vector.h"
 #include "vtr_assert.h"
 #include "vtr_geometry.h"
 #include "vtr_vector.h"
@@ -48,10 +51,11 @@ FlatPlacementDensityManager::FlatPlacementDensityManager(const APNetlist& ap_net
                                                          const DeviceGrid& device_grid,
                                                          const std::vector<t_logical_block_type>& logical_block_types,
                                                          const std::vector<t_physical_tile_type>& physical_tile_types,
+                                                         const LogicalModels& models,
                                                          int log_verbosity)
     : ap_netlist_(ap_netlist)
     , bins_(ap_netlist)
-    , mass_calculator_(ap_netlist, prepacker, atom_netlist, logical_block_types, physical_tile_types, log_verbosity)
+    , mass_calculator_(ap_netlist, prepacker, atom_netlist, logical_block_types, physical_tile_types, models, log_verbosity)
     , log_verbosity_(log_verbosity) {
     // Initialize the bin spatial lookup object.
     size_t num_layers, width, height;
@@ -96,12 +100,24 @@ FlatPlacementDensityManager::FlatPlacementDensityManager(const APNetlist& ap_net
         }
     }
 
+    // Get the used primitive dims. This is used to ignore the unused dims during
+    // partial legalization.
+    const PrimitiveDimManager& dim_manager = mass_calculator_.get_dim_manager();
+    for (AtomBlockId blk_id : atom_netlist.blocks()) {
+        LogicalModelId model_id = atom_netlist.block_model(blk_id);
+        PrimitiveVectorDim dim = dim_manager.get_model_dim(model_id);
+        used_dims_mask_.set_dim_val(dim, 1);
+    }
+
     // Initialize the bin capacities to the mass capacity of the physical tile
     // this bin represents.
     bin_capacity_.resize(bins_.bins().size());
     for (FlatPlacementBinId bin_id : bins_.bins()) {
         size_t physical_tile_type_index = bin_phy_tile_type_idx[bin_id];
         bin_capacity_[bin_id] = mass_calculator_.get_physical_tile_type_capacity(physical_tile_type_index);
+        // Only allocate capacity to dims which are actually used. This prevents
+        // the capacity vectors from getting too large, saving run time.
+        bin_capacity_[bin_id].project(used_dims_mask_);
     }
 
     // Initialize the bin utilizations to be zero (there is nothing in the bin

vpr/src/analytical_place/flat_placement_density_manager.h

@@ -14,13 +14,15 @@
 #include <vector>
 #include "flat_placement_bins.h"
 #include "flat_placement_mass_calculator.h"
+#include "primitive_vector.h"
 #include "vtr_assert.h"
 #include "vtr_ndmatrix.h"
 #include "vtr_vector.h"
 
 class APNetlist;
 class AtomNetlist;
 class DeviceGrid;
+class LogicalModels;
 class Prepacker;
 struct PartialPlacement;
 struct t_logical_block_type;
@@ -66,6 +68,7 @@ class FlatPlacementDensityManager {
      *  @param device_grid
      *  @param logical_block_types
      *  @param physical_tile_types
+     *  @param models
      *  @param log_verbosity
      */
     FlatPlacementDensityManager(const APNetlist& ap_netlist,
@@ -74,6 +77,7 @@ class FlatPlacementDensityManager {
                                 const DeviceGrid& device_grid,
                                 const std::vector<t_logical_block_type>& logical_block_types,
                                 const std::vector<t_physical_tile_type>& physical_tile_types,
+                                const LogicalModels& models,
                                 int log_verbosity);
 
     /**
@@ -217,6 +221,16 @@ class FlatPlacementDensityManager {
                                                  const vtr::Rect<double>& bin_region,
                                                  const PartialPlacement& p_placement) const;
 
+    /**
+     * @brief Return a primitive vector where any dim which is used in the netlist
+     *        is set to 1, and any unused dim is set to 0.
+     *
+     * This information can be used to ignore dims which are unused.
+     */
+    const PrimitiveVector& get_used_dims_mask() const {
+        return used_dims_mask_;
+    }
+
     /**
      * @brief Resets all bins by emptying them.
      */
@@ -273,6 +287,11 @@ class FlatPlacementDensityManager {
     /// @brief The set of overfilled bins.
     std::unordered_set<FlatPlacementBinId> overfilled_bins_;
 
+    /// @brief A vector mask representing the used primitive vector dimensions
+    ///        in the netlist. If a dimension is used, its value will be set to
+    ///        1 in this vector, and 0 otherwise.
+    PrimitiveVector used_dims_mask_;
+
     /// @brief The verbosity of log messages in this class.
     const int log_verbosity_;
 };