[Place] Updated Place Context Init Based on Soheil Comments

Author: AlexandreSinger

vpr/src/analytical_place/full_legalizer.cpp

@@ -130,8 +130,7 @@ class APClusterPlacer {
                 : place_macros_(place_macros) {
         // Initialize the block loc registry.
         auto& blk_loc_registry = g_vpr_ctx.mutable_placement().mutable_blk_loc_registry();
-        blk_loc_registry.init(g_vpr_ctx.clustering().clb_nlist,
-                              g_vpr_ctx.device().grid);
+        blk_loc_registry.init();
 
         // Place the fixed blocks and mark them as fixed.
         mark_fixed_blocks(blk_loc_registry);
@@ -351,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
@@ -445,13 +443,14 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
     // Initialize the placement context.
-    init_placement_context(g_vpr_ctx.mutable_placement(),
-                           vpr_setup_.PlacerOpts,
-                           vpr_setup_.NocOpts,
-                           arch_.directs);
+    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);
 
@@ -467,7 +466,10 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
     }
 
     // Clean the placement context.
-    clean_placement_context(g_vpr_ctx.mutable_placement());
+    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
@@ -505,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

@@ -7,18 +7,12 @@
 #include "physical_types_util.h"
 #include "vpr_context.h"
 
-/**
- * @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 subtile would be marked ClusterBlockId::INVALID().
- */
-static GridBlock init_grid_blocks(const DeviceGrid& device_grid);
-
 BlkLocRegistry::BlkLocRegistry()
     : expected_transaction_(e_expected_transaction::APPLY) {}
 
-void BlkLocRegistry::init(const ClusteredNetlist& clb_nlist, const DeviceGrid& device_grid) {
+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();
 
@@ -27,35 +21,14 @@ void BlkLocRegistry::init(const ClusteredNetlist& clb_nlist, const DeviceGrid& d
     block_locs.resize(clb_nlist.blocks().size());
 
     /* Initialize the reverse lookup of CLB block positions */
-    grid_blocks = init_grid_blocks(device_grid);
+    grid_blocks.init_grid_blocks(device_grid);
 
     /* Initialize the grid blocks to empty.
      * Initialize all the blocks to unplaced.
      */
     clear_all_grid_locs();
 }
 
-static GridBlock init_grid_blocks(const DeviceGrid& device_grid) {
-    size_t grid_width = device_grid.width();
-    size_t grid_height = device_grid.height();
-    int num_layers = device_grid.get_num_layers();
-
-    /* Structure should have the same dimensions as the grid. */
-    auto grid_blocks = GridBlock(grid_width, grid_height, num_layers);
-
-    for (int 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, layer_num});
-                auto type = device_grid.get_physical_type(tile_loc);
-                grid_blocks.initialized_grid_block_at_location(tile_loc, type->capacity);
-            }
-        }
-    }
-
-    return grid_blocks;
-}
-
 const vtr::vector_map<ClusterBlockId, t_block_loc>& BlkLocRegistry::block_locs() const {
     return  block_locs_;
 }

vpr/src/base/blk_loc_registry.h

@@ -28,7 +28,7 @@ class BlkLocRegistry {
 
     /// @brief Initialize the block loc registry's internal data. Must be called
     ///        before any other method is called.
-    void init(const ClusteredNetlist& clb_nlist, const DeviceGrid& device_grid);
+    void init();
 
   private:
     ///@brief Clustered block placement locations

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);
@@ -844,7 +844,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup,
     const auto& filename_opts = vpr_setup.FileNameOpts;
 
     //Initialize the block location registry, which will be filled when loading placement
-    blk_loc_registry.init(g_vpr_ctx.clustering().clb_nlist, device_ctx.grid);
+    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
      *

vpr/src/place/initial_placement.cpp

@@ -1298,7 +1298,7 @@ void initial_placement(const t_placer_opts& placer_opts,
     vtr::ScopedStartFinishTimer timer("Initial Placement");
 
     // Initialize the block loc registry.
-    blk_loc_registry.init(g_vpr_ctx.clustering().clb_nlist, g_vpr_ctx.device().grid);
+    blk_loc_registry.init();
 
     /*Mark the blocks that have already been locked to one spot via floorplan constraints
      * as fixed, so they do not get moved during initial placement or later during the simulated annealing stage of placement*/