[Place] Cleaned Up Placement Context Initialization

Cleaned up how the variables in the placement context were initialized
to make it easier to initialize the placement context outside of the
placement stage (Analytical Placement).

Added an optional argument to the Placer class to allow an initial
placement to be passed in. This allows a different initial placement to
be used without having to pull the initial placer out of the Placer
class.

With this change, it should be easier to create the Detailed Placer in
Analytical Placement.

Author: AlexandreSinger

vpr/src/analytical_place/full_legalizer.cpp

@@ -131,30 +131,13 @@ 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(g_vpr_ctx.clustering().clb_nlist,
+                              g_vpr_ctx.device().grid);
 
-        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();
     }
 
     /**
@@ -468,13 +451,11 @@ 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.
+    init_placement_context(g_vpr_ctx.mutable_placement(),
+                           vpr_setup_.PlacerOpts,
+                           vpr_setup_.NocOpts,
+                           arch_.directs);
 
     const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
 
@@ -492,6 +473,9 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
                   num_placement_errors);
     }
 
+    // Clean the placement context.
+    clean_placement_context(g_vpr_ctx.mutable_placement());
+
     // 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.

vpr/src/base/blk_loc_registry.cpp

@@ -1,13 +1,61 @@
 
 #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"
+
+/**
+ * @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) {
+    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();
+}
+
+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

@@ -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(const ClusteredNetlist& clb_nlist, const DeviceGrid& device_grid);
+
   private:
     ///@brief Clustered block placement locations
     vtr::vector_map<ClusterBlockId, t_block_loc> block_locs_;

vpr/src/base/vpr_api.cpp

@@ -845,8 +845,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(g_vpr_ctx.clustering().clb_nlist, device_ctx.grid);
 
     // Alloc and load the placement macros.
     place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,

vpr/src/place/initial_placement.cpp

@@ -1251,23 +1251,13 @@ void initial_placement(const t_placer_opts& placer_opts,
                        vtr::RngContainer& rng) {
     vtr::ScopedStartFinishTimer timer("Initial Placement");
 
-    /* Initialize the grid blocks to empty.
-     * Initialize all the blocks to unplaced.
-     */
-    blk_loc_registry.clear_all_grid_locs();
-
-    /* Go through cluster blocks to calculate the tightest placement
-     * floorplan constraint for each constrained block
-     */
-    propagate_place_constraints(place_macros);
+    // Initialize the block loc registry.
+    blk_loc_registry.init(g_vpr_ctx.clustering().clb_nlist, g_vpr_ctx.device().grid);
 
     /*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*/
     mark_fixed_blocks(blk_loc_registry);
 
-    // Compute and store compressed floorplanning constraints
-    alloc_and_load_compressed_cluster_constraints();
-
     // read the constraint file and place fixed blocks
     if (strlen(constraints_file) != 0) {
         read_constraints(constraints_file, blk_loc_registry);

vpr/src/place/place.cpp

@@ -1,10 +1,18 @@
 
 #include <memory>
+#include <optional>
 
 #include "FlatPlacementInfo.h"
+#include "initial_placement.h"
+#include "load_flat_place.h"
+#include "noc_place_utils.h"
+#include "pack.h"
+#include "place_constraints.h"
 #include "place_macro.h"
+#include "vpr_context.h"
 #include "vtr_assert.h"
 #include "vtr_log.h"
+#include "vtr_memory.h"
 #include "vtr_time.h"
 #include "vpr_types.h"
 #include "vpr_utils.h"
@@ -53,6 +61,18 @@ void try_place(const Netlist<>& net_list,
     const auto& cluster_ctx = g_vpr_ctx.clustering();
     const auto& atom_ctx = g_vpr_ctx.atom();
 
+    // Initialize the variables in the placement context.
+    init_placement_context(g_vpr_ctx.mutable_placement(),
+                           placer_opts,
+                           noc_opts,
+                           directs);
+
+    const bool cube_bb = g_vpr_ctx.placement().cube_bb;
+
+    VTR_LOG("\n");
+    VTR_LOG("Bounding box mode is %s\n", (cube_bb ? "Cube" : "Per-layer"));
+    VTR_LOG("\n");
+
     /* Placement delay model is independent of the placement and can be shared across
      * multiple placers if we are performing parallel annealing.
      * So, it is created and initialized once. */
@@ -74,28 +94,11 @@ void try_place(const Netlist<>& net_list,
         }
     }
 
-    g_vpr_ctx.mutable_placement().cube_bb = is_cube_bb(placer_opts.place_bounding_box_mode, device_ctx.rr_graph);
-    const bool cube_bb = g_vpr_ctx.placement().cube_bb;
-
-    VTR_LOG("\n");
-    VTR_LOG("Bounding box mode is %s\n", (cube_bb ? "Cube" : "Per-layer"));
-    VTR_LOG("\n");
-
-    auto& place_ctx = g_vpr_ctx.mutable_placement();
-
     /* Make the global instance of BlkLocRegistry inaccessible through the getter methods of the
      * placement context. This is done to make sure that the placement stage only accesses its
      * own local instances of BlkLocRegistry.
      */
-    place_ctx.lock_loc_vars();
-    place_ctx.compressed_block_grids = create_compressed_block_grids();
-
-    // Alloc and load the placement macros.
-    place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,
-                                                           device_ctx.physical_tile_types,
-                                                           cluster_ctx.clb_nlist,
-                                                           atom_ctx.nlist,
-                                                           atom_ctx.lookup);
+    g_vpr_ctx.mutable_placement().lock_loc_vars();
 
     /* Start measuring placement time. The measured execution time will be printed
      * when this object goes out of scope at the end of this function.
@@ -107,18 +110,74 @@ void try_place(const Netlist<>& net_list,
     // Enables fast look-up of atom pins connect to CLB pins
     ClusteredPinAtomPinsLookup netlist_pin_lookup(cluster_ctx.clb_nlist, atom_ctx.nlist, pb_gpin_lookup);
 
-    Placer placer(net_list, placer_opts, analysis_opts, noc_opts, pb_gpin_lookup, netlist_pin_lookup,
+    Placer placer(net_list, {}, placer_opts, analysis_opts, noc_opts, pb_gpin_lookup, netlist_pin_lookup,
                   flat_placement_info, place_delay_model, cube_bb, is_flat, /*quiet=*/false);
 
     placer.place();
 
-    vtr::release_memory(place_ctx.compressed_block_grids);
-
     /* The placer object has its own copy of block locations and doesn't update
      * the global context directly. We need to copy its internal data structures
      * to the global placement context before it goes out of scope.
      */
-    placer.copy_locs_to_global_state(place_ctx);
+    placer.copy_locs_to_global_state(g_vpr_ctx.mutable_placement());
+
+    // Clean the variables in the placement context. This will deallocate memory
+    // used by variables which were allocated in the placement context and are
+    // never used outside of placement.
+    clean_placement_context(g_vpr_ctx.mutable_placement());
+}
+
+void init_placement_context(PlacementContext& place_ctx,
+                            const t_placer_opts& placer_opts,
+                            const t_noc_opts& noc_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();
+
+    place_ctx.cube_bb = is_cube_bb(placer_opts.place_bounding_box_mode, device_ctx.rr_graph);
+
+    place_ctx.compressed_block_grids = create_compressed_block_grids();
+
+    // Alloc and load the placement macros.
+    place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,
+                                                           device_ctx.physical_tile_types,
+                                                           cluster_ctx.clb_nlist,
+                                                           atom_ctx.nlist,
+                                                           atom_ctx.lookup);
+
+    /* Go through cluster blocks to calculate the tightest placement
+     * floorplan constraint for each constrained block.
+     */
+    propagate_place_constraints(*place_ctx.place_macros);
+
+    // Compute and store compressed floorplanning constraints.
+    alloc_and_load_compressed_cluster_constraints();
+
+    /* To make sure the importance of NoC-related cost terms compared to
+     * BB and timing cost is determine only through NoC placement weighting factor,
+     * we normalize NoC-related cost weighting factors so that they add up to 1.
+     * With this normalization, NoC-related cost weighting factors only determine
+     * the relative importance of NoC cost terms with respect to each other, while
+     * the importance of total NoC cost to conventional placement cost is determined
+     * by NoC placement weighting factor.
+     * FIXME: Why is this modifying the noc_opts?
+     */
+    if (noc_opts.noc) {
+        normalize_noc_cost_weighting_factor(const_cast<t_noc_opts&>(noc_opts));
+    }
+}
+
+void clean_placement_context(PlacementContext& place_ctx) {
+    vtr::release_memory(place_ctx.compressed_block_grids);
+
+    // The cluster constraints are loaded in propagate_place_constraints and are
+    // not used outside of placement.
+    vtr::release_memory(g_vpr_ctx.mutable_floorplanning().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(g_vpr_ctx.mutable_floorplanning().compressed_cluster_constraints);
 }
 
 static bool is_cube_bb(const e_place_bounding_box_mode place_bb_mode,

vpr/src/place/place.h

@@ -4,6 +4,7 @@
 #include "vpr_types.h"
 
 class FlatPlacementInfo;
+class PlacementContext;
 
 void try_place(const Netlist<>& net_list,
                const t_placer_opts& placer_opts,
@@ -17,3 +18,32 @@ void try_place(const Netlist<>& net_list,
                const FlatPlacementInfo& flat_placement_info,
                bool is_flat);
 
+/**
+ * @brief Initialize the variables stored within the placement context. This
+ *        must be called before using the Placer class.
+ *
+ *  @param place_ctx
+ *      The placement context to initialize.
+ *  @param placer_opts
+ *      The options passed into the placer.
+ *  @param noc_opts
+ *      The options passed into the placer for NoCs.
+ *  @param directs
+ *      A list of the direct connections in the architecture.
+ */
+void init_placement_context(PlacementContext& place_ctx,
+                            const t_placer_opts& placer_opts,
+                            const t_noc_opts& noc_opts,
+                            const std::vector<t_direct_inf>& directs);
+
+/**
+ * @brief Clean variables from the placement context which are not used outside
+ *        of placement.
+ *
+ * These 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(PlacementContext& place_ctx);
+