Merge pull request #2902 from AlexandreSinger/feature-ap-detailed-placer

[Place] Cleaned Up Placement Context Initialization

Author: AlexandreSinger

vpr/src/analytical_place/full_legalizer.cpp

@@ -128,30 +128,12 @@ class APClusterPlacer {
      */
     APClusterPlacer(const PlaceMacros& place_macros)
                 : place_macros_(place_macros) {
-        // FIXME: This was stolen from place/place.cpp
-        //        it used a static method, just taking what I think I will need.
+        // Initialize the block loc registry.
         auto& blk_loc_registry = g_vpr_ctx.mutable_placement().mutable_blk_loc_registry();
+        blk_loc_registry.init();
 
-        init_placement_context(blk_loc_registry);
-
-        // stolen from place/place.cpp:alloc_and_load_try_swap_structs
-        // FIXME: set cube_bb to false by hand, should be passed in.
-        g_vpr_ctx.mutable_placement().cube_bb = false;
-        g_vpr_ctx.mutable_placement().compressed_block_grids = create_compressed_block_grids();
-
-        // TODO: The next few steps will be basically a direct copy of the initial
-        //       placement code since it does everything we need! It would be nice
-        //       to share the code.
-
-        // Clear the grid locations (stolen from initial_placement)
-        blk_loc_registry.clear_all_grid_locs();
-
-        // Deal with the placement constraints.
-        propagate_place_constraints(place_macros_);
-
+        // Place the fixed blocks and mark them as fixed.
         mark_fixed_blocks(blk_loc_registry);
-
-        alloc_and_load_compressed_cluster_constraints();
     }
 
     /**
@@ -368,7 +350,6 @@ void NaiveFullLegalizer::create_clusters(const PartialPlacement& p_placement) {
     // FIXME: This writing and loading from a file is wasteful. Should generate
     //        the clusters directly from the cluster legalizer.
     vpr_load_packing(vpr_setup_, arch_);
-    load_cluster_constraints();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     // Verify the packing and print some info
@@ -461,16 +442,15 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
     // TODO: Eventually should be returned from the create_clusters method.
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
-    // Alloc and load the placement macros.
-    VTR_ASSERT(!g_vpr_ctx.placement().place_macros);
-    g_vpr_ctx.mutable_placement().place_macros = std::make_unique<PlaceMacros>(g_vpr_ctx.device().arch->directs,
-                                                                               g_vpr_ctx.device().physical_tile_types,
-                                                                               g_vpr_ctx.clustering().clb_nlist,
-                                                                               g_vpr_ctx.atom().nlist,
-                                                                               g_vpr_ctx.atom().lookup);
+    // Initialize the placement context.
+    g_vpr_ctx.mutable_placement().init_placement_context(vpr_setup_.PlacerOpts,
+                                                         arch_.directs);
 
     const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
 
+    // Update the floorplanning context with the macro information.
+    g_vpr_ctx.mutable_floorplanning().update_floorplanning_context_pre_place(place_macros);
+
     // Place the clusters based on where the atoms want to be placed.
     place_clusters(clb_nlist, place_macros, p_placement);
 
@@ -485,6 +465,12 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
                   num_placement_errors);
     }
 
+    // Clean the placement context.
+    g_vpr_ctx.mutable_placement().clean_placement_context_post_place();
+
+    // Clean the floorplanning context.
+    g_vpr_ctx.mutable_floorplanning().clean_floorplanning_context_post_place();
+
     // TODO: This was taken from vpr_api. Not sure why it is needed. Should be
     //       made part of the placement and verify placement should check for
     //       it.
@@ -521,7 +507,6 @@ void APPack::legalize(const PartialPlacement& p_placement) {
     // The Packer stores the clusters into a .net file. Load the packing file.
     // FIXME: This should be removed. Reading from a file is strange.
     vpr_load_packing(vpr_setup_, arch_);
-    load_cluster_constraints();
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     // Verify the packing and print some info

vpr/src/base/blk_loc_registry.cpp

@@ -1,13 +1,34 @@
 
 #include "blk_loc_registry.h"
 
+#include "device_grid.h"
 #include "move_transactions.h"
 #include "globals.h"
 #include "physical_types_util.h"
+#include "vpr_context.h"
 
 BlkLocRegistry::BlkLocRegistry()
     : expected_transaction_(e_expected_transaction::APPLY) {}
 
+void BlkLocRegistry::init() {
+    const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
+    const DeviceGrid& device_grid = g_vpr_ctx.device().grid;
+    auto& block_locs = mutable_block_locs();
+    auto& grid_blocks = mutable_grid_blocks();
+
+    /* Initialize the lookup of CLB block positions */
+    block_locs.clear();
+    block_locs.resize(clb_nlist.blocks().size());
+
+    /* Initialize the reverse lookup of CLB block positions */
+    grid_blocks.init_grid_blocks(device_grid);
+
+    /* Initialize the grid blocks to empty.
+     * Initialize all the blocks to unplaced.
+     */
+    clear_all_grid_locs();
+}
+
 const vtr::vector_map<ClusterBlockId, t_block_loc>& BlkLocRegistry::block_locs() const {
     return  block_locs_;
 }

vpr/src/base/blk_loc_registry.h

@@ -26,6 +26,10 @@ class BlkLocRegistry {
     BlkLocRegistry(BlkLocRegistry&&) = delete;
     BlkLocRegistry& operator=(BlkLocRegistry&&) = delete;
 
+    /// @brief Initialize the block loc registry's internal data. Must be called
+    ///        before any other method is called.
+    void init();
+
   private:
     ///@brief Clustered block placement locations
     vtr::vector_map<ClusterBlockId, t_block_loc> block_locs_;

vpr/src/base/grid_block.cpp

@@ -1,7 +1,28 @@
 
 #include "grid_block.h"
 
+#include "device_grid.h"
 #include "globals.h"
+#include "physical_types.h"
+
+void GridBlock::init_grid_blocks(const DeviceGrid& device_grid) {
+    size_t grid_width = device_grid.width();
+    size_t grid_height = device_grid.height();
+    size_t num_layers = device_grid.get_num_layers();
+
+    /* Structure should have the same dimensions as the grid. */
+    grid_blocks_.resize({num_layers, grid_width, grid_height});
+
+    for (size_t layer_num = 0; layer_num < num_layers; layer_num++) {
+        for (size_t x = 0; x < grid_width; x++) {
+            for (size_t y = 0; y < grid_height; y++) {
+                const t_physical_tile_loc tile_loc({(int)x, (int)y, (int)layer_num});
+                auto type = device_grid.get_physical_type(tile_loc);
+                initialized_grid_block_at_location(tile_loc, type->capacity);
+            }
+        }
+    }
+}
 
 void GridBlock::zero_initialize() {
     auto& device_ctx = g_vpr_ctx.device();

vpr/src/base/grid_block.h

@@ -38,6 +38,14 @@ class GridBlock {
         grid_blocks_.resize({layers, width, height});
     }
 
+    /**
+     * @brief Initialize `grid_blocks`, the inverse structure of `block_locs`.
+     *
+     * The container at each grid block location should have a length equal to the
+     * subtile capacity of that block. Unused subtiles would be marked ClusterBlockId::INVALID().
+     */
+    void init_grid_blocks(const DeviceGrid& device_grid);
+
     inline void initialized_grid_block_at_location(const t_physical_tile_loc& loc, int num_sub_tiles) {
         grid_blocks_[loc.layer_num][loc.x][loc.y].blocks.resize(num_sub_tiles, ClusterBlockId::INVALID());
     }

vpr/src/base/vpr_api.cpp

@@ -69,7 +69,6 @@
 #include "atom_netlist_utils.h"
 #include "output_clustering.h"
 #include "vpr_constraints_reader.h"
-#include "place_constraints.h"
 #include "place_util.h"
 #include "timing_fail_error.h"
 #include "analytical_placement_flow.h"
@@ -683,8 +682,9 @@ void vpr_load_packing(const t_vpr_setup& vpr_setup, const t_arch& arch) {
         report_packing_pin_usage(ofs, g_vpr_ctx);
     }
 
-    // Load cluster_constraints data structure.
-    load_cluster_constraints();
+    // Ater the clustered netlist has been loaded, update the floorplanning
+    // constraints with the new information.
+    g_vpr_ctx.mutable_floorplanning().update_floorplanning_context_post_pack();
 
     /* Sanity check the resulting netlist */
     check_netlist(vpr_setup.PackerOpts.pack_verbosity);
@@ -843,8 +843,8 @@ void vpr_load_placement(t_vpr_setup& vpr_setup,
     auto& blk_loc_registry = place_ctx.mutable_blk_loc_registry();
     const auto& filename_opts = vpr_setup.FileNameOpts;
 
-    //Initialize placement data structures, which will be filled when loading placement
-    init_placement_context(blk_loc_registry);
+    //Initialize the block location registry, which will be filled when loading placement
+    blk_loc_registry.init();
 
     // Alloc and load the placement macros.
     place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,

vpr/src/base/vpr_context.cpp

@@ -0,0 +1,103 @@
+/**
+ * @file
+ * @author  Alex Singer
+ * @date    February 2025
+ * @brief   Implementation of the more complicated context member functions.
+ *          These are methods used to initialize / clean the contexts.
+ */
+
+#include "vpr_context.h"
+#include <memory>
+#include "compressed_grid.h"
+#include "globals.h"
+#include "physical_types.h"
+#include "place_constraints.h"
+#include "place_macro.h"
+#include "vpr_types.h"
+#include "vtr_memory.h"
+
+/**
+ * @brief determine the type of the bounding box used by the placer to predict
+ * the wirelength.
+ *
+ * @param place_bb_mode The bounding box mode passed by the CLI
+ * @param rr_graph The routing resource graph
+ */
+static bool is_cube_bb(const e_place_bounding_box_mode place_bb_mode,
+                       const RRGraphView& rr_graph);
+
+void FloorplanningContext::update_floorplanning_context_post_pack() {
+    // Initialize the cluster_constraints using the constraints loaded from the
+    // user and clustering generated from packing.
+    load_cluster_constraints();
+}
+
+void FloorplanningContext::update_floorplanning_context_pre_place(
+                                    const PlaceMacros& place_macros) {
+    // Go through cluster blocks to calculate the tightest placement
+    // floorplan constraint for each constrained block.
+    propagate_place_constraints(place_macros);
+
+    // Compute and store compressed floorplanning constraints.
+    alloc_and_load_compressed_cluster_constraints();
+}
+
+void FloorplanningContext::clean_floorplanning_context_post_place() {
+    // The cluster constraints are loaded in propagate_place_constraints and are
+    // not used outside of placement.
+    vtr::release_memory(cluster_constraints);
+
+    // The compressed cluster constraints are loaded in alloc_and_laod_compressed
+    // cluster_constraints and are not used outside of placement.
+    vtr::release_memory(compressed_cluster_constraints);
+}
+
+void PlacementContext::init_placement_context(
+                                    const t_placer_opts& placer_opts,
+                                    const std::vector<t_direct_inf>& directs) {
+    const AtomContext& atom_ctx = g_vpr_ctx.atom();
+    const ClusteringContext& cluster_ctx = g_vpr_ctx.clustering();
+    const DeviceContext& device_ctx = g_vpr_ctx.device();
+
+    cube_bb = is_cube_bb(placer_opts.place_bounding_box_mode, device_ctx.rr_graph);
+
+    compressed_block_grids = create_compressed_block_grids();
+
+    // Alloc and load the placement macros.
+    place_macros = std::make_unique<PlaceMacros>(directs,
+                                                 device_ctx.physical_tile_types,
+                                                 cluster_ctx.clb_nlist,
+                                                 atom_ctx.nlist,
+                                                 atom_ctx.lookup);
+}
+
+static bool is_cube_bb(const e_place_bounding_box_mode place_bb_mode,
+                       const RRGraphView& rr_graph) {
+    bool cube_bb;
+    const int number_layers = g_vpr_ctx.device().grid.get_num_layers();
+
+    if (place_bb_mode == e_place_bounding_box_mode::AUTO_BB) {
+        // If the auto_bb is used, we analyze the RR graph to see whether is there any inter-layer connection that is not
+        // originated from OPIN. If there is any, cube BB is chosen, otherwise, per-layer bb is chosen.
+        if (number_layers > 1 && inter_layer_connections_limited_to_opin(rr_graph)) {
+            cube_bb = false;
+        } else {
+            cube_bb = true;
+        }
+    } else if (place_bb_mode == e_place_bounding_box_mode::CUBE_BB) {
+        // The user has specifically asked for CUBE_BB
+        cube_bb = true;
+    } else {
+        // The user has specifically asked for PER_LAYER_BB
+        VTR_ASSERT_SAFE(place_bb_mode == e_place_bounding_box_mode::PER_LAYER_BB);
+        cube_bb = false;
+    }
+
+    return cube_bb;
+}
+
+void PlacementContext::clean_placement_context_post_place() {
+    // The compressed block grids are currently only used during placement.
+    vtr::release_memory(compressed_block_grids);
+}
+

vpr/src/base/vpr_context.h

@@ -6,6 +6,7 @@
 #include <mutex>
 
 #include "FlatPlacementInfo.h"
+#include "physical_types.h"
 #include "place_macro.h"
 #include "user_place_constraints.h"
 #include "user_route_constraints.h"
@@ -337,6 +338,30 @@ struct PlacementContext : public Context {
 
   public:
 
+    /**
+     * @brief Initialize the variables stored within the placement context. This
+     *        must be called before performing placement, but must be called
+     *        after the clusters are loaded.
+     *
+     *  @param placer_opts
+     *      The options passed into the placer.
+     *  @param directs
+     *      A list of the direct connections in the architecture.
+     */
+    void init_placement_context(const t_placer_opts& placer_opts,
+                                const std::vector<t_direct_inf>& directs);
+
+    /**
+     * @brief Clean variables from the placement context which are not used
+     *        outside of placement.
+     *
+     * There are some variables that are stored in the placement context and are
+     * only used in placement; while there are some that are used outside of
+     * placement. This method frees up the memory of the variables used only
+     * within placement.
+     */
+    void clean_placement_context_post_place();
+
     const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.block_locs(); }
     vtr::vector_map<ClusterBlockId, t_block_loc>& mutable_block_locs() { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.mutable_block_locs(); }
     const GridBlock& grid_blocks() const { VTR_ASSERT_SAFE(loc_vars_are_accessible_); return blk_loc_registry_.grid_blocks(); }
@@ -480,6 +505,42 @@ struct RoutingContext : public Context {
  * to certain regions on the chip.
  */
 struct FloorplanningContext : public Context {
+    /**
+     * @brief Update the floorplanning constraints after a clustering has been
+     *        created.
+     *
+     * After clustering, the constraints of contained atoms are used to compute
+     * the constraints of clusters.
+     *
+     * This must be called before using the cluster_constraints.
+     */
+    void update_floorplanning_context_post_pack();
+
+    /**
+     * @brief Update the floorplanning constraints before placement.
+     *
+     * Placement groups clusters together into macros which must be placed
+     * together. This imposes more constraints onto the clusters which needs to
+     * be updated.
+     *
+     * This must be called before placement, but after the placement context is
+     * initialized.
+     *
+     *  @param place_macros
+     *      Macros of clusters which must be placed together. Initialized in the
+     *      placement context.
+     */
+    void update_floorplanning_context_pre_place(const PlaceMacros& place_macros);
+
+    /**
+     * @brief Clean the floorplanning constraints after placement.
+     *
+     * After placement, many of the variables in this class will no longer be
+     * used (since the placement is no longer changing, the constraints are no
+     * longer needed). This method will free up the memory used by this class.
+     */
+    void clean_floorplanning_context_post_place();
+
     /**
      * @brief Stores groups of constrained atoms, areas where the atoms are constrained to
      *