place.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	try_place (struct s_placer_opts placer_opts, struct s_annealing_sched annealing_sched, t_chan_width_dist chan_width_dist, struct s_router_opts router_opts, struct s_det_routing_arch det_routing_arch, t_segment_inf *segment_inf, t_timing_inf timing_inf, t_direct_inf *directs, int num_directs)

Function Documentation

void try_place	(	struct s_placer_opts	placer_opts,
		struct s_annealing_sched	annealing_sched,
		t_chan_width_dist	chan_width_dist,
		struct s_router_opts	router_opts,
		struct s_det_routing_arch	det_routing_arch,
		t_segment_inf *	segment_inf,
		t_timing_inf	timing_inf,
		t_direct_inf *	directs,
		int	num_directs
	)

Definition at line 310 of file place.c.

                                                                         {

    /* Does almost all the work of placing a circuit.  Width_fac gives the   *
     * width of the widest channel.  Place_cost_exp says what exponent the   *
     * width should be taken to when calculating costs.  This allows a       *
     * greater bias for anisotropic architectures.                           */

    int tot_iter, inner_iter, success_sum, move_lim, moves_since_cost_recompute, width_fac,
        num_connections, inet, ipin, outer_crit_iter_count, inner_crit_iter_count,
        inner_recompute_limit, swap_result;
    float t, success_rat, rlim, cost, timing_cost, bb_cost, new_bb_cost, new_timing_cost,
        delay_cost, new_delay_cost, place_delay_value, inverse_prev_bb_cost, inverse_prev_timing_cost,
        oldt, **old_region_occ_x, **old_region_occ_y, **net_delay = NULL, crit_exponent,
        first_rlim, final_rlim, inverse_delta_rlim, critical_path_delay = UNDEFINED,
        **remember_net_delay_original_ptr; /*used to free net_delay if it is re-assigned */
    double av_cost, av_bb_cost, av_timing_cost, av_delay_cost, sum_of_squares, std_dev;
    int total_swap_attempts;
    float reject_rate;
    float accept_rate;
    float abort_rate;
    char msg[BUFSIZE];
    t_slack * slacks = NULL;

    /* Allocated here because it goes into timing critical code where each memory allocation is expensive */

    remember_net_delay_original_ptr = NULL; /*prevents compiler warning */

    /* init file scope variables */
    num_swap_rejected = 0;
    num_swap_accepted = 0;
    num_swap_aborted = 0;
    num_ts_called = 0;

    if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
            || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE
            || placer_opts.enable_timing_computations) {
        /*do this before the initial placement to avoid messing up the initial placement */
        slacks = alloc_lookups_and_criticalities(chan_width_dist, router_opts,
                det_routing_arch, segment_inf, timing_inf, &net_delay, directs, num_directs);

        remember_net_delay_original_ptr = net_delay;

        /*#define PRINT_LOWER_BOUND */
#ifdef PRINT_LOWER_BOUND
        /*print the crit_path, assuming delay between blocks that are*
         *block_dist apart*/

        if (placer_opts.block_dist <= nx)
        place_delay_value =
        delta_clb_to_clb[placer_opts.block_dist][0];
        else if (placer_opts.block_dist <= ny)
        place_delay_value =
        delta_clb_to_clb[0][placer_opts.block_dist];
        else
        place_delay_value = delta_clb_to_clb[nx][ny];

        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "Lower bound assuming delay of %g\n", place_delay_value);

        load_constant_net_delay(net_delay, place_delay_value);
        load_timing_graph_net_delays(net_delay);
        do_timing_analysis(slacks, FALSE, FALSE, TRUE);

        if (getEchoEnabled()) {
            if(isEchoFileEnabled(E_ECHO_PLACEMENT_CRITICAL_PATH))
                print_critical_path(getEchoFileName(E_ECHO_PLACEMENT_CRITICAL_PATH));
            if(isEchoFileEnabled(E_ECHO_PLACEMENT_LOWER_BOUND_SINK_DELAYS))
                print_sink_delays(getEchoFileName(E_ECHO_PLACEMENT_LOWER_BOUND_SINK_DELAYS));
            if(isEchoFileEnabled(E_ECHO_PLACEMENT_LOGIC_SINK_DELAYS))
                print_sink_delays(getEchoFileName(E_ECHO_PLACEMENT_LOGIC_SINK_DELAYS));
        }

        /*also print sink delays assuming 0 delay between blocks, 
         * this tells us how much logic delay is on each path */

        load_constant_net_delay(net_delay, 0);
        load_timing_graph_net_delays(net_delay);
        do_timing_analysis(slacks, FALSE, FALSE, TRUE);

#endif

    }

    width_fac = placer_opts.place_chan_width;

    init_chan(width_fac, chan_width_dist);

    alloc_and_load_placement_structs(
            placer_opts.place_cost_exp,
            &old_region_occ_x, &old_region_occ_y, placer_opts,
            directs, num_directs);

    initial_placement(placer_opts.pad_loc_type, placer_opts.pad_loc_file);
    init_draw_coords((float) width_fac);

    /* Storing the number of pins on each type of block makes the swap routine *
     * slightly more efficient.                                                */

    /* Gets initial cost and loads bounding boxes. */

    if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
            || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
        bb_cost = comp_bb_cost(NORMAL);

        crit_exponent = placer_opts.td_place_exp_first; /*this will be modified when rlim starts to change */

        num_connections = count_connections();
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "There are %d point to point connections in this circuit.\n", num_connections);
        vpr_printf(TIO_MESSAGE_INFO, "\n");

        if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE) {
            for (inet = 0; inet < num_nets; inet++)
                for (ipin = 1; ipin <= clb_net[inet].num_sinks; ipin++)
                    timing_place_crit[inet][ipin] = 0; /*dummy crit values */

            comp_td_costs(&timing_cost, &delay_cost); /*first pass gets delay_cost, which is used 
             * in criticality computations in the next call
             * to comp_td_costs. */
            place_delay_value = delay_cost / num_connections; /*used for computing criticalities */
            load_constant_net_delay(net_delay, place_delay_value, clb_net,
                    num_nets);

        } else
            place_delay_value = 0;

        if (placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
            net_delay = point_to_point_delay_cost; /*this keeps net_delay up to date with      *
             * *the same values that the placer is using  *
             * *point_to_point_delay_cost is computed each*
             * *time that comp_td_costs is called, and is *
             * *also updated after any swap is accepted   */
        }

        load_timing_graph_net_delays(net_delay);
        do_timing_analysis(slacks, FALSE, FALSE, FALSE);
        load_criticalities(slacks, crit_exponent);
        if (getEchoEnabled()) {
            if(isEchoFileEnabled(E_ECHO_INITIAL_PLACEMENT_TIMING_GRAPH))
                print_timing_graph(getEchoFileName(E_ECHO_INITIAL_PLACEMENT_TIMING_GRAPH));
            if(isEchoFileEnabled(E_ECHO_INITIAL_PLACEMENT_SLACK))
                print_slack(slacks->slack, FALSE, getEchoFileName(E_ECHO_INITIAL_PLACEMENT_SLACK));
            if(isEchoFileEnabled(E_ECHO_INITIAL_PLACEMENT_CRITICALITY))
                print_criticality(slacks, FALSE, getEchoFileName(E_ECHO_INITIAL_PLACEMENT_CRITICALITY));
        }
        outer_crit_iter_count = 1;

        /*now we can properly compute costs  */
        comp_td_costs(&timing_cost, &delay_cost); /*also vpr_printf proper values into point_to_point_delay_cost */

        inverse_prev_timing_cost = 1 / timing_cost;
        inverse_prev_bb_cost = 1 / bb_cost;
        cost = 1; /*our new cost function uses normalized values of           */
        /*bb_cost and timing_cost, the value of cost will be reset  */
        /*to 1 at each temperature when *_TIMING_DRIVEN_PLACE is true */
    } else { /*BOUNDING_BOX_PLACE */
        cost = bb_cost = comp_bb_cost(NORMAL);
        timing_cost = 0;
        delay_cost = 0;
        place_delay_value = 0;
        outer_crit_iter_count = 0;
        num_connections = 0;
        crit_exponent = 0;

        inverse_prev_timing_cost = 0; /*inverses not used */
        inverse_prev_bb_cost = 0;
    }

    move_lim = (int) (annealing_sched.inner_num * pow(num_blocks, 1.3333));

    if (placer_opts.inner_loop_recompute_divider != 0)
        inner_recompute_limit = (int) (0.5
                + (float) move_lim
                        / (float) placer_opts.inner_loop_recompute_divider);
    else
        /*don't do an inner recompute */
        inner_recompute_limit = move_lim + 1;

    /* Sometimes I want to run the router with a random placement.  Avoid *
     * using 0 moves to stop division by 0 and 0 length vector problems,  *
     * by setting move_lim to 1 (which is still too small to do any       *
     * significant optimization).                                         */

    if (move_lim <= 0)
        move_lim = 1;

    rlim = (float) std::max(nx + 1, ny + 1);

    first_rlim = rlim; /*used in timing-driven placement for exponent computation */
    final_rlim = 1;
    inverse_delta_rlim = 1 / (first_rlim - final_rlim);

    t = starting_t(&cost, &bb_cost, &timing_cost,
            old_region_occ_x, old_region_occ_y,
            annealing_sched, move_lim, rlim,
            placer_opts.place_algorithm, placer_opts.timing_tradeoff,
            inverse_prev_bb_cost, inverse_prev_timing_cost, &delay_cost);
    tot_iter = 0;
    moves_since_cost_recompute = 0;
    vpr_printf(TIO_MESSAGE_INFO, "Initial placement cost: %g bb_cost: %g td_cost: %g delay_cost: %g\n",
                cost, bb_cost, timing_cost, delay_cost);
    vpr_printf(TIO_MESSAGE_INFO, "\n");

#ifndef SPEC
    vpr_printf(TIO_MESSAGE_INFO, "%9s %9s %11s %11s %11s %11s %8s %8s %7s %7s %7s %9s %7s\n",
            "---------", "---------", "-----------", "-----------", "-----------", "-----------", 
            "--------", "--------", "-------", "-------", "-------", "---------", "-------");
    vpr_printf(TIO_MESSAGE_INFO, "%9s %9s %11s %11s %11s %11s %8s %8s %7s %7s %7s %9s %7s\n",
            "T", "Cost", "Av BB Cost", "Av TD Cost", "Av Tot Del",
            "P to P Del", "d_max", "Ac Rate", "Std Dev", "R limit", "Exp",
            "Tot Moves", "Alpha");
    vpr_printf(TIO_MESSAGE_INFO, "%9s %9s %11s %11s %11s %11s %8s %8s %7s %7s %7s %9s %7s\n",
            "---------", "---------", "-----------", "-----------", "-----------", "-----------", 
            "--------", "--------", "-------", "-------", "-------", "---------", "-------");
#endif

    sprintf(msg, "Initial Placement.  Cost: %g  BB Cost: %g  TD Cost %g  Delay Cost: %g \t Channel Factor: %d", 
        cost, bb_cost, timing_cost, delay_cost, width_fac);
    update_screen(MAJOR, msg, PLACEMENT, FALSE);

    while (exit_crit(t, cost, annealing_sched) == 0) {

        if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
            cost = 1;
        }

        av_cost = 0.;
        av_bb_cost = 0.;
        av_delay_cost = 0.;
        av_timing_cost = 0.;
        sum_of_squares = 0.;
        success_sum = 0;

        if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {

            if (outer_crit_iter_count >= placer_opts.recompute_crit_iter
                    || placer_opts.inner_loop_recompute_divider != 0) {
#ifdef VERBOSE
                vpr_printf(TIO_MESSAGE_INFO, "Outer loop recompute criticalities\n");
#endif
                place_delay_value = delay_cost / num_connections;

                if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE)
                    load_constant_net_delay(net_delay, place_delay_value,
                            clb_net, num_nets);
                /*note, for path_based, the net delay is not updated since it is current,
                 *because it accesses point_to_point_delay array */

                load_timing_graph_net_delays(net_delay);
                do_timing_analysis(slacks, FALSE, FALSE, FALSE);
                load_criticalities(slacks, crit_exponent);
                /*recompute costs from scratch, based on new criticalities */
                comp_td_costs(&timing_cost, &delay_cost);
                outer_crit_iter_count = 0;
            }
            outer_crit_iter_count++;

            /*at each temperature change we update these values to be used     */
            /*for normalizing the tradeoff between timing and wirelength (bb)  */
            inverse_prev_bb_cost = 1 / bb_cost;
            /*Prevent inverse timing cost from going to infinity */
            inverse_prev_timing_cost = std::min(1 / timing_cost, (float)MAX_INV_TIMING_COST);
        }

        inner_crit_iter_count = 1;

        for (inner_iter = 0; inner_iter < move_lim; inner_iter++) {
            swap_result = try_swap(t, &cost, &bb_cost, &timing_cost, rlim,
                    old_region_occ_x,
                    old_region_occ_y, 
                    placer_opts.place_algorithm, placer_opts.timing_tradeoff,
                    inverse_prev_bb_cost, inverse_prev_timing_cost, &delay_cost);
            if (swap_result == ACCEPTED) {

                /* Move was accepted.  Update statistics that are useful for the annealing schedule. */
                success_sum++;
                av_cost += cost;
                av_bb_cost += bb_cost;
                av_timing_cost += timing_cost;
                av_delay_cost += delay_cost;
                sum_of_squares += cost * cost;
                num_swap_accepted++;
            } else if (swap_result == ABORTED) {
                num_swap_aborted++;
            } else { // swap_result == REJECTED
                num_swap_rejected++;
            }


            if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                    || placer_opts.place_algorithm
                            == PATH_TIMING_DRIVEN_PLACE) {

                /* Do we want to re-timing analyze the circuit to get updated slack and criticality values? 
                 * We do this only once in a while, since it is expensive.
                 */
                if (inner_crit_iter_count >= inner_recompute_limit
                        && inner_iter != move_lim - 1) { /*on last iteration don't recompute */

                    inner_crit_iter_count = 0;
#ifdef VERBOSE
                    vpr_printf(TIO_MESSAGE_TRACE, "Inner loop recompute criticalities\n");
#endif
                    if (placer_opts.place_algorithm
                            == NET_TIMING_DRIVEN_PLACE) {
                        /* Use a constant delay per connection as the delay estimate, rather than
                         * estimating based on the current placement.  Not a great idea, but not the 
                         * default.
                         */
                        place_delay_value = delay_cost / num_connections;
                        load_constant_net_delay(net_delay, place_delay_value,
                                clb_net, num_nets);
                    }

                    /* Using the delays in net_delay, do a timing analysis to update slacks and
                     * criticalities; then update the timing cost since it will change.
                     */
                    load_timing_graph_net_delays(net_delay);
                    do_timing_analysis(slacks, FALSE, FALSE, FALSE);
                    load_criticalities(slacks, crit_exponent);
                    comp_td_costs(&timing_cost, &delay_cost);
                }
                inner_crit_iter_count++;
            }
#ifdef VERBOSE
            vpr_printf(TIO_MESSAGE_TRACE, "t = %g  cost = %g   bb_cost = %g timing_cost = %g move = %d dmax = %g\n",
                    t, cost, bb_cost, timing_cost, inner_iter, delay_cost);
            if (fabs(bb_cost - comp_bb_cost(CHECK)) > bb_cost * ERROR_TOL)
                exit(1);
#endif
        }

        /* Lines below prevent too much round-off error from accumulating *
         * in the cost over many iterations.  This round-off can lead to  *
         * error checks failing because the cost is different from what   *
         * you get when you recompute from scratch.                       */

        moves_since_cost_recompute += move_lim;
        if (moves_since_cost_recompute > MAX_MOVES_BEFORE_RECOMPUTE) {
            new_bb_cost = recompute_bb_cost();
            if (fabs(new_bb_cost - bb_cost) > bb_cost * ERROR_TOL) {
                vpr_printf(TIO_MESSAGE_ERROR, "in try_place: new_bb_cost = %g, old bb_cost = %g\n", 
                        new_bb_cost, bb_cost);
                exit(1);
            }
            bb_cost = new_bb_cost;

            if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                    || placer_opts.place_algorithm
                            == PATH_TIMING_DRIVEN_PLACE) {
                comp_td_costs(&new_timing_cost, &new_delay_cost);
                if (fabs(new_timing_cost - timing_cost) > timing_cost * ERROR_TOL) {
                    vpr_printf(TIO_MESSAGE_ERROR, "in try_place: new_timing_cost = %g, old timing_cost = %g\n",
                            new_timing_cost, timing_cost);
                    exit(1);
                }
                if (fabs(new_delay_cost - delay_cost) > delay_cost * ERROR_TOL) {
                    vpr_printf(TIO_MESSAGE_ERROR, "in try_place: new_delay_cost = %g, old delay_cost = %g\n",
                            new_delay_cost, delay_cost);
                    exit(1);
                }
                timing_cost = new_timing_cost;
            }

            if (placer_opts.place_algorithm == BOUNDING_BOX_PLACE) {
                cost = new_bb_cost;
            }
            moves_since_cost_recompute = 0;
        }

        tot_iter += move_lim;
        success_rat = ((float) success_sum) / move_lim;
        if (success_sum == 0) {
            av_cost = cost;
            av_bb_cost = bb_cost;
            av_timing_cost = timing_cost;
            av_delay_cost = delay_cost;
        } else {
            av_cost /= success_sum;
            av_bb_cost /= success_sum;
            av_timing_cost /= success_sum;
            av_delay_cost /= success_sum;
        }
        std_dev = get_std_dev(success_sum, sum_of_squares, av_cost);

        oldt = t; /* for finding and printing alpha. */
        update_t(&t, std_dev, rlim, success_rat, annealing_sched);

#ifndef SPEC
        critical_path_delay = get_critical_path_delay();
        vpr_printf(TIO_MESSAGE_INFO, "%9.5f %9.5g %11.6g %11.6g %11.6g %11.6g %8.4f %8.4f %7.4f %7.4f %7.4f %9d %7.4f\n",
                oldt, av_cost, av_bb_cost, av_timing_cost, av_delay_cost, place_delay_value, 
                critical_path_delay, success_rat, std_dev, rlim, crit_exponent, tot_iter, t / oldt);
#endif

        sprintf(msg, "Cost: %g  BB Cost %g  TD Cost %g  Temperature: %g",
                cost, bb_cost, timing_cost, t);
        update_screen(MINOR, msg, PLACEMENT, FALSE);
        update_rlim(&rlim, success_rat);

        if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
            crit_exponent = (1 - (rlim - final_rlim) * inverse_delta_rlim)
                    * (placer_opts.td_place_exp_last
                            - placer_opts.td_place_exp_first)
                    + placer_opts.td_place_exp_first;
        }
#ifdef VERBOSE
        if (getEchoEnabled()) {
            print_clb_placement("first_iteration_clb_placement.echo");
        }
#endif
    }

    t = 0; /* freeze out */
    av_cost = 0.;
    av_bb_cost = 0.;
    av_timing_cost = 0.;
    sum_of_squares = 0.;
    av_delay_cost = 0.;
    success_sum = 0;

    if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
            || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE) {
        /*at each temperature change we update these values to be used     */
        /*for normalizing the tradeoff between timing and wirelength (bb)  */
        if (outer_crit_iter_count >= placer_opts.recompute_crit_iter
                || placer_opts.inner_loop_recompute_divider != 0) {

#ifdef VERBOSE
            vpr_printf(TIO_MESSAGE_INFO, "Outer loop recompute criticalities\n");
#endif
            place_delay_value = delay_cost / num_connections;

            if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE)
                load_constant_net_delay(net_delay, place_delay_value, clb_net,
                        num_nets);

            load_timing_graph_net_delays(net_delay);
            do_timing_analysis(slacks, FALSE, FALSE, FALSE);
            load_criticalities(slacks, crit_exponent);
            /*recompute criticaliies */
            comp_td_costs(&timing_cost, &delay_cost);
            outer_crit_iter_count = 0;
        }
        outer_crit_iter_count++;

        inverse_prev_bb_cost = 1 / (bb_cost);
        /*Prevent inverse timing cost from going to infinity */     
        inverse_prev_timing_cost = std::min(1 / timing_cost, (float)MAX_INV_TIMING_COST);
    }

    inner_crit_iter_count = 1;

    for (inner_iter = 0; inner_iter < move_lim; inner_iter++) {
        swap_result = try_swap(t, &cost, &bb_cost, &timing_cost, rlim,
                old_region_occ_x, old_region_occ_y,
                placer_opts.place_algorithm, placer_opts.timing_tradeoff,
                inverse_prev_bb_cost, inverse_prev_timing_cost, &delay_cost);
        
        if (swap_result == ACCEPTED) {
            success_sum++;
            av_cost += cost;
            av_bb_cost += bb_cost;
            av_delay_cost += delay_cost;
            av_timing_cost += timing_cost;
            sum_of_squares += cost * cost;

            if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
                    || placer_opts.place_algorithm
                            == PATH_TIMING_DRIVEN_PLACE) {

                if (inner_crit_iter_count >= inner_recompute_limit
                        && inner_iter != move_lim - 1) {

                    inner_crit_iter_count = 0;
#ifdef VERBOSE
                    vpr_printf(TIO_MESSAGE_TRACE, "Inner loop recompute criticalities\n");
#endif
                    if (placer_opts.place_algorithm
                            == NET_TIMING_DRIVEN_PLACE) {
                        place_delay_value = delay_cost / num_connections;
                        load_constant_net_delay(net_delay, place_delay_value,
                                clb_net, num_nets);
                    }

                    load_timing_graph_net_delays(net_delay);
                    do_timing_analysis(slacks, FALSE, FALSE, FALSE);
                    load_criticalities(slacks, crit_exponent);
                    comp_td_costs(&timing_cost, &delay_cost);
                }
                inner_crit_iter_count++;
            }
            num_swap_accepted++;
        } else if (swap_result == ABORTED) {
            num_swap_aborted++;
        } else {
            num_swap_rejected++;
        }

#ifdef VERBOSE
        vpr_printf(TIO_MESSAGE_INFO, "t = %g, cost = %g, move = %d\n", t, cost, tot_iter);
#endif
    }
    tot_iter += move_lim;
    success_rat = ((float) success_sum) / move_lim;
    if (success_sum == 0) {
        av_cost = cost;
        av_bb_cost = bb_cost;
        av_delay_cost = delay_cost;
        av_timing_cost = timing_cost;
    } else {
        av_cost /= success_sum;
        av_bb_cost /= success_sum;
        av_delay_cost /= success_sum;
        av_timing_cost /= success_sum;
    }

    std_dev = get_std_dev(success_sum, sum_of_squares, av_cost);

#ifndef SPEC
    vpr_printf(TIO_MESSAGE_INFO, "%9.5f %9.5g %11.6g %11.6g %11.6g %11.6g %8s %8.4f %7.4f %7.4f %7.4f %9d\n",
            t, av_cost, av_bb_cost, av_timing_cost, av_delay_cost, place_delay_value, 
            " ", success_rat, std_dev, rlim, crit_exponent, tot_iter);
#endif

    // TODO:  
    // 1. print a message about number of aborted moves.
    // 2. add some subroutine hierarchy!  Too big!
    // 3. put statistics counters (av_cost, success_sum, etc.) in a struct so a 
    // pointer to it can be passed around. 

#ifdef VERBOSE
    if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_END_CLB_PLACEMENT)) {
        print_clb_placement(getEchoFileName(E_ECHO_END_CLB_PLACEMENT));
    }
#endif

    check_place(bb_cost, timing_cost,
            placer_opts.place_algorithm, delay_cost);

    if (placer_opts.enable_timing_computations
            && placer_opts.place_algorithm == BOUNDING_BOX_PLACE) {
        /*need this done since the timing data has not been kept up to date*
         *in bounding_box mode */
        for (inet = 0; inet < num_nets; inet++)
            for (ipin = 1; ipin <= clb_net[inet].num_sinks; ipin++)
                timing_place_crit[inet][ipin] = 0; /*dummy crit values */
        comp_td_costs(&timing_cost, &delay_cost); /*computes point_to_point_delay_cost */
    }

    if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
            || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE
            || placer_opts.enable_timing_computations) {
        net_delay = point_to_point_delay_cost; /*this makes net_delay up to date with    *
         *the same values that the placer is using*/
        load_timing_graph_net_delays(net_delay);

        do_timing_analysis(slacks, FALSE, FALSE, FALSE);

        if (getEchoEnabled()) {
            if(isEchoFileEnabled(E_ECHO_PLACEMENT_SINK_DELAYS))
                print_sink_delays(getEchoFileName(E_ECHO_PLACEMENT_SINK_DELAYS));
            if(isEchoFileEnabled(E_ECHO_FINAL_PLACEMENT_SLACK))
                print_slack(slacks->slack, FALSE, getEchoFileName(E_ECHO_FINAL_PLACEMENT_SLACK));
            if(isEchoFileEnabled(E_ECHO_FINAL_PLACEMENT_CRITICALITY))
                print_criticality(slacks, FALSE, getEchoFileName(E_ECHO_FINAL_PLACEMENT_CRITICALITY));
            if(isEchoFileEnabled(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH))
                print_timing_graph(getEchoFileName(E_ECHO_FINAL_PLACEMENT_TIMING_GRAPH));
            if(isEchoFileEnabled(E_ECHO_PLACEMENT_CRIT_PATH))
                print_critical_path(getEchoFileName(E_ECHO_PLACEMENT_CRIT_PATH));
        }

        /* Print critical path delay. */
        critical_path_delay = get_critical_path_delay();
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "Placement estimated critical path delay: %g ns\n", critical_path_delay);
    }

    sprintf(msg, "Placement. Cost: %g  bb_cost: %g td_cost: %g Channel Factor: %d",
            cost, bb_cost, timing_cost, width_fac);
    vpr_printf(TIO_MESSAGE_INFO, "Placement cost: %g, bb_cost: %g, td_cost: %g, delay_cost: %g\n", 
            cost, bb_cost, timing_cost, delay_cost);
    update_screen(MAJOR, msg, PLACEMENT, FALSE);
     
    // Print out swap statistics
    total_swap_attempts = num_swap_rejected + num_swap_accepted + num_swap_aborted;
    reject_rate = num_swap_rejected / total_swap_attempts;
    accept_rate = num_swap_accepted / total_swap_attempts;
    abort_rate = num_swap_aborted / total_swap_attempts;
    vpr_printf(TIO_MESSAGE_INFO, "Placement total # of swap attempts: %d\n", total_swap_attempts);
    vpr_printf(TIO_MESSAGE_INFO, "\tSwap reject rate: %g\n", reject_rate);
    vpr_printf(TIO_MESSAGE_INFO, "\tSwap accept rate: %g\n", accept_rate);
    vpr_printf(TIO_MESSAGE_INFO, "\tSwap abort rate: %g\n", abort_rate);
    

#ifdef SPEC
    vpr_printf(TIO_MESSAGE_INFO, "Total moves attempted: %d.0\n", tot_iter);
#endif

    free_placement_structs(
                old_region_occ_x, old_region_occ_y,
                placer_opts);
    if (placer_opts.place_algorithm == NET_TIMING_DRIVEN_PLACE
            || placer_opts.place_algorithm == PATH_TIMING_DRIVEN_PLACE
            || placer_opts.enable_timing_computations) {

        net_delay = remember_net_delay_original_ptr;
        free_lookups_and_criticalities(&net_delay, slacks);
    }

    free_try_swap_arrays();
}

Here is the call graph for this function:

Here is the caller graph for this function: