Remove accesses to global placement state during placement stage

libs/EXTERNAL/libtatum/libtatum/tatum/TimingReporter.cpp

@@ -606,7 +606,7 @@ Time TimingReporter::report_timing_data_arrival_subpath(std::ostream& os,
 
     {
         //Input constraint
-        TATUM_ASSERT(subpath.elements().size() > 0);
+        TATUM_ASSERT(!subpath.elements().empty());
         const TimingPathElem& path_elem = *(subpath.elements().begin());
 
         Time input_constraint;
@@ -712,7 +712,7 @@ bool TimingReporter::nearly_equal(const Time& lhs, const Time& rhs) const {
 
 size_t TimingReporter::estimate_point_print_width(const TimingPath& path) const {
     size_t width = 60; //default
-    for(auto subpath : {path.clock_launch_path(), path.data_arrival_path(), path.clock_capture_path()}) {
+    for(const auto& subpath : {path.clock_launch_path(), path.data_arrival_path(), path.clock_capture_path()}) {
         for(auto elem : subpath.elements()) {
             //Take the longest typical point name
             std::string point = name_resolver_.node_name(elem.node()) + " (" + name_resolver_.node_type_name(elem.node()) + ")";

utils/fasm/src/fasm.cpp

@@ -37,9 +37,9 @@ void FasmWriterVisitor::visit_top_impl(const char* top_level_name) {
 }
 
 void FasmWriterVisitor::visit_clb_impl(ClusterBlockId blk_id, const t_pb* clb) {
-    auto& place_ctx = g_vpr_ctx.placement();
     auto& device_ctx = g_vpr_ctx.device();
     auto& cluster_ctx = g_vpr_ctx.clustering();
+    auto& block_locs = g_vpr_ctx.placement().block_locs();
 
     current_blk_id_ = blk_id;
 
@@ -48,10 +48,10 @@ void FasmWriterVisitor::visit_clb_impl(ClusterBlockId blk_id, const t_pb* clb) {
 
     root_clb_ = clb->pb_graph_node;
 
-    int x = place_ctx.block_locs[blk_id].loc.x;
-    int y = place_ctx.block_locs[blk_id].loc.y;
-    int layer_num = place_ctx.block_locs[blk_id].loc.layer;
-    int sub_tile = place_ctx.block_locs[blk_id].loc.sub_tile;
+    int x = block_locs[blk_id].loc.x;
+    int y = block_locs[blk_id].loc.y;
+    int layer_num = block_locs[blk_id].loc.layer;
+    int sub_tile = block_locs[blk_id].loc.sub_tile;
     physical_tile_ = device_ctx.grid.get_physical_type({x, y, layer_num});
     logical_block_ = cluster_ctx.clb_nlist.block_type(blk_id);
     const auto& grid_meta = device_ctx.grid.get_metadata({x, y, layer_num});

utils/fasm/test/test_fasm.cpp

@@ -569,7 +569,7 @@ TEST_CASE("fasm_integration_test", "[fasm]") {
 
     // Verify occupied grid LOCs
     const auto & place_ctx = g_vpr_ctx.placement();
-    for (const auto& loc: place_ctx.block_locs) {
+    for (const auto& loc: place_ctx.block_locs()) {
 
         // Do not consider "IOB" tiles. They do not have fasm features
         // defined in the arch.

vpr/src/analysis/timing_reports.cpp

@@ -12,13 +12,18 @@
 
 #include "VprTimingGraphResolver.h"
 
-void generate_setup_timing_stats(const std::string& prefix, const SetupTimingInfo& timing_info, const AnalysisDelayCalculator& delay_calc, const t_analysis_opts& analysis_opts, bool is_flat) {
+void generate_setup_timing_stats(const std::string& prefix,
+                                 const SetupTimingInfo& timing_info,
+                                 const AnalysisDelayCalculator& delay_calc,
+                                 const t_analysis_opts& analysis_opts,
+                                 bool is_flat,
+                                 const BlkLocRegistry& blk_loc_registry) {
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
 
     print_setup_timing_summary(*timing_ctx.constraints, *timing_info.setup_analyzer(), "Final ", analysis_opts.write_timing_summary);
 
-    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat);
+    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
     resolver.set_detail_level(analysis_opts.timing_report_detail);
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);
@@ -32,13 +37,18 @@ void generate_setup_timing_stats(const std::string& prefix, const SetupTimingInf
     timing_reporter.report_unconstrained_setup(prefix + "report_unconstrained_timing.setup.rpt", *timing_info.setup_analyzer());
 }
 
-void generate_hold_timing_stats(const std::string& prefix, const HoldTimingInfo& timing_info, const AnalysisDelayCalculator& delay_calc, const t_analysis_opts& analysis_opts, bool is_flat) {
+void generate_hold_timing_stats(const std::string& prefix,
+                                const HoldTimingInfo& timing_info,
+                                const AnalysisDelayCalculator& delay_calc,
+                                const t_analysis_opts& analysis_opts,
+                                bool is_flat,
+                                const BlkLocRegistry& blk_loc_registry) {
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
 
     print_hold_timing_summary(*timing_ctx.constraints, *timing_info.hold_analyzer(), "Final ");
 
-    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat);
+    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc, is_flat, blk_loc_registry);
     resolver.set_detail_level(analysis_opts.timing_report_detail);
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);

vpr/src/analysis/timing_reports.h

@@ -5,7 +5,20 @@
 #include "AnalysisDelayCalculator.h"
 #include "vpr_types.h"
 
-void generate_setup_timing_stats(const std::string& prefix, const SetupTimingInfo& timing_info, const AnalysisDelayCalculator& delay_calc, const t_analysis_opts& report_detail, bool is_flat);
-void generate_hold_timing_stats(const std::string& prefix, const HoldTimingInfo& timing_info, const AnalysisDelayCalculator& delay_calc, const t_analysis_opts& report_detail, bool is_flat);
+class BlkLocRegistry;
+
+void generate_setup_timing_stats(const std::string& prefix,
+                                 const SetupTimingInfo& timing_info,
+                                 const AnalysisDelayCalculator& delay_calc,
+                                 const t_analysis_opts& report_detail,
+                                 bool is_flat,
+                                 const BlkLocRegistry& blk_loc_registry);
+
+void generate_hold_timing_stats(const std::string& prefix,
+                                const HoldTimingInfo& timing_info,
+                                const AnalysisDelayCalculator& delay_calc,
+                                const t_analysis_opts& report_detail,
+                                bool is_flat,
+                                const BlkLocRegistry& blk_loc_registry);
 
 #endif

vpr/src/base/ShowSetup.cpp

@@ -527,10 +527,10 @@ static void ShowPlacerOpts(const t_placer_opts& PlacerOpts,
 
         VTR_LOG("PlacerOpts.pad_loc_type: ");
         switch (PlacerOpts.pad_loc_type) {
-            case FREE:
+            case e_pad_loc_type::FREE:
                 VTR_LOG("FREE\n");
                 break;
-            case RANDOM:
+            case e_pad_loc_type::RANDOM:
                 VTR_LOG("RANDOM\n");
                 break;
             default:

vpr/src/base/load_flat_place.cpp

@@ -9,12 +9,13 @@ static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
 
 static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
                                std::vector<AtomBlockId>& atoms) {
+    const auto& atom_ctx = g_vpr_ctx.atom();
+    const auto& block_locs = g_vpr_ctx.placement().block_locs();
 
-    auto& atom_ctx = g_vpr_ctx.atom();
-    t_pl_loc loc = g_vpr_ctx.placement().block_locs[iblk].loc;
+    t_pl_loc loc = block_locs[iblk].loc;
     size_t bnum = size_t(iblk);
 
-    for (auto atom : atoms) {
+    for (AtomBlockId atom : atoms) {
         t_pb_graph_node* atom_pbgn = atom_ctx.lookup.atom_pb(atom)->pb_graph_node;
         fprintf(fp, "%s  %d %d %d %d #%zu %s\n", atom_ctx.nlist.block_name(atom).c_str(),
                                                 loc.x, loc.y, loc.sub_tile,
@@ -26,15 +27,16 @@ static void print_flat_cluster(FILE* fp, ClusterBlockId iblk,
 
 /* prints a flat placement file */
 void print_flat_placement(const char* flat_place_file) {
-
+    const auto& block_locs = g_vpr_ctx.placement().block_locs();
+
     FILE* fp;
 
     ClusterAtomsLookup atoms_lookup;
     auto& cluster_ctx = g_vpr_ctx.clustering();
 
-    if (!g_vpr_ctx.placement().block_locs.empty()) {
+    if (!block_locs.empty()) {
         fp = fopen(flat_place_file, "w");
-        for (auto iblk : cluster_ctx.clb_nlist.blocks()) {
+        for (ClusterBlockId iblk : cluster_ctx.clb_nlist.blocks()) {
             auto atoms = atoms_lookup.atoms_in_cluster(iblk);
             print_flat_cluster(fp, iblk, atoms);
         }

vpr/src/base/place_and_route.cpp

@@ -348,7 +348,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                             ScreenUpdatePriority::MINOR,
                             is_flat);
 
-            if (success && Fc_clipped == false) {
+            if (success && !Fc_clipped) {
                 final = current;
                 save_routing(best_routing,
                              route_ctx.clb_opins_used_locally,
@@ -357,8 +357,9 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                 if (placer_opts.place_freq == PLACE_ALWAYS) {
                     auto& cluster_ctx = g_vpr_ctx.clustering();
                     // Cluster-based net_list is used for placement
-                    print_place(filename_opts.NetFile.c_str(), cluster_ctx.clb_nlist.netlist_id().c_str(),
-                                filename_opts.PlaceFile.c_str());
+                    std::string placement_id = print_place(filename_opts.NetFile.c_str(), cluster_ctx.clb_nlist.netlist_id().c_str(),
+                                                           filename_opts.PlaceFile.c_str(), g_vpr_ctx.placement().block_locs());
+                    g_vpr_ctx.mutable_placement().placement_id = placement_id;
                 }
             }
 
@@ -389,7 +390,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
                     &warnings,
                     is_flat);
 
-    init_draw_coords(final);
+    init_draw_coords(final, g_vpr_ctx.placement().blk_loc_registry());
 
     /* Allocate and load additional rr_graph information needed only by the router. */
     alloc_and_load_rr_node_route_structs();
@@ -556,26 +557,28 @@ static float comp_width(t_chan* chan, float x, float separation) {
             break;
     }
 
-    return (val);
+    return val;
 }
 
 /**
  * @brief After placement, logical pins for blocks, and nets must be updated to correspond with physical pins of type.
  *
- * This is required by blocks with capacity > 1 (e.g. typically IOs with multiple instaces in each placement
- * gride location). Since they may be swapped around during placement, we need to update which pins the various
+ * This is required by blocks with capacity > 1 (e.g. typically IOs with multiple instances in each placement
+ * grid location). Since they may be swapped around during placement, we need to update which pins the various
  * nets use.
  *
- * This updates both the external inter-block net connecitivity (i.e. the clustered netlist), and the intra-block
+ * This updates both the external inter-block net connectivity (i.e. the clustered netlist), and the intra-block
  * connectivity (since the internal pins used also change).
  *
  * This function should only be called once
  */
 void post_place_sync() {
     /* Go through each block */
-    auto& cluster_ctx = g_vpr_ctx.clustering();
+    const auto& cluster_ctx = g_vpr_ctx.clustering();
+    auto& blk_loc_registry = g_vpr_ctx.mutable_placement().mutable_blk_loc_registry();
+
     // Cluster-based netlist is used for placement
-    for (auto block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id);
+    for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
+        place_sync_external_block_connections(block_id, blk_loc_registry);
     }
 }

vpr/src/base/read_options.cpp

@@ -532,9 +532,9 @@ struct ParseFixPins {
     ConvertedValue<e_pad_loc_type> from_str(const std::string& str) {
         ConvertedValue<e_pad_loc_type> conv_value;
         if (str == "free")
-            conv_value.set_value(FREE);
+            conv_value.set_value(e_pad_loc_type::FREE);
         else if (str == "random")
-            conv_value.set_value(RANDOM);
+            conv_value.set_value(e_pad_loc_type::RANDOM);
         else {
             std::stringstream msg;
             msg << "Invalid conversion from '" << str << "' to e_router_algorithm (expected one of: " << argparse::join(default_choices(), ", ") << ")";
@@ -545,10 +545,10 @@ struct ParseFixPins {
 
     ConvertedValue<std::string> to_str(e_pad_loc_type val) {
         ConvertedValue<std::string> conv_value;
-        if (val == FREE)
+        if (val == e_pad_loc_type::FREE)
             conv_value.set_value("free");
         else {
-            VTR_ASSERT(val == RANDOM);
+            VTR_ASSERT(val == e_pad_loc_type::RANDOM);
             conv_value.set_value("random");
         }
         return conv_value;