added const BlkLocRegistry& member variable to VprTimingGraphResolver

soheilshahrouz · soheilshahrouz · commit 6db42e99047a · 2024-08-04T21:22:54.000-04:00
diff --git a/vpr/src/analysis/timing_reports.cpp b/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);
diff --git a/vpr/src/analysis/timing_reports.h b/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
diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp
@@ -1477,6 +1477,7 @@ void vpr_analysis(const Netlist<>& net_list,
                   bool is_flat) {
     auto& route_ctx = g_vpr_ctx.routing();
     auto& atom_ctx = g_vpr_ctx.atom();
+    const auto& blk_loc_registry = g_vpr_ctx.placement().blk_loc_registry();
 
     if (route_ctx.route_trees.empty()) {
         VPR_FATAL_ERROR(VPR_ERROR_ANALYSIS, "No routing loaded -- can not perform post-routing analysis");
@@ -1497,8 +1498,7 @@ void vpr_analysis(const Netlist<>& net_list,
         //Load the net delays
 
         NetPinsMatrix<float> net_delay = make_net_pins_matrix<float>(net_list);
-        load_net_delay_from_routing(net_list,
-                                    net_delay);
+        load_net_delay_from_routing(net_list, net_delay);
 
         //Do final timing analysis
         auto analysis_delay_calc = std::make_shared<AnalysisDelayCalculator>(atom_ctx.nlist, atom_ctx.lookup, net_delay, vpr_setup.RouterOpts.flat_routing);
@@ -1513,10 +1513,10 @@ void vpr_analysis(const Netlist<>& net_list,
 
         //Timing stats
         VTR_LOG("\n");
-        generate_hold_timing_stats(/*prefix=*/"", *timing_info,
-                                   *analysis_delay_calc, vpr_setup.AnalysisOpts, vpr_setup.RouterOpts.flat_routing);
-        generate_setup_timing_stats(/*prefix=*/"", *timing_info,
-                                    *analysis_delay_calc, vpr_setup.AnalysisOpts, vpr_setup.RouterOpts.flat_routing);
+        generate_hold_timing_stats(/*prefix=*/"", *timing_info, *analysis_delay_calc,
+                                   vpr_setup.AnalysisOpts, vpr_setup.RouterOpts.flat_routing, blk_loc_registry);
+        generate_setup_timing_stats(/*prefix=*/"", *timing_info, *analysis_delay_calc,
+                                    vpr_setup.AnalysisOpts, vpr_setup.RouterOpts.flat_routing, blk_loc_registry);
 
         //Write the post-synthesis netlist
         if (vpr_setup.AnalysisOpts.gen_post_synthesis_netlist) {
diff --git a/vpr/src/place/place.cpp b/vpr/src/place/place.cpp
@@ -317,7 +317,8 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
                                                const t_analysis_opts& analysis_opts,
                                                const SetupTimingInfo& timing_info,
                                                const PlacementDelayCalculator& delay_calc,
-                                               bool is_flat);
+                                               bool is_flat,
+                                               const BlkLocRegistry& blk_loc_registry);
 
 //calculate the agent's reward and the total process outcome
 static void calculate_reward_and_process_outcome(const t_placer_opts& placer_opts,
@@ -437,7 +438,7 @@ void try_place(const Netlist<>& net_list,
 
     PlacerContext placer_ctx;
     auto& place_move_ctx = placer_ctx.mutable_move();
-    auto& place_loc_vars = placer_ctx.mutable_blk_loc_registry();
+    auto& blk_loc_registry = placer_ctx.mutable_blk_loc_registry();
     const auto& p_timing_ctx = placer_ctx.timing();
     const auto& p_runtime_ctx = placer_ctx.runtime();
 
@@ -453,7 +454,7 @@ void try_place(const Netlist<>& net_list,
         normalize_noc_cost_weighting_factor(const_cast<t_noc_opts&>(noc_opts));
     }
 
-    initial_placement(placer_opts, placer_opts.constraints_file.c_str(), noc_opts, place_loc_vars);
+    initial_placement(placer_opts, placer_opts.constraints_file.c_str(), noc_opts, blk_loc_registry);
 
     //create the move generator based on the chosen strategy
     auto [move_generator, move_generator2] = create_move_generators(placer_ctx, placer_opts, move_lim, noc_opts.noc_centroid_weight);
@@ -470,18 +471,18 @@ void try_place(const Netlist<>& net_list,
      *  Most of anneal is disabled later by setting initial temperature to 0 and only further optimizes in quench
      */
     if (placer_opts.enable_analytic_placer) {
-        AnalyticPlacer{place_loc_vars}.ap_place();
+        AnalyticPlacer{blk_loc_registry}.ap_place();
     }
 
 #endif /* ENABLE_ANALYTIC_PLACE */
 
     // Update physical pin values
     for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id, place_loc_vars);
+        place_sync_external_block_connections(block_id, blk_loc_registry);
     }
 
     const int width_fac = placer_opts.place_chan_width;
-    init_draw_coords((float)width_fac, place_loc_vars);
+    init_draw_coords((float)width_fac, blk_loc_registry);
 
     /* Allocated here because it goes into timing critical code where each memory allocation is expensive */
     IntraLbPbPinLookup pb_gpin_lookup(device_ctx.logical_block_types);
@@ -654,7 +655,7 @@ void try_place(const Netlist<>& net_list,
         std::string filename = vtr::string_fmt("placement_%03d_%03d.place", 0,
                                                0);
         VTR_LOG("Saving initial placement to file: %s\n", filename.c_str());
-        print_place(nullptr, nullptr, filename.c_str(), place_loc_vars.block_locs());
+        print_place(nullptr, nullptr, filename.c_str(), blk_loc_registry.block_locs());
     }
 
     int first_move_lim = get_initial_move_lim(placer_opts, annealing_sched);
@@ -759,7 +760,7 @@ void try_place(const Netlist<>& net_list,
 
                 if (placer_opts.place_checkpointing
                     && agent_state == e_agent_state::LATE_IN_THE_ANNEAL) {
-                    save_placement_checkpoint_if_needed(place_loc_vars.block_locs(),
+                    save_placement_checkpoint_if_needed(blk_loc_registry.block_locs(),
                                                         placement_checkpoint,
                                                         timing_info, costs, critical_path.delay());
                 }
@@ -891,7 +892,7 @@ void try_place(const Netlist<>& net_list,
         std::string filename = vtr::string_fmt("placement_%03d_%03d.place",
                                                state.num_temps + 1, 0);
         VTR_LOG("Saving final placement to file: %s\n", filename.c_str());
-        print_place(nullptr, nullptr, filename.c_str(), place_loc_vars.block_locs());
+        print_place(nullptr, nullptr, filename.c_str(), blk_loc_registry.block_locs());
     }
 
     // TODO:
@@ -905,7 +906,7 @@ void try_place(const Netlist<>& net_list,
 
     // Update physical pin values
     for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        place_sync_external_block_connections(block_id, place_loc_vars);
+        place_sync_external_block_connections(block_id, blk_loc_registry);
     }
 
     check_place(costs,
@@ -940,8 +941,8 @@ void try_place(const Netlist<>& net_list,
                 *timing_info, debug_tnode);
         }
 
-        generate_post_place_timing_reports(placer_opts, analysis_opts,
-                                           *timing_info, *placement_delay_calc, is_flat);
+        generate_post_place_timing_reports(placer_opts, analysis_opts, *timing_info,
+                                           *placement_delay_calc, is_flat, blk_loc_registry);
 
         /* Print critical path delay metrics */
         VTR_LOG("\n");
@@ -968,14 +969,14 @@ void try_place(const Netlist<>& net_list,
 
     update_screen(ScreenUpdatePriority::MAJOR, msg, PLACEMENT, timing_info);
     // Print out swap statistics
-    print_resources_utilization(place_loc_vars);
+    print_resources_utilization(blk_loc_registry);
 
     print_placement_swaps_stats(state, swap_stats);
 
     print_placement_move_types_stats(move_type_stat);
 
     if (noc_opts.noc) {
-        write_noc_placement_file(noc_opts.noc_placement_file_name, place_loc_vars.block_locs());
+        write_noc_placement_file(noc_opts.noc_placement_file_name, blk_loc_registry.block_locs());
     }
 
     free_placement_structs(placer_opts, noc_opts, placer_ctx);
@@ -992,7 +993,7 @@ void try_place(const Netlist<>& net_list,
             p_runtime_ctx.f_update_td_costs_sum_nets_elapsed_sec,
             p_runtime_ctx.f_update_td_costs_total_elapsed_sec);
 
-    copy_locs_to_global_state(place_loc_vars);
+    copy_locs_to_global_state(blk_loc_registry);
 }
 
 /* Function to update the setup slacks and criticalities before the inner loop of the annealing/quench */
@@ -2051,15 +2052,15 @@ static int check_placement_costs(const t_placer_costs& costs,
     return error;
 }
 
-static int check_placement_consistency(const BlkLocRegistry& place_loc_vars) {
-    return check_block_placement_consistency(place_loc_vars) + check_macro_placement_consistency(place_loc_vars);
+static int check_placement_consistency(const BlkLocRegistry& blk_loc_registry) {
+    return check_block_placement_consistency(blk_loc_registry) + check_macro_placement_consistency(blk_loc_registry);
 }
 
-static int check_block_placement_consistency(const BlkLocRegistry& place_loc_vars) {
+static int check_block_placement_consistency(const BlkLocRegistry& blk_loc_registry) {
     auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.device();
-    const auto& block_locs = place_loc_vars.block_locs();
-    const auto& grid_blocks = place_loc_vars.grid_blocks();
+    const auto& block_locs = blk_loc_registry.block_locs();
+    const auto& grid_blocks = blk_loc_registry.grid_blocks();
 
     int error = 0;
 
@@ -2139,10 +2140,10 @@ static int check_block_placement_consistency(const BlkLocRegistry& place_loc_var
     return error;
 }
 
-int check_macro_placement_consistency(const BlkLocRegistry& place_loc_vars) {
+int check_macro_placement_consistency(const BlkLocRegistry& blk_loc_registry) {
     const auto& pl_macros = g_vpr_ctx.placement().pl_macros;
-    const auto& block_locs = place_loc_vars.block_locs();
-    const auto& grid_blocks = place_loc_vars.grid_blocks();
+    const auto& block_locs = blk_loc_registry.block_locs();
+    const auto& grid_blocks = blk_loc_registry.grid_blocks();
 
     int error = 0;
 
@@ -2204,12 +2205,13 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
                                                const t_analysis_opts& analysis_opts,
                                                const SetupTimingInfo& timing_info,
                                                const PlacementDelayCalculator& delay_calc,
-                                               bool is_flat) {
+                                               bool is_flat,
+                                               const BlkLocRegistry& blk_loc_registry) {
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    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,
@@ -2288,10 +2290,10 @@ static void print_place_status(const t_annealing_state& state,
     fflush(stdout);
 }
 
-static void print_resources_utilization(const BlkLocRegistry& place_loc_vars) {
+static void print_resources_utilization(const BlkLocRegistry& blk_loc_registry) {
     const auto& cluster_ctx = g_vpr_ctx.clustering();
     const auto& device_ctx = g_vpr_ctx.device();
-    const auto& block_locs = place_loc_vars.block_locs();
+    const auto& block_locs = blk_loc_registry.block_locs();
 
     int max_block_name = 0;
     int max_tile_name = 0;
@@ -2429,18 +2431,18 @@ static void calculate_reward_and_process_outcome(const t_placer_opts& placer_opt
     }
 }
 
-static void copy_locs_to_global_state(const BlkLocRegistry& place_loc_vars) {
+static void copy_locs_to_global_state(const BlkLocRegistry& blk_loc_registry) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
     // the placement location variables should be unlocked before being accessed
     place_ctx.unlock_loc_vars();
 
     // copy the local location variables into the global state
-    auto& global_place_loc_vars = place_ctx.mutable_blk_loc_registry();
-    global_place_loc_vars = place_loc_vars;
+    auto& global_blk_loc_registry = place_ctx.mutable_blk_loc_registry();
+    global_blk_loc_registry = blk_loc_registry;
 
 #ifndef NO_GRAPHICS
     // update the graphics' reference to placement location variables
-    set_graphics_blk_loc_registry_ref(global_place_loc_vars);
+    set_graphics_blk_loc_registry_ref(global_blk_loc_registry);
 #endif
 }
diff --git a/vpr/src/route/route_utils.cpp b/vpr/src/route/route_utils.cpp
@@ -18,13 +18,12 @@
 bool check_net_delays(const Netlist<>& net_list, NetPinsMatrix<float>& net_delay) {
     constexpr float ERROR_TOL = 0.0001;
 
-    unsigned int ipin;
     auto net_delay_check = make_net_pins_matrix<float>(net_list);
 
     load_net_delay_from_routing(net_list, net_delay_check);
 
     for (auto net_id : net_list.nets()) {
-        for (ipin = 1; ipin < net_list.net_pins(net_id).size(); ipin++) {
+        for (size_t ipin = 1; ipin < net_list.net_pins(net_id).size(); ipin++) {
             if (net_delay_check[net_id][ipin] == 0.) { /* Should be only GLOBAL nets */
                 if (fabs(net_delay[net_id][ipin]) > ERROR_TOL) {
                     VPR_ERROR(VPR_ERROR_ROUTE,
@@ -220,8 +219,9 @@ void generate_route_timing_reports(const t_router_opts& router_opts,
                                    bool is_flat) {
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
+    const auto& blk_loc_registry = g_vpr_ctx.placement().blk_loc_registry();
 
-    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);
diff --git a/vpr/src/server/pathhelper.cpp b/vpr/src/server/pathhelper.cpp
@@ -39,13 +39,13 @@ CritPathsResultPtr calc_critical_path(const std::string& report_type, int crit_p
 
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
-    //
+    const auto& blk_loc_registry = g_vpr_ctx.placement().blk_loc_registry();
 
     t_analysis_opts analysis_opts;
     analysis_opts.timing_report_detail = details_level;
     analysis_opts.timing_report_npaths = crit_path_num;
 
-    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, *routing_delay_calc, is_flat_routing);
+    VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, *routing_delay_calc, is_flat_routing, blk_loc_registry);
     resolver.set_detail_level(analysis_opts.timing_report_detail);
 
     tatum::TimingReporter timing_reporter(resolver, *timing_ctx.graph, *timing_ctx.constraints);
diff --git a/vpr/src/timing/VprTimingGraphResolver.cpp b/vpr/src/timing/VprTimingGraphResolver.cpp
@@ -6,12 +6,14 @@ VprTimingGraphResolver::VprTimingGraphResolver(const AtomNetlist& netlist,
                                                const AtomLookup& netlist_lookup,
                                                const tatum::TimingGraph& timing_graph,
                                                const AnalysisDelayCalculator& delay_calc,
-                                               bool is_flat)
+                                               bool is_flat,
+                                               const BlkLocRegistry& blk_loc_registry)
     : netlist_(netlist)
     , netlist_lookup_(netlist_lookup)
     , timing_graph_(timing_graph)
     , delay_calc_(delay_calc)
-    , is_flat_(is_flat) {}
+    , is_flat_(is_flat)
+    , blk_loc_registry_(blk_loc_registry) {}
 
 std::string VprTimingGraphResolver::node_name(tatum::NodeId node) const {
     AtomPinId pin = netlist_lookup_.tnode_atom_pin(node);
@@ -31,7 +33,7 @@ std::string VprTimingGraphResolver::node_type_name(tatum::NodeId node) const {
         //Detailed report consist of the aggregated reported with a breakdown of inter-block routing
         //Annotate primitive grid location, if known
         auto& atom_ctx = g_vpr_ctx.atom();
-        auto& block_locs = g_vpr_ctx.placement().block_locs();
+        auto& block_locs = blk_loc_registry_.block_locs();
         ClusterBlockId cb = atom_ctx.lookup.atom_clb(blk);
         if (cb && block_locs.count(cb)) {
             int x = block_locs[cb].loc.x;
diff --git a/vpr/src/timing/VprTimingGraphResolver.h b/vpr/src/timing/VprTimingGraphResolver.h
