[AP] Full Legalizer

The Full Legalizer in the AP flow takes a partial placement (of any
legality) and returns a fully legal placement. A legal placement is a
set of legal clusterers of atoms and legal places for those clusters to
be placed.

To fully test the AP flow, made a temporary Global Placer which will
just place the APBlocks at the center of the device. This will be fixed
later.

Also includes basic tests to ensure the AP flow does not regress.

Author: AlexandreSinger

vpr/src/analytical_place/analytical_placement_flow.cpp

@@ -8,19 +8,21 @@
 #include "analytical_placement_flow.h"
 #include "ap_netlist.h"
 #include "atom_netlist.h"
+#include "full_legalizer.h"
 #include "gen_ap_netlist_from_atoms.h"
 #include "globals.h"
+#include "partial_placement.h"
 #include "prepack.h"
 #include "user_place_constraints.h"
 #include "vpr_context.h"
-#include "vpr_error.h"
 #include "vpr_types.h"
+#include "vtr_assert.h"
 #include "vtr_time.h"
 
 void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
     (void)vpr_setup;
     // Start an overall timer for the Analytical Placement flow.
-    vtr::ScopedStartFinishTimer timer("Analytical Placement Flow");
+    vtr::ScopedStartFinishTimer timer("Analytical Placement");
 
     // The global state used/modified by this flow.
     const AtomNetlist& atom_nlist = g_vpr_ctx.atom().nlist;
@@ -37,9 +39,38 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) {
                                                      prepacker,
                                                      constraints);
 
-    // AP is currently under-construction. Fail gracefully just in case this
-    // is somehow being called.
-    VPR_FATAL_ERROR(VPR_ERROR_AP,
-                    "Analytical Placement flow not implemented yet");
+    // Run the Global Placer
+    //  For now, just put all the moveable blocks at the center of the device
+    //  grid. This will be replaced later. This is just for testing.
+    PartialPlacement p_placement(ap_netlist);
+    const size_t device_width = device_ctx.grid.width();
+    const size_t device_height = device_ctx.grid.height();
+    double device_center_x = static_cast<double>(device_width) / 2.0;
+    double device_center_y = static_cast<double>(device_height) / 2.0;
+    for (APBlockId ap_blk_id : ap_netlist.blocks()) {
+        if (ap_netlist.block_mobility(ap_blk_id) != APBlockMobility::MOVEABLE)
+            continue;
+        // If the APBlock is moveable, put it on the center for the device.
+        p_placement.block_x_locs[ap_blk_id] = device_center_x;
+        p_placement.block_y_locs[ap_blk_id] = device_center_y;
+    }
+    VTR_ASSERT(p_placement.verify(ap_netlist,
+                                  device_width,
+                                  device_height,
+                                  device_ctx.grid.get_num_layers()));
+
+    // Run the Full Legalizer.
+    FullLegalizer full_legalizer(ap_netlist,
+                                 vpr_setup,
+                                 device_ctx.grid,
+                                 device_ctx.arch,
+                                 atom_nlist,
+                                 prepacker,
+                                 device_ctx.logical_block_types,
+                                 vpr_setup.PackerRRGraph,
+                                 device_ctx.arch->models,
+                                 device_ctx.arch->model_library,
+                                 vpr_setup.PackerOpts);
+    full_legalizer.legalize(p_placement);
 }
 

vpr/src/analytical_place/full_legalizer.cpp

@@ -0,0 +1,110 @@
+/**
+ * @file
+ * @author  Alex Singer
+ * @date    September 2024
+ * @brief   Defines the FullLegalizer class which takes a partial AP placement
+ *          and generates a fully legal clustering and placement which can be
+ *          routed by VTR.
+ */
+
+#pragma once
+
+#include <vector>
+
+// Forward declarations
+class APNetlist;
+class AtomNetlist;
+class ClusteredNetlist;
+class DeviceGrid;
+class PartialPlacement;
+class Prepacker;
+struct t_arch;
+struct t_lb_type_rr_node;
+struct t_logical_block_type;
+struct t_model;
+struct t_packer_opts;
+struct t_vpr_setup;
+
+/**
+ * @brief The full legalizer in an AP flow
+ *
+ * Given a valid partial placement (of any level of legality), will produce a
+ * fully legal clustering and placement for use in the rest of the VTR flow.
+ */
+class FullLegalizer {
+public:
+    /**
+     * @brief Constructor of the Full Legalizer class.
+     *
+     * Brings in all the necessary state here. This is the state needed from the
+     * AP Context. the Packer Context, and the Placer Context.
+     */
+    FullLegalizer(const APNetlist& ap_netlist,
+                  t_vpr_setup& vpr_setup,
+                  const DeviceGrid& device_grid,
+                  const t_arch* arch,
+                  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 t_packer_opts& packer_opts)
+            : ap_netlist_(ap_netlist),
+              vpr_setup_(vpr_setup),
+              device_grid_(device_grid),
+              arch_(arch),
+              atom_netlist_(atom_netlist),
+              prepacker_(prepacker),
+              logical_block_types_(logical_block_types),
+              lb_type_rr_graphs_(lb_type_rr_graphs),
+              user_models_(user_models),
+              library_models_(library_models),
+              packer_opts_(packer_opts) {}
+
+    /**
+     * @brief Perform legalization on the given partial placement solution
+     *
+     *  @param p_placement  A valid partial placement (passes verify method).
+     *                      This implies that all blocks are placed on the
+     *                      device grid and fixed blocks are observed.
+     */
+    void legalize(const PartialPlacement& p_placement);
+
+private:
+    /**
+     * @brief Helper method to create the clusters from the given partial
+     *        placement.
+     * TODO: Should return a ClusteredNetlist object, but need to wait until
+     *       it is separated from load_cluster_constraints.
+     */
+    void create_clusters(const PartialPlacement& p_placement);
+
+    /**
+     * @brief Helper method to place the clusters based on the given partial
+     *        placement.
+     */
+    void place_clusters(const ClusteredNetlist& clb_nlist,
+                        const PartialPlacement& p_placement);
+
+    // AP Context Info
+    const APNetlist& ap_netlist_;
+    // Overall Setup Info
+    // FIXME: I do not like bringing all of this in. Perhaps clean up the methods
+    //        that use it.
+    t_vpr_setup& vpr_setup_;
+    // Device Context Info
+    const DeviceGrid& device_grid_;
+    const t_arch* arch_;
+    // Packing Context Info
+    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 t_packer_opts& packer_opts_;
+    // Placement Context Info
+    // TODO: Populate this once the placer is cleaned up some.
+};
+

vpr/src/analytical_place/full_legalizer.h

@@ -12,7 +12,7 @@
 
 bool PartialPlacement::verify_locs(const APNetlist& netlist,
                                    size_t grid_width,
-                                   size_t grid_height) {
+                                   size_t grid_height) const {
     // Make sure all of the loc values are there.
     if (block_x_locs.size() != netlist.blocks().size())
         return false;
@@ -43,7 +43,7 @@ bool PartialPlacement::verify_locs(const APNetlist& netlist,
 }
 
 bool PartialPlacement::verify_layer_nums(const APNetlist& netlist,
-                                         size_t grid_num_layers) {
+                                         size_t grid_num_layers) const {
     // Make sure all of the layer nums are there
     if (block_layer_nums.size() != netlist.blocks().size())
         return false;
@@ -62,7 +62,7 @@ bool PartialPlacement::verify_layer_nums(const APNetlist& netlist,
     return true;
 }
 
-bool PartialPlacement::verify_sub_tiles(const APNetlist& netlist) {
+bool PartialPlacement::verify_sub_tiles(const APNetlist& netlist) const {
     // Make sure all of the sub tiles are there
     if (block_sub_tiles.size() != netlist.blocks().size())
         return false;
@@ -88,7 +88,7 @@ bool PartialPlacement::verify_sub_tiles(const APNetlist& netlist) {
 bool PartialPlacement::verify(const APNetlist& netlist,
                               size_t grid_width,
                               size_t grid_height,
-                              size_t grid_num_layers) {
+                              size_t grid_num_layers) const {
     // Check that all the other verify methods passed.
     if (!verify_locs(netlist, grid_width, grid_height))
         return false;

vpr/src/analytical_place/partial_placement.cpp

@@ -12,7 +12,9 @@
 
 #pragma once
 
+#include <cmath>
 #include "ap_netlist.h"
+#include "physical_types.h"
 #include "vtr_vector.h"
 
 /**
@@ -94,6 +96,35 @@ struct PartialPlacement {
         }
     }
 
+    /**
+     * @brief Get the location of the physical tile that contains the given
+     *        AP block.
+     * FIXME: Ideally this should return an ID to the tile, not a location.
+     *        This is important since there is a distinction between the two.
+     *        We know a block will be at that tile, but it would not be at the
+     *        corner of the block (likely it would be at the center).
+     */
+    inline t_physical_tile_loc get_containing_tile_loc(APBlockId blk_id) const {
+        // We take the floor here since we want to know which tile contains this
+        // block. On a grid, if the block is located at x=0.99999, it would still
+        // be in the first tile. This is because we assume that the blocks will
+        // ultimately end up in the center of the tile, not at the top left
+        // corner of it. The physical tile loc is just a way of identifying that
+        // tile.
+        // TODO: This may be a bit more complicated than this. This assumes that
+        //       all tiles are 1x1, but it could be the case that this is on
+        //       the edge of a much larger block. In reality this should try
+        //       to go into the tile where it is closest to the center. What
+        //       is written here is not necessarily wrong, but it may put blocks
+        //       which on are the edge of large blocks into the large blocks.
+        //       However, this may not even matter if the partial legalizer is
+        //       doing its job!
+        int tile_x_loc = std::floor(block_x_locs[blk_id]);
+        int tile_y_loc = std::floor(block_y_locs[blk_id]);
+        int tile_layer = std::floor(block_layer_nums[blk_id]);
+        return t_physical_tile_loc(tile_x_loc, tile_y_loc, tile_layer);
+    }
+
     /**
      * @brief Verify the block_x_locs and block_y_locs vectors
      *
@@ -108,7 +139,7 @@ struct PartialPlacement {
      */
     bool verify_locs(const APNetlist& netlist,
                      size_t grid_width,
-                     size_t grid_height);
+                     size_t grid_height) const;
 
     /**
      * @brief Verify the block_layer_nums vector
@@ -121,7 +152,8 @@ struct PartialPlacement {
      *  @param netlist          The APNetlist used to generate this placement
      *  @param grid_num_layers  The number of layers in the device grid
      */
-    bool verify_layer_nums(const APNetlist& netlist, size_t grid_num_layers);
+    bool verify_layer_nums(const APNetlist& netlist,
+                           size_t grid_num_layers) const;
 
     /**
      * @brief Verify the sub_tiles
@@ -131,7 +163,7 @@ struct PartialPlacement {
      *
      *  @param netlist  The APNetlist used to generate this placement
      */
-    bool verify_sub_tiles(const APNetlist& netlist);
+    bool verify_sub_tiles(const APNetlist& netlist) const;
 
     /**
      * @brief Verify the entire partial placement object
@@ -146,6 +178,6 @@ struct PartialPlacement {
     bool verify(const APNetlist& netlist,
                 size_t grid_width,
                 size_t grid_height,
-                size_t grid_num_layers);
+                size_t grid_num_layers) const;
 };
 

vpr/src/analytical_place/partial_placement.h

@@ -411,6 +411,15 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
             // TODO: Make this return a bool if the placement was successful or not.
             run_analytical_placement_flow(vpr_setup);
         }
+        // Print the placement generated by AP to a .place file.
+        auto& filename_opts = vpr_setup.FileNameOpts;
+        auto& cluster_ctx = g_vpr_ctx.clustering();
+        const auto& block_locs = g_vpr_ctx.placement().block_locs();
+        auto& placement_id = g_vpr_ctx.mutable_placement().placement_id;
+        placement_id = print_place(filename_opts.NetFile.c_str(),
+                                   cluster_ctx.clb_nlist.netlist_id().c_str(),
+                                   filename_opts.PlaceFile.c_str(),
+                                   block_locs);
     }
 
     bool is_flat = vpr_setup.RouterOpts.flat_routing;

vpr/src/base/vpr_api.cpp

@@ -38,6 +38,27 @@
 #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.
  *
@@ -1636,7 +1657,8 @@ 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,
-                                   size_t num_models,
+                                   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,
@@ -1661,7 +1683,7 @@ ClusterLegalizer::ClusterLegalizer(const AtomNetlist& atom_netlist,
     // 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_ = num_models;
+    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,

vpr/src/pack/cluster_legalizer.cpp

@@ -215,10 +215,10 @@ class ClusterLegalizer {
      *                           different cluster types. A reference is stored
      *                           in the class to be used to allocate and load
      *                           the router data.
-     *  @param num_models       The total number of models in the architecture.
-     *                          This is the sum of the number of the user and
-     *                          library models. Used internally to allocate data
-     *                          structures.
+     *  @param user_models  A linked list of the user models. Used to allocate
+     *                      an internal structure.
+     *  @param library_models   A linked list of the library models. Used to
+     *                          allocate an internal structure.
      *  @param target_external_pin_util_str A string used to initialize the
      *                                      target external pin utilization of
      *                                      each cluster type.
@@ -246,7 +246,8 @@ class ClusterLegalizer {
                      const Prepacker& prepacker,
                      const std::vector<t_logical_block_type>& logical_block_types,
                      std::vector<t_lb_type_rr_node>* lb_type_rr_graphs,
-                     size_t num_models,
+                     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,