vpr/SRC/place/timing_place.c

#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"

float **timing_place_crit; /*available externally */

static t_chunk timing_place_crit_ch = {NULL, 0, NULL};
static t_chunk net_delay_ch = {NULL, 0, NULL};

/*static struct s_linked_vptr *timing_place_crit_chunk_list_head;
static struct s_linked_vptr *net_delay_chunk_list_head;*/

/******** prototypes ******************/
/*static float **alloc_crit(struct s_linked_vptr **chunk_list_head_ptr);

static void free_crit(struct s_linked_vptr **chunk_list_head_ptr);*/

static float **alloc_crit(t_chunk *chunk_list_ptr);

static void free_crit(t_chunk *chunk_list_ptr);

/**************************************/

static float ** alloc_crit(t_chunk *chunk_list_ptr) {

	/* 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);
}

/**************************************/
static void free_crit(t_chunk *chunk_list_ptr){
	free_chunk_memory(chunk_list_ptr);
}

/**************************************/
void print_sink_delays(const char *fname) {

	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);
}

/**************************************/
void load_criticalities(t_slack * slacks, float crit_exponent) {
	/* 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
			}
		}
	}
}

/**************************************/
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) {

	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;
}

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

	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();
}

/**************************************/