added place() method to Placer class

Author: soheilshahrouz

vpr/src/place/place.cpp

@@ -80,22 +80,6 @@ static void generate_post_place_timing_reports(const t_placer_opts& placer_opts,
                                                bool is_flat,
                                                const BlkLocRegistry& blk_loc_registry);
 
-static void print_place_status_header(bool noc_enabled);
-
-static void print_place_status(const t_annealing_state& state,
-                               const t_placer_statistics& stats,
-                               float elapsed_sec,
-                               float cpd,
-                               float sTNS,
-                               float sWNS,
-                               size_t tot_moves,
-                               bool noc_enabled,
-                               const NocCostTerms& noc_cost_terms);
-
-static void print_resources_utilization(const BlkLocRegistry& blk_loc_registry);
-
-static void print_placement_swaps_stats(const t_annealing_state& state, const t_swap_stats& swap_stats);
-
 /**
  * @brief Copies the placement location variables into the global placement context.
  * @param blk_loc_registry The placement location variables to be copied.
@@ -129,10 +113,6 @@ void try_place(const Netlist<>& net_list,
     const auto& timing_ctx = g_vpr_ctx.timing();
     auto pre_place_timing_stats = timing_ctx.stats;
 
-
-    float sTNS = NAN;
-    float sWNS = NAN;
-
     char msg[vtr::bufsize];
 
     /* Placement delay model is independent of the placement and can be shared across
@@ -192,141 +172,6 @@ void try_place(const Netlist<>& net_list,
         print_place(nullptr, nullptr, filename.c_str(), blk_loc_registry.block_locs());
     }
 
-    bool skip_anneal = false;
-
-#ifdef ENABLE_ANALYTIC_PLACE
-    // Analytic placer: When enabled, skip most of the annealing and go straight to quench
-    // TODO: refactor goto label.
-    if (placer_opts.enable_analytic_placer) {
-        skip_anneal = true;
-    }
-#endif /* ENABLE_ANALYTIC_PLACE */
-
-    PlacementAnnealer annealer(placer_opts, placer_state, costs, net_cost_handler, noc_cost_handler,
-                               noc_opts, rng, std::move(move_generator), std::move(move_generator2), place_delay_model.get(),
-                               placer_criticalities.get(), placer_setup_slacks.get(), timing_info.get(), pin_timing_invalidator.get(), move_lim);
-
-    const t_annealing_state& annealing_state = annealer.get_annealing_state();
-    const auto& [swap_stats, move_type_stats, placer_stats] = annealer.get_stats();
-
-    if (!skip_anneal) {
-        //Table header
-        VTR_LOG("\n");
-        print_place_status_header(noc_opts.noc);
-
-        /* Outer loop of the simulated annealing begins */
-        do {
-            vtr::Timer temperature_timer;
-
-            annealer.outer_loop_update_timing_info();
-
-            if (placer_opts.place_algorithm.is_timing_driven()) {
-                critical_path = timing_info->least_slack_critical_path();
-                sTNS = timing_info->setup_total_negative_slack();
-                sWNS = timing_info->setup_worst_negative_slack();
-
-                // see if we should save the current placement solution as a checkpoint
-                if (placer_opts.place_checkpointing && annealer.get_agent_state() == e_agent_state::LATE_IN_THE_ANNEAL) {
-                    save_placement_checkpoint_if_needed(blk_loc_registry.block_locs(),
-                                                        placement_checkpoint,
-                                                        timing_info, costs, critical_path.delay());
-                }
-            }
-
-            // do a complete inner loop iteration
-            annealer.placement_inner_loop();
-
-            print_place_status(annealing_state, placer_stats, temperature_timer.elapsed_sec(),
-                               critical_path.delay(), sTNS, sWNS, annealer.get_total_iteration(),
-                               noc_opts.noc, costs.noc_cost_terms);
-
-            sprintf(msg, "Cost: %g  BB Cost %g  TD Cost %g  Temperature: %g",
-                    costs.cost, costs.bb_cost, costs.timing_cost, annealing_state.t);
-            update_screen(ScreenUpdatePriority::MINOR, msg, PLACEMENT, timing_info);
-
-            //#ifdef VERBOSE
-            //            if (getEchoEnabled()) {
-            //                print_clb_placement("first_iteration_clb_placement.echo");
-            //            }
-            //#endif
-        } while (annealer.outer_loop_update_state());
-        /* Outer loop of the simulated annealing ends */
-    } //skip_anneal ends
-
-    // Start Quench
-    annealer.start_quench();
-
-    auto pre_quench_timing_stats = timing_ctx.stats;
-    { /* Quench */
-
-        vtr::ScopedFinishTimer temperature_timer("Placement Quench");
-
-        annealer.outer_loop_update_timing_info();
-
-        /* Run inner loop again with temperature = 0 so as to accept only swaps
-         * which reduce the cost of the placement */
-        annealer.placement_inner_loop();
-
-        if (placer_opts.place_quench_algorithm.is_timing_driven()) {
-            critical_path = timing_info->least_slack_critical_path();
-            sTNS = timing_info->setup_total_negative_slack();
-            sWNS = timing_info->setup_worst_negative_slack();
-        }
-
-        print_place_status(annealing_state, placer_stats, temperature_timer.elapsed_sec(),
-                           critical_path.delay(), sTNS, sWNS, annealer.get_total_iteration(),
-                           noc_opts.noc, costs.noc_cost_terms);
-    }
-    auto post_quench_timing_stats = timing_ctx.stats;
-
-    //Final timing analysis
-    PlaceCritParams crit_params;
-    crit_params.crit_exponent = annealing_state.crit_exponent;
-    crit_params.crit_limit = placer_opts.place_crit_limit;
-
-    if (placer_opts.place_algorithm.is_timing_driven()) {
-        perform_full_timing_update(crit_params, place_delay_model.get(), placer_criticalities.get(),
-                                   placer_setup_slacks.get(), pin_timing_invalidator.get(),
-                                   timing_info.get(), &costs, placer_state);
-        VTR_LOG("post-quench CPD = %g (ns) \n",
-                1e9 * timing_info->least_slack_critical_path().delay());
-    }
-
-    //See if our latest checkpoint is better than the current placement solution
-    if (placer_opts.place_checkpointing)
-        restore_best_placement(placer_state,
-                               placement_checkpoint, timing_info, costs,
-                               placer_criticalities, placer_setup_slacks, place_delay_model,
-                               pin_timing_invalidator, crit_params, noc_cost_handler);
-
-    if (placer_opts.placement_saves_per_temperature >= 1) {
-        std::string filename = vtr::string_fmt("placement_%03d_%03d.place",
-                                               annealing_state.num_temps + 1, 0);
-        VTR_LOG("Saving final placement to file: %s\n", filename.c_str());
-        print_place(nullptr, nullptr, filename.c_str(), blk_loc_registry.block_locs());
-    }
-
-
-    //#ifdef VERBOSE
-    //    if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_END_CLB_PLACEMENT)) {
-    //        print_clb_placement(getEchoFileName(E_ECHO_END_CLB_PLACEMENT));
-    //    }
-    //#endif
-
-    // Update physical pin values
-    for (const ClusterBlockId block_id : cluster_ctx.clb_nlist.blocks()) {
-        blk_loc_registry.place_sync_external_block_connections(block_id);
-    }
-
-    check_place(costs,
-                place_delay_model.get(),
-                placer_criticalities.get(),
-                placer_opts.place_algorithm,
-                noc_opts,
-                placer_state,
-                net_cost_handler,
-                noc_cost_handler);
-
     //Some stats
     VTR_LOG("\n");
     VTR_LOG("Swaps called: %d\n", swap_stats.num_ts_called);
@@ -339,23 +184,19 @@ void try_place(const Netlist<>& net_list,
         critical_path = timing_info->least_slack_critical_path();
 
         if (isEchoFileEnabled(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH)) {
-            tatum::write_echo(
-                getEchoFileName(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH),
-                *timing_ctx.graph, *timing_ctx.constraints,
-                *placement_delay_calc, timing_info->analyzer());
-
-            tatum::NodeId debug_tnode = id_or_pin_name_to_tnode(
-                analysis_opts.echo_dot_timing_graph_node);
-            write_setup_timing_graph_dot(
-                getEchoFileName(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH)
-                    + std::string(".dot"),
-                *timing_info, debug_tnode);
+            tatum::write_echo(getEchoFileName(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH),
+                              *timing_ctx.graph, *timing_ctx.constraints,
+                              *placement_delay_calc, timing_info->analyzer());
+
+            tatum::NodeId debug_tnode = id_or_pin_name_to_tnode(analysis_opts.echo_dot_timing_graph_node);
+            write_setup_timing_graph_dot(getEchoFileName(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH) + std::string(".dot"),
+                                         *timing_info, debug_tnode);
         }
 
         generate_post_place_timing_reports(placer_opts, analysis_opts, *timing_info,
                                            *placement_delay_calc, is_flat, blk_loc_registry);
 
-        /* Print critical path delay metrics */
+        // Print critical path delay metrics
         VTR_LOG("\n");
         print_setup_timing_summary(*timing_ctx.constraints,
                                    *timing_info->setup_analyzer(), "Placement estimated ", "");
@@ -380,28 +221,9 @@ void try_place(const Netlist<>& net_list,
     }
 
     update_screen(ScreenUpdatePriority::MAJOR, msg, PLACEMENT, timing_info);
-    // Print out swap statistics
-    print_resources_utilization(blk_loc_registry);
-
-    print_placement_swaps_stats(annealing_state, swap_stats);
-
-    move_type_stats.print_placement_move_types_stats();
-
-    if (noc_opts.noc) {
-        write_noc_placement_file(noc_opts.noc_placement_file_name, blk_loc_registry.block_locs());
-    }
 
     free_placement_structs();
 
-    print_timing_stats("Placement Quench", post_quench_timing_stats, pre_quench_timing_stats);
-    print_timing_stats("Placement Total ", timing_ctx.stats, pre_place_timing_stats);
-
-    VTR_LOG("update_td_costs: connections %g nets %g sum_nets %g total %g\n",
-            p_runtime_ctx.f_update_td_costs_connections_elapsed_sec,
-            p_runtime_ctx.f_update_td_costs_nets_elapsed_sec,
-            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(blk_loc_registry);
 }
 
@@ -505,119 +327,6 @@ static void update_screen_debug() {
 }
 #endif
 
-static void print_place_status_header(bool noc_enabled) {
-    if (!noc_enabled) {
-        VTR_LOG(
-            "---- ------ ------- ------- ---------- ---------- ------- ---------- -------- ------- ------- ------ -------- --------- ------\n");
-        VTR_LOG(
-            "Tnum   Time       T Av Cost Av BB Cost Av TD Cost     CPD       sTNS     sWNS Ac Rate Std Dev  R lim Crit Exp Tot Moves  Alpha\n");
-        VTR_LOG(
-            "      (sec)                                          (ns)       (ns)     (ns)                                                 \n");
-        VTR_LOG(
-            "---- ------ ------- ------- ---------- ---------- ------- ---------- -------- ------- ------- ------ -------- --------- ------\n");
-    } else {
-        VTR_LOG(
-            "---- ------ ------- ------- ---------- ---------- ------- ---------- -------- ------- ------- ------ -------- --------- ------ -------- -------- ---------  ---------\n");
-        VTR_LOG(
-            "Tnum   Time       T Av Cost Av BB Cost Av TD Cost     CPD       sTNS     sWNS Ac Rate Std Dev  R lim Crit Exp Tot Moves  Alpha Agg. BW  Agg. Lat Lat Over. NoC Cong.\n");
-        VTR_LOG(
-            "      (sec)                                          (ns)       (ns)     (ns)                                                   (bps)     (ns)     (ns)             \n");
-        VTR_LOG(
-            "---- ------ ------- ------- ---------- ---------- ------- ---------- -------- ------- ------- ------ -------- --------- ------ -------- -------- --------- ---------\n");
-    }
-}
-
-static void print_place_status(const t_annealing_state& state,
-                               const t_placer_statistics& stats,
-                               float elapsed_sec,
-                               float cpd,
-                               float sTNS,
-                               float sWNS,
-                               size_t tot_moves,
-                               bool noc_enabled,
-                               const NocCostTerms& noc_cost_terms) {
-    VTR_LOG(
-        "%4zu %6.1f %7.1e "
-        "%7.3f %10.2f %-10.5g "
-        "%7.3f % 10.3g % 8.3f "
-        "%7.3f %7.4f %6.1f %8.2f",
-        state.num_temps, elapsed_sec, state.t,
-        stats.av_cost, stats.av_bb_cost, stats.av_timing_cost,
-        1e9 * cpd, 1e9 * sTNS, 1e9 * sWNS,
-        stats.success_rate, stats.std_dev, state.rlim, state.crit_exponent);
-
-    pretty_print_uint(" ", tot_moves, 9, 3);
-
-    VTR_LOG(" %6.3f", state.alpha);
-
-    if (noc_enabled) {
-        VTR_LOG(
-            " %7.2e %7.2e"
-            " %8.2e %8.2f",
-            noc_cost_terms.aggregate_bandwidth, noc_cost_terms.latency,
-            noc_cost_terms.latency_overrun, noc_cost_terms.congestion);
-    }
-
-    VTR_LOG("\n");
-    fflush(stdout);
-}
-
-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 = blk_loc_registry.block_locs();
-
-    size_t max_block_name = 0;
-    size_t max_tile_name = 0;
-
-    //Record the resource requirement
-    std::map<t_logical_block_type_ptr, size_t> num_type_instances;
-    std::map<t_logical_block_type_ptr, std::map<t_physical_tile_type_ptr, size_t>> num_placed_instances;
-
-    for (ClusterBlockId blk_id : cluster_ctx.clb_nlist.blocks()) {
-        const t_pl_loc& loc = block_locs[blk_id].loc;
-
-        t_physical_tile_type_ptr physical_tile = device_ctx.grid.get_physical_type({loc.x, loc.y, loc.layer});
-        t_logical_block_type_ptr logical_block = cluster_ctx.clb_nlist.block_type(blk_id);
-
-        num_type_instances[logical_block]++;
-        num_placed_instances[logical_block][physical_tile]++;
-
-        max_block_name = std::max(max_block_name, logical_block->name.length());
-        max_tile_name = std::max(max_tile_name, physical_tile->name.length());
-    }
-
-    VTR_LOG("\n");
-    VTR_LOG("Placement resource usage:\n");
-    for (const auto [logical_block_type_ptr, _] : num_type_instances) {
-        for (const auto [physical_tile_type_ptr, num_instances] : num_placed_instances[logical_block_type_ptr]) {
-            VTR_LOG("  %-*s implemented as %-*s: %d\n", max_block_name,
-                    logical_block_type_ptr->name.c_str(), max_tile_name,
-                    physical_tile_type_ptr->name.c_str(), num_instances);
-        }
-    }
-    VTR_LOG("\n");
-}
-
-static void print_placement_swaps_stats(const t_annealing_state& state, const t_swap_stats& swap_stats) {
-    size_t total_swap_attempts = swap_stats.num_swap_rejected + swap_stats.num_swap_accepted + swap_stats.num_swap_aborted;
-    VTR_ASSERT(total_swap_attempts > 0);
-
-    size_t num_swap_print_digits = ceil(log10(total_swap_attempts));
-    float reject_rate = (float)swap_stats.num_swap_rejected / total_swap_attempts;
-    float accept_rate = (float)swap_stats.num_swap_accepted / total_swap_attempts;
-    float abort_rate = (float)swap_stats.num_swap_aborted / total_swap_attempts;
-    VTR_LOG("Placement number of temperatures: %d\n", state.num_temps);
-    VTR_LOG("Placement total # of swap attempts: %*d\n", num_swap_print_digits,
-            total_swap_attempts);
-    VTR_LOG("\tSwaps accepted: %*d (%4.1f %%)\n", num_swap_print_digits,
-            swap_stats.num_swap_accepted, 100 * accept_rate);
-    VTR_LOG("\tSwaps rejected: %*d (%4.1f %%)\n", num_swap_print_digits,
-            swap_stats.num_swap_rejected, 100 * reject_rate);
-    VTR_LOG("\tSwaps aborted: %*d (%4.1f %%)\n", num_swap_print_digits,
-            swap_stats.num_swap_aborted, 100 * abort_rate);
-}
-
 static void copy_locs_to_global_state(const BlkLocRegistry& blk_loc_registry) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 

vpr/src/place/place_checkpoint.cpp

@@ -42,7 +42,7 @@ void restore_best_placement(PlacerState& placer_state,
                             t_placer_costs& costs,
                             std::unique_ptr<PlacerCriticalities>& placer_criticalities,
                             std::unique_ptr<PlacerSetupSlacks>& placer_setup_slacks,
-                            std::unique_ptr<PlaceDelayModel>& place_delay_model,
+                            std::shared_ptr<PlaceDelayModel>& place_delay_model,
                             std::unique_ptr<NetPinTimingInvalidator>& pin_timing_invalidator,
                             PlaceCritParams crit_params,
                             std::optional<NocCostHandler>& noc_cost_handler) {

vpr/src/place/place_checkpoint.h

@@ -74,7 +74,7 @@ void restore_best_placement(PlacerState& placer_state,
                             t_placer_costs& costs,
                             std::unique_ptr<PlacerCriticalities>& placer_criticalities,
                             std::unique_ptr<PlacerSetupSlacks>& placer_setup_slacks,
-                            std::unique_ptr<PlaceDelayModel>& place_delay_model,
+                            std::shared_ptr<PlaceDelayModel>& place_delay_model,
                             std::unique_ptr<NetPinTimingInvalidator>& pin_timing_invalidator,
                             PlaceCritParams crit_params,
                             std::optional<NocCostHandler>& noc_cost_handler);