[Place] Moved PlaceMacros Out of BlkLocRegistry

The PlaceMacros only require the Clustering and atom/arch info to be
constructed; after which they are never modified. Since they are
unchanged by the placement, they were out of place in the
BlkLocRegistry.

Moved them to the clustering context since they only make sense once the
clusters are loaded.

This will make it easier to separate out the initial placement from the
SA placer.

Author: AlexandreSinger

vpr/src/analytical_place/full_legalizer.cpp

@@ -101,14 +101,13 @@ class APClusterPlacer {
 private:
     // Get the macro for the given cluster block.
     t_pl_macro get_macro(ClusterBlockId clb_blk_id) {
-        const auto& place_macros = g_vpr_ctx.placement().blk_loc_registry().place_macros();
         // Basically stolen from initial_placement.cpp:place_one_block
         // TODO: Make this a cleaner interface and share the code.
-        int imacro = place_macros.get_imacro_from_iblk(clb_blk_id);
+        int imacro = place_macros_.get_imacro_from_iblk(clb_blk_id);
 
         // If this block is part of a macro, return it.
         if (imacro != -1) {
-            return place_macros[imacro];
+            return place_macros_[imacro];
         }
         // If not, create a "fake" macro with a single element.
         t_pl_macro_member macro_member;
@@ -121,20 +120,22 @@ class APClusterPlacer {
         return pl_macro;
     }
 
+    const PlaceMacros& place_macros_;
+
 public:
     /**
      * @brief Constructor for the APClusterPlacer
      *
      * Initializes internal and global state necessary to place clusters on the
      * FPGA device.
      */
-    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.
         auto& blk_loc_registry = g_vpr_ctx.mutable_placement().mutable_blk_loc_registry();
-        const auto& directs = g_vpr_ctx.device().arch->directs;
 
-        init_placement_context(blk_loc_registry, directs);
+        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.
@@ -149,7 +150,7 @@ class APClusterPlacer {
         blk_loc_registry.clear_all_grid_locs();
 
         // Deal with the placement constraints.
-        propagate_place_constraints(blk_loc_registry.place_macros());
+        propagate_place_constraints(place_macros_);
 
         mark_fixed_blocks(blk_loc_registry);
 
@@ -384,6 +385,7 @@ void NaiveFullLegalizer::create_clusters(const PartialPlacement& p_placement) {
 }
 
 void NaiveFullLegalizer::place_clusters(const ClusteredNetlist& clb_nlist,
+                                        const PlaceMacros& place_macros,
                                         const PartialPlacement& p_placement) {
     // PLACING:
     // Create a lookup from the AtomBlockId to the APBlockId
@@ -405,7 +407,7 @@ void NaiveFullLegalizer::place_clusters(const ClusteredNetlist& clb_nlist,
     // Move the clusters to where they want to be first.
     // TODO: The fixed clusters should probably be moved first for legality
     //       reasons.
-    APClusterPlacer ap_cluster_placer;
+    APClusterPlacer ap_cluster_placer(place_macros);
     std::vector<ClusterBlockId> unplaced_clusters;
     for (ClusterBlockId cluster_blk_id : clb_nlist.blocks()) {
         // Assume that the cluster will always want to be placed wherever the
@@ -465,9 +467,10 @@ 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;
 
     // Place the clusters based on where the atoms want to be placed.
-    place_clusters(clb_nlist, p_placement);
+    place_clusters(clb_nlist, place_macros, p_placement);
 
     // Verify that the placement created by the full legalizer is valid.
     unsigned num_placement_errors = verify_placement(g_vpr_ctx);
@@ -530,7 +533,9 @@ 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,

vpr/src/analytical_place/full_legalizer.h

@@ -19,6 +19,7 @@ class AtomNetlist;
 class ClusteredNetlist;
 class DeviceGrid;
 class PartialPlacement;
+class PlaceMacros;
 class Prepacker;
 struct t_arch;
 struct t_logical_block_type;
@@ -125,6 +126,7 @@ class NaiveFullLegalizer : public FullLegalizer {
      *        placement.
      */
     void place_clusters(const ClusteredNetlist& clb_nlist,
+                        const PlaceMacros& place_macros,
                         const PartialPlacement& p_placement);
 
 };

vpr/src/base/blk_loc_registry.cpp

@@ -45,14 +45,6 @@ int BlkLocRegistry::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net
     return this->tile_pin_index(pin_id);
 }
 
-const PlaceMacros& BlkLocRegistry::place_macros() const {
-    return place_macros_;
-}
-
-PlaceMacros& BlkLocRegistry::mutable_place_macros() {
-    return  place_macros_;
-}
-
 void BlkLocRegistry::set_block_location(ClusterBlockId blk_id, const t_pl_loc& location) {
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -289,3 +281,4 @@ t_physical_tile_loc BlkLocRegistry::get_coordinate_of_pin(ClusterPinId pin) cons
 
     return tile_loc;
 }
+

vpr/src/base/blk_loc_registry.h

@@ -5,7 +5,6 @@
 #include "vtr_vector_map.h"
 #include "vpr_types.h"
 #include "grid_block.h"
-#include "place_macro.h"
 
 struct t_block_loc;
 struct t_pl_blocks_to_be_moved;
@@ -37,13 +36,6 @@ class BlkLocRegistry {
     ///@brief Clustered pin placement mapping with physical pin
     vtr::vector_map<ClusterPinId, int> physical_pins_;
 
-    /**
-     * @brief Contains information about placement macros.
-     * 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.
-     */
-    PlaceMacros place_macros_;
-
     /// @brief Stores ClusterBlockId of all movable clustered blocks
     /// (blocks that are not locked down to a single location)
     std::vector<ClusterBlockId> movable_blocks_;
@@ -67,12 +59,6 @@ class BlkLocRegistry {
     ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
     int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
 
-    ///@brief Returns a constant reference to placement macros.
-    const PlaceMacros& place_macros() const;
-
-    ///@brief Returns a mutable reference to placement macros.
-    PlaceMacros& mutable_place_macros();
-
     /// @brief Returns a constant reference to the vector of ClusterBlockIds of all movable clustered blocks.
     const std::vector<ClusterBlockId>& movable_blocks() const { return movable_blocks_; }
 
@@ -170,3 +156,4 @@ class BlkLocRegistry {
 
     e_expected_transaction expected_transaction_;
 };
+

vpr/src/base/place_and_route.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 
 #include "FlatPlacementInfo.h"
+#include "place_macro.h"
 #include "vtr_assert.h"
 #include "vtr_log.h"
 
@@ -45,6 +46,7 @@ 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,
@@ -166,6 +168,7 @@ 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,
@@ -310,7 +313,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, placer_opts, router_opts, analysis_opts, noc_opts,
+                try_place(placement_net_list, place_macros, placer_opts, router_opts, analysis_opts, noc_opts,
                           arch->Chans, det_routing_arch, segment_inf,
                           arch->directs,
                           FlatPlacementInfo(),  // Pass empty flat placement info.

vpr/src/base/place_and_route.h

@@ -11,6 +11,8 @@
 #include "RoutingDelayCalculator.h"
 #include "rr_graph.h"
 
+class PlaceMacros;
+
 struct t_fmap_cell {
     int fs;         ///<at this fs
     int fc;         ///<at this fc
@@ -27,6 +29,7 @@ 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,

vpr/src/base/vpr_api.cpp

@@ -14,9 +14,11 @@
 #include <cstdio>
 #include <cstring>
 #include <cmath>
+#include <memory>
 
 #include "FlatPlacementInfo.h"
 #include "cluster_util.h"
+#include "place_macro.h"
 #include "verify_placement.h"
 #include "vpr_context.h"
 #include "vtr_assert.h"
@@ -392,7 +394,8 @@ 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;
-        bool place_success = vpr_place_flow(placement_net_list, vpr_setup, arch);
+        const PlaceMacros& place_macros = *g_vpr_ctx.clustering().place_macros;
+        bool place_success = vpr_place_flow(placement_net_list, vpr_setup, arch, place_macros);
 
         if (!place_success) {
             return false; //Unimplementable
@@ -417,9 +420,10 @@ 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, is_flat);
+        route_status = vpr_route_flow(router_net_list, vpr_setup, arch, place_macros, is_flat);
     }
     { //Analysis
         vpr_analysis_flow(router_net_list, vpr_setup, arch, route_status, is_flat);
@@ -705,6 +709,13 @@ 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) {
@@ -741,7 +752,10 @@ bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
     return true;
 }
 
-bool vpr_place_flow(const Netlist<>& net_list, 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) {
     VTR_LOG("\n");
     const auto& placer_opts = vpr_setup.PlacerOpts;
     const auto& filename_opts = vpr_setup.FileNameOpts;
@@ -750,13 +764,13 @@ bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_a
     } else {
         if (placer_opts.doPlacement == STAGE_DO) {
             //Do the actual placement
-            vpr_place(net_list, vpr_setup, arch);
+            vpr_place(net_list, vpr_setup, arch, place_macros);
 
         } else {
             VTR_ASSERT(placer_opts.doPlacement == STAGE_LOAD);
 
             //Load a previous placement
-            vpr_load_placement(vpr_setup, arch);
+            vpr_load_placement(vpr_setup);
         }
 
         post_place_sync();
@@ -781,7 +795,10 @@ bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_a
     return true;
 }
 
-void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch& arch) {
+void vpr_place(const Netlist<>& net_list,
+               t_vpr_setup& vpr_setup,
+               const t_arch& arch,
+               const PlaceMacros& place_macros) {
     bool is_flat = false;
     if (vpr_setup.PlacerOpts.place_algorithm.is_timing_driven()) {
         // Prime lookahead cache to avoid adding lookahead computation cost to
@@ -806,6 +823,7 @@ void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch&
     }
 
     try_place(net_list,
+              place_macros,
               vpr_setup.PlacerOpts,
               vpr_setup.RouterOpts,
               vpr_setup.AnalysisOpts,
@@ -828,7 +846,7 @@ void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch&
                                block_locs);
 }
 
-void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
+void vpr_load_placement(t_vpr_setup& vpr_setup) {
     vtr::ScopedStartFinishTimer timer("Load Placement");
 
     const auto& device_ctx = g_vpr_ctx.device();
@@ -837,7 +855,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
     const auto& filename_opts = vpr_setup.FileNameOpts;
 
     //Initialize placement data structures, which will be filled when loading placement
-    init_placement_context(blk_loc_registry, arch.directs);
+    init_placement_context(blk_loc_registry);
 
     //Load an existing placement from a file
     place_ctx.placement_id = read_place(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(),
@@ -860,6 +878,7 @@ void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
 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");
 
@@ -906,7 +925,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, is_flat);
+                route_status = vpr_route_min_W(net_list, vpr_setup, arch, timing_info, routing_delay_calc, net_delay, place_macros, 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);
@@ -1036,6 +1055,7 @@ 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
@@ -1052,6 +1072,7 @@ 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,