[Place] Moved Place Macros From Clustering to Placement Context

AlexandreSinger · AlexandreSinger · commit 38b09e2466f0 · 2025-02-15T13:52:55.000-05:00
Vaughn thought that the place macros made more sense in the placement
context instead of the clustering context.
diff --git a/vpr/src/analytical_place/full_legalizer.cpp b/vpr/src/analytical_place/full_legalizer.cpp
@@ -467,7 +467,16 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
     // Get the clustering from the global context.
     // TODO: Eventually should be returned from the create_clusters method.
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
-    const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
+
+    // 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);
+
+    const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
 
     // Place the clusters based on where the atoms want to be placed.
     place_clusters(clb_nlist, place_macros, p_placement);
@@ -533,9 +542,7 @@ void APPack::legalize(const PartialPlacement& p_placement) {
     // TODO: This should only be the initial placer. Running the full SA would
     //       be more of a Detailed Placer.
     const auto& placement_net_list = (const Netlist<>&)clb_nlist;
-    const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
     try_place(placement_net_list,
-              place_macros,
               vpr_setup_.PlacerOpts,
               vpr_setup_.RouterOpts,
               vpr_setup_.AnalysisOpts,
diff --git a/vpr/src/base/place_and_route.cpp b/vpr/src/base/place_and_route.cpp
@@ -46,7 +46,6 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                                   const t_noc_opts& noc_opts,
                                   const t_file_name_opts& filename_opts,
                                   const t_arch* arch,
-                                  const PlaceMacros& place_macros,
                                   bool verify_binary_search,
                                   int min_chan_width_hint,
                                   t_det_routing_arch* det_routing_arch,
@@ -168,7 +167,6 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
         if (placer_opts.place_freq == PLACE_ALWAYS) {
             placer_opts.place_chan_width = current;
             try_place(placement_net_list,
-                      place_macros,
                       placer_opts,
                       router_opts,
                       analysis_opts,
@@ -313,7 +311,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                 break;
             if (placer_opts.place_freq == PLACE_ALWAYS) {
                 placer_opts.place_chan_width = current;
-                try_place(placement_net_list, place_macros, placer_opts, router_opts, analysis_opts, noc_opts,
+                try_place(placement_net_list, placer_opts, router_opts, analysis_opts, noc_opts,
                           arch->Chans, det_routing_arch, segment_inf,
                           arch->directs,
                           FlatPlacementInfo(),  // Pass empty flat placement info.
diff --git a/vpr/src/base/place_and_route.h b/vpr/src/base/place_and_route.h
@@ -11,8 +11,6 @@
 #include "RoutingDelayCalculator.h"
 #include "rr_graph.h"
 
-class PlaceMacros;
-
 struct t_fmap_cell {
     int fs;         ///<at this fs
     int fc;         ///<at this fc
@@ -29,7 +27,6 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                                   const t_noc_opts& noc_opts,
                                   const t_file_name_opts& filename_opts,
                                   const t_arch* arch,
-                                  const PlaceMacros& place_macros,
                                   bool verify_binary_search,
                                   int min_chan_width_hint,
                                   t_det_routing_arch* det_routing_arch,
diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp
@@ -15,9 +15,11 @@
 #include <cstring>
 #include <cmath>
 #include <memory>
+#include <vector>
 
 #include "FlatPlacementInfo.h"
 #include "cluster_util.h"
+#include "physical_types.h"
 #include "place_macro.h"
 #include "verify_placement.h"
 #include "vpr_context.h"
@@ -394,8 +396,7 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
 
     { //Place
         const auto& placement_net_list = (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
-        const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
-        bool place_success = vpr_place_flow(placement_net_list, vpr_setup, arch, place_macros);
+        bool place_success = vpr_place_flow(placement_net_list, vpr_setup, arch);
 
         if (!place_success) {
             return false; //Unimplementable
@@ -420,10 +421,9 @@ bool vpr_flow(t_vpr_setup& vpr_setup, t_arch& arch) {
 
     bool is_flat = vpr_setup.RouterOpts.flat_routing;
     const Netlist<>& router_net_list = is_flat ? (const Netlist<>&)g_vpr_ctx.atom().nlist : (const Netlist<>&)g_vpr_ctx.clustering().clb_nlist;
-    const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
     RouteStatus route_status;
     { //Route
-        route_status = vpr_route_flow(router_net_list, vpr_setup, arch, place_macros, is_flat);
+        route_status = vpr_route_flow(router_net_list, vpr_setup, arch, is_flat);
     }
     { //Analysis
         vpr_analysis_flow(router_net_list, vpr_setup, arch, route_status, is_flat);
@@ -709,13 +709,6 @@ void vpr_load_packing(const t_vpr_setup& vpr_setup, const t_arch& arch) {
     // print the total number of used physical blocks for each
     // physical block type after finishing the packing stage
     print_pb_type_count(g_vpr_ctx.clustering().clb_nlist);
-
-    // Alloc and load the placement macros.
-    cluster_ctx.place_macros = std::make_unique<PlaceMacros>(arch.directs,
-                                                             g_vpr_ctx.device().physical_tile_types,
-                                                             cluster_ctx.clb_nlist,
-                                                             g_vpr_ctx.atom().nlist,
-                                                             g_vpr_ctx.atom().lookup);
 }
 
 bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
@@ -754,8 +747,7 @@ bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
 
 bool vpr_place_flow(const Netlist<>& net_list,
                     t_vpr_setup& vpr_setup,
-                    const t_arch& arch,
-                    const PlaceMacros& place_macros) {
+                    const t_arch& arch) {
     VTR_LOG("\n");
     const auto& placer_opts = vpr_setup.PlacerOpts;
     const auto& filename_opts = vpr_setup.FileNameOpts;
@@ -764,13 +756,13 @@ bool vpr_place_flow(const Netlist<>& net_list,
     } else {
         if (placer_opts.doPlacement == STAGE_DO) {
             //Do the actual placement
-            vpr_place(net_list, vpr_setup, arch, place_macros);
+            vpr_place(net_list, vpr_setup, arch);
 
         } else {
             VTR_ASSERT(placer_opts.doPlacement == STAGE_LOAD);
 
             //Load a previous placement
-            vpr_load_placement(vpr_setup);
+            vpr_load_placement(vpr_setup, arch.directs);
         }
 
         post_place_sync();
@@ -797,8 +789,7 @@ bool vpr_place_flow(const Netlist<>& net_list,
 
 void vpr_place(const Netlist<>& net_list,
                t_vpr_setup& vpr_setup,
-               const t_arch& arch,
-               const PlaceMacros& place_macros) {
+               const t_arch& arch) {
     bool is_flat = false;
     if (vpr_setup.PlacerOpts.place_algorithm.is_timing_driven()) {
         // Prime lookahead cache to avoid adding lookahead computation cost to
@@ -823,7 +814,6 @@ void vpr_place(const Netlist<>& net_list,
     }
 
     try_place(net_list,
-              place_macros,
               vpr_setup.PlacerOpts,
               vpr_setup.RouterOpts,
               vpr_setup.AnalysisOpts,
@@ -846,7 +836,8 @@ void vpr_place(const Netlist<>& net_list,
                                block_locs);
 }
 
-void vpr_load_placement(t_vpr_setup& vpr_setup) {
+void vpr_load_placement(t_vpr_setup& vpr_setup,
+                        const std::vector<t_direct_inf> directs) {
     vtr::ScopedStartFinishTimer timer("Load Placement");
 
     const auto& device_ctx = g_vpr_ctx.device();
@@ -857,6 +848,13 @@ void vpr_load_placement(t_vpr_setup& vpr_setup) {
     //Initialize placement data structures, which will be filled when loading placement
     init_placement_context(blk_loc_registry);
 
+    // Alloc and load the placement macros.
+    place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,
+                                                           device_ctx.physical_tile_types,
+                                                           g_vpr_ctx.clustering().clb_nlist,
+                                                           g_vpr_ctx.atom().nlist,
+                                                           g_vpr_ctx.atom().lookup);
+
     //Load an existing placement from a file
     place_ctx.placement_id = read_place(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(),
                                         blk_loc_registry,
@@ -878,7 +876,6 @@ void vpr_load_placement(t_vpr_setup& vpr_setup) {
 RouteStatus vpr_route_flow(const Netlist<>& net_list,
                            t_vpr_setup& vpr_setup,
                            const t_arch& arch,
-                           const PlaceMacros& place_macros,
                            bool is_flat) {
     VTR_LOG("\n");
 
@@ -925,7 +922,7 @@ RouteStatus vpr_route_flow(const Netlist<>& net_list,
             //Do the actual routing
             if (NO_FIXED_CHANNEL_WIDTH == chan_width) {
                 //Find minimum channel width
-                route_status = vpr_route_min_W(net_list, vpr_setup, arch, timing_info, routing_delay_calc, net_delay, place_macros, is_flat);
+                route_status = vpr_route_min_W(net_list, vpr_setup, arch, timing_info, routing_delay_calc, net_delay, is_flat);
             } else {
                 //Route at specified channel width
                 route_status = vpr_route_fixed_W(net_list, vpr_setup, arch, chan_width, timing_info, routing_delay_calc, net_delay, is_flat);
@@ -1055,7 +1052,6 @@ RouteStatus vpr_route_min_W(const Netlist<>& net_list,
                             std::shared_ptr<SetupHoldTimingInfo> timing_info,
                             std::shared_ptr<RoutingDelayCalculator> delay_calc,
                             NetPinsMatrix<float>& net_delay,
-                            const PlaceMacros& place_macros,
                             bool is_flat) {
     // Note that lookahead cache is not primed here because
     // binary_search_place_and_route will change the channel width, and result
@@ -1072,7 +1068,6 @@ RouteStatus vpr_route_min_W(const Netlist<>& net_list,
                                               vpr_setup.NocOpts,
                                               vpr_setup.FileNameOpts,
                                               &arch,
-                                              place_macros,
                                               router_opts.verify_binary_search,
                                               router_opts.min_channel_width_hint,
                                               &vpr_setup.RoutingArch,
diff --git a/vpr/src/base/vpr_api.h b/vpr/src/base/vpr_api.h
@@ -41,8 +41,6 @@
 
 #include "vpr_error.h"
 
-class PlaceMacros;
-
 /*
  * Main VPR Operations
  */
@@ -75,25 +73,23 @@ bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch);
 ///@brief Perform, load or skip the placement stage
 bool vpr_place_flow(const Netlist<>& net_list,
                     t_vpr_setup& vpr_setup,
-                    const t_arch& arch,
-                    const PlaceMacros& place_macros);
+                    const t_arch& arch);
 
 ///@brief Perform placement
 void vpr_place(const Netlist<>& net_list,
                t_vpr_setup& vpr_setup,
-               const t_arch& arch,
-               const PlaceMacros& place_macros);
+               const t_arch& arch);
 
 ///@brief Loads a previous placement
-void vpr_load_placement(t_vpr_setup& vpr_setup);
+void vpr_load_placement(t_vpr_setup& vpr_setup,
+                        const std::vector<t_direct_inf> directs);
 
 /* Routing */
 
 ///@brief Perform, load or skip the routing stage
 RouteStatus vpr_route_flow(const Netlist<>& net_list,
                            t_vpr_setup& vpr_setup,
                            const t_arch& arch,
-                           const PlaceMacros& place_macros,
                            bool is_flat);
 
 ///@brief Perform routing at a fixed channel width)
@@ -113,7 +109,6 @@ RouteStatus vpr_route_min_W(const Netlist<>& net_list,
                             std::shared_ptr<SetupHoldTimingInfo> timing_info,
                             std::shared_ptr<RoutingDelayCalculator> delay_calc,
                             NetPinsMatrix<float>& net_delay,
-                            const PlaceMacros& place_macros,
                             bool is_flat);
 
 ///@brief Loads a previous routing
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -301,14 +301,6 @@ struct ClusteringContext : public Context {
     ///        clustered block [0 .. num_clustered_blocks-1]
     /// This is populated when the packing is loaded.
     vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
-
-    /// @brief Collection of all the placement macros in the netlist. A placement
-    ///        macro is a set of clustered blocks that must be placed in a way
-    ///        that is compliant with relative locations specified by the macro.
-    ///        Macros are used during placement and are not modified after they
-    ///        are created.
-    /// This is created when the packing is loaded.
-    std::unique_ptr<PlaceMacros> place_macros;
 };
 
 /**
@@ -371,6 +363,16 @@ struct PlacementContext : public Context {
      */
     void unlock_loc_vars() { VTR_ASSERT_SAFE(!loc_vars_are_accessible_); loc_vars_are_accessible_ = true; }
 
+    /**
+     * @brief Collection of all the placement macros in the netlist. A placement
+     *        macro is a set of clustered blocks that must be placed in a way
+     *        that is compliant with relative locations specified by the macro.
+     *        Macros are used during placement and are not modified after they
+     *        are created.
+     * This is created at the start of placement.
+     */
+    std::unique_ptr<PlaceMacros> place_macros;
+
     /**
      * @brief Compressed grid space for each block type
      *
diff --git a/vpr/src/draw/draw_basic.cpp b/vpr/src/draw/draw_basic.cpp
@@ -777,8 +777,8 @@ void draw_placement_macros(ezgl::renderer* g) {
 
     const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
 
-    VTR_ASSERT(g_vpr_ctx.clustering().place_macros);
-    const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
+    VTR_ASSERT(g_vpr_ctx.placement().place_macros);
+    const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
 
     for (const t_pl_macro& pl_macro : place_macros.macros()) {
 
diff --git a/vpr/src/place/place.cpp b/vpr/src/place/place.cpp
@@ -33,7 +33,6 @@ static bool is_cube_bb(const e_place_bounding_box_mode place_bb_mode,
 
 /*****************************************************************************/
 void try_place(const Netlist<>& net_list,
-               const PlaceMacros& place_macros,
                const t_placer_opts& placer_opts,
                const t_router_opts& router_opts,
                const t_analysis_opts& analysis_opts,
@@ -91,6 +90,13 @@ void try_place(const Netlist<>& net_list,
     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);
+
     /* Start measuring placement time. The measured execution time will be printed
      * when this object goes out of scope at the end of this function.
      */
@@ -101,7 +107,7 @@ 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, place_macros, 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();
diff --git a/vpr/src/place/place.h b/vpr/src/place/place.h
@@ -4,10 +4,8 @@
 #include "vpr_types.h"
 
 class FlatPlacementInfo;
-class PlaceMacros;
 
 void try_place(const Netlist<>& net_list,
-               const PlaceMacros& place_macros,
                const t_placer_opts& placer_opts,
                const t_router_opts& router_opts,
                const t_analysis_opts& analysis_opts,
diff --git a/vpr/src/place/placement_log_printer.cpp b/vpr/src/place/placement_log_printer.cpp
@@ -197,7 +197,7 @@ void PlacementLogPrinter::print_initial_placement_stats() const {
     }
 
     const BlkLocRegistry& blk_loc_registry = placer_.placer_state_.blk_loc_registry();
-    const PlaceMacros& place_macros = placer_.place_macros_;
+    const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
     size_t num_macro_members = 0;
     for (const t_pl_macro& macro : place_macros.macros()) {
         num_macro_members += macro.members.size();
diff --git a/vpr/src/place/placer.cpp b/vpr/src/place/placer.cpp
diff --git a/vpr/src/place/placer.h b/vpr/src/place/placer.h
diff --git a/vpr/src/place/verify_placement.cpp b/vpr/src/place/verify_placement.cpp

Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ void PlacementLogPrinter::print_initial_placement_stats() const {`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`const BlkLocRegistry& blk_loc_registry = placer_.placer_state_.blk_loc_registry();`
`200`		`- const PlaceMacros& place_macros = placer_.place_macros_;`
	`200`	`+ const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;`
`201`	`201`	`size_t num_macro_members = 0;`
`202`	`202`	`for (const t_pl_macro& macro : place_macros.macros()) {`
`203`	`203`	`num_macro_members += macro.members.size();`