timing_place.c File Reference

#include <stdio.h>
#include <math.h>
#include "util.h"
#include "vpr_types.h"
#include "globals.h"
#include "path_delay.h"
#include "path_delay2.h"
#include "net_delay.h"
#include "timing_place_lookup.h"
#include "timing_place.h"

Include dependency graph for timing_place.c:

Go to the source code of this file.

Functions
static float **	alloc_crit (t_chunk *chunk_list_ptr)
static void	free_crit (t_chunk *chunk_list_ptr)
void	print_sink_delays (const char *fname)
void	load_criticalities (t_slack *slacks, float crit_exponent)
t_slack *	alloc_lookups_and_criticalities (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, float ***net_delay, INP t_direct_inf *directs, INP int num_directs)
void	free_lookups_and_criticalities (float ***net_delay, t_slack *slacks)

Variables
float **	timing_place_crit
static t_chunk	timing_place_crit_ch = {NULL, 0, NULL}
static t_chunk	net_delay_ch = {NULL, 0, NULL}

Function Documentation

static float ** alloc_crit ( t_chunk *  chunk_list_ptr )

static

Definition at line 31 of file timing_place.c.

                                                    {

    /* Allocates space for the timing_place_crit data structure *
     * [0..num_nets-1][1..num_pins-1].  I chunk the data to save space on large    *
     * problems.                                                                   */

    float **local_crit; /* [0..num_nets-1][1..num_pins-1] */
    float *tmp_ptr;
    int inet;

    local_crit = (float **) my_malloc(num_nets * sizeof(float *));

    for (inet = 0; inet < num_nets; inet++) {
        tmp_ptr = (float *) my_chunk_malloc(
                (clb_net[inet].num_sinks) * sizeof(float), chunk_list_ptr);
        local_crit[inet] = tmp_ptr - 1; /* [1..num_sinks] */
    }

    return (local_crit);
}

Here is the call graph for this function:

Here is the caller graph for this function:

t_slack* alloc_lookups_and_criticalities	(	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,
		float ***	net_delay,
		INP t_direct_inf *	directs,
		INP int	num_directs
	)

Definition at line 121 of file timing_place.c.

                             {

    t_slack * slacks = alloc_and_load_timing_graph(timing_inf);

    (*net_delay) = alloc_net_delay(&net_delay_ch, clb_net,
            num_nets);

    compute_delay_lookup_tables(router_opts, det_routing_arch, segment_inf,
            timing_inf, chan_width_dist, directs, num_directs);
    
    timing_place_crit = alloc_crit(&timing_place_crit_ch);

    return slacks;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_crit ( t_chunk *  chunk_list_ptr )

static

Definition at line 53 of file timing_place.c.

                                              {
    free_chunk_memory(chunk_list_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_lookups_and_criticalities	(	float ***	net_delay,
		t_slack *	slacks
	)

Definition at line 141 of file timing_place.c.

                                                                          {

    free(timing_place_crit);
    free_crit(&timing_place_crit_ch);

    free_timing_graph(slacks);
    free_net_delay(*net_delay, &net_delay_ch);

    free_place_lookup_structs();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void load_criticalities	(	t_slack *	slacks,
		float	crit_exponent
	)

Definition at line 81 of file timing_place.c.

                                                               {
    /* Performs a 1-to-1 mapping from criticality to timing_place_crit.  
      For every pin on every net (or, equivalently, for every tedge ending 
      in that pin), timing_place_crit = criticality^(criticality exponent) */

    int inet, ipin;
#ifdef PATH_COUNTING
    float timing_criticality, path_criticality; 
#endif

    for (inet = 0; inet < num_nets; inet++) {
        if (inet == OPEN)
            continue;
        if (clb_net[inet].is_global)
            continue;
        for (ipin = 1; ipin <= clb_net[inet].num_sinks; ipin++) {
            if (slacks->timing_criticality[inet][ipin] < HUGE_NEGATIVE_FLOAT + 1) {
                /* We didn't analyze this connection, so give it a timing_place_crit of 0. */
                timing_place_crit[inet][ipin] = 0.;
            } else {
#ifdef PATH_COUNTING
                /* Calculate criticality as a weighted sum of timing criticality and path 
                criticality. The placer likes a great deal of contrast between criticalities. 
                Since path criticality varies much more than timing, we "sharpen" timing 
                criticality by taking it to some power, crit_exponent (between 1 and 8 by default). */
                path_criticality = slacks->path_criticality[inet][ipin];
                timing_criticality = pow(slacks->timing_criticality[inet][ipin], crit_exponent);

                timing_place_crit[inet][ipin] =      PLACE_PATH_WEIGHT  * path_criticality
                                              + (1 - PLACE_PATH_WEIGHT) * timing_criticality; 
#else
                /* Just take timing criticality to some power (crit_exponent). */
                timing_place_crit[inet][ipin] = pow(slacks->timing_criticality[inet][ipin], crit_exponent);
#endif
            }
        }
    }
}

Here is the caller graph for this function:

void print_sink_delays

(

const char *

fname

)

Definition at line 58 of file timing_place.c.

                                          {

    int num_at_level, num_edges, inode, ilevel, i;
    FILE *fp;

    fp = my_fopen(fname, "w", 0);

    for (ilevel = num_tnode_levels - 1; ilevel >= 0; ilevel--) {
        num_at_level = tnodes_at_level[ilevel].nelem;

        for (i = 0; i < num_at_level; i++) {
            inode = tnodes_at_level[ilevel].list[i];
            num_edges = tnode[inode].num_edges;

            if (num_edges == 0) { /* sink */
                fprintf(fp, "%g\n", tnode[inode].T_arr);
            }
        }
    }
    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

t_chunk net_delay_ch = {NULL, 0, NULL}

static

Definition at line 15 of file timing_place.c.

float** timing_place_crit

Definition at line 12 of file timing_place.c.

t_chunk timing_place_crit_ch = {NULL, 0, NULL}

static

Definition at line 14 of file timing_place.c.