#include "power.h"
#include "power_components.h"

Include dependency graph for power_util.h:

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

Functions
float	pin_dens (t_pb pb, t_pb_graph_pin pin)

float	pin_prob (t_pb pb, t_pb_graph_pin pin)

int	power_calc_pin_fanout (t_pb_graph_pin *pin, int mode_idx)

void	pb_foreach_pin (t_pb_graph_node pb_node, void(fn)(t_pb_graph_pin , void ), void *context)

void	power_zero_usage (t_power_usage *power_usage)

void	power_add_usage (t_power_usage dest, const t_power_usage src)

void	power_scale_usage (t_power_usage *power_usage, float scale_factor)

float	power_sum_usage (t_power_usage *power_usage)

float	power_perc_dynamic (t_power_usage *power_usage)

void	power_log_msg (e_power_log_type log_type, char *msg)

int	power_calc_buffer_num_stages (float final_stage_size, float desired_stage_effort)

float	calc_buffer_stage_effort (int N, float final_stage_size)

float	power_buffer_size_from_logical_effort (float C_load)

boolean	mux_find_selector_values (int selector_values, t_mux_node mux_node, int selected_input_pin)

t_mux_arch *	power_get_mux_arch (int num_mux_inputs, float transistor_size)

void	mux_arch_fix_levels (t_mux_arch *mux_arch)

boolean	power_method_is_transistor_level (e_power_estimation_method estimation_method)

boolean	power_method_is_recursive (e_power_estimation_method method)

char *	transistor_type_name (e_tx_type type)

char *	alloc_SRAM_values_from_truth_table (int LUT_size, t_linked_vptr *truth_table)

float	clb_net_density (int net_idx)

char *	interconnect_type_name (enum e_interconnect type)

float	clb_net_prob (int net_idx)

void	output_log (t_log log_ptr, FILE fp)

void	output_logs (FILE fp, t_log logs, int num_logs)

void	power_print_title (FILE fp, char title)

Function Documentation

char* alloc_SRAM_values_from_truth_table	(	int	LUT_size,
		t_linked_vptr *	truth_table
	)

This functions returns the LUT SRAM values from the given logic terms

LUT_size: The number of LUT inputs
truth_table: The logic terms saved from the BLIF file, in a linked list format

Definition at line 273 of file power_util.c.

                                      {
     char * SRAM_values;
     int i;
     int num_SRAM_bits;
     char * binary_str;
     char ** terms;
     char * buffer;
     char * str_loc;
     boolean on_set;
     t_linked_vptr * list_ptr;
     int num_terms;
     int term_idx;
     int bit_idx;
     int dont_care_start_pos;
 
     num_SRAM_bits = 1 << LUT_size;
     SRAM_values = (char*) my_calloc(num_SRAM_bits + 1, sizeof(char));
     SRAM_values[num_SRAM_bits] = '\0';
 
     if (!truth_table) {
         for (i = 0; i < num_SRAM_bits; i++) {
             SRAM_values[i] = '1';
         }
         return SRAM_values;
     }
 
     binary_str = (char*) my_calloc(LUT_size + 1, sizeof(char));
     buffer = (char*) my_calloc(LUT_size + 10, sizeof(char));
 
     strcpy(buffer, (char*) truth_table->data_vptr);
 
     /* Check if this is an unconnected node - hopefully these will be
      * ignored by VPR in the future
      */
     if (strcmp(buffer, " 0") == 0) {
         free(binary_str);
         free(buffer);
         return SRAM_values;
     } else if (strcmp(buffer, " 1") == 0) {
         for (i = 0; i < num_SRAM_bits; i++) {
             SRAM_values[i] = '1';
         }
         free(binary_str);
         free(buffer);
         return SRAM_values;
     }
 
     /* If the LUT is larger than the terms, the lower significant bits will be don't cares */
     str_loc = strtok(buffer, " \t");
     dont_care_start_pos = strlen(str_loc);
 
     /* Find out if the truth table provides the ON-set or OFF-set */
     str_loc = strtok(NULL, " \t");
     on_set = TRUE;
     if (str_loc[0] == '1') {
     } else if (str_loc[0] == '0') {
         on_set = FALSE;
     } else {
         assert(0);
     }
 
     /* Count truth table terms */
     num_terms = 0;
     for (list_ptr = truth_table; list_ptr != NULL; list_ptr = list_ptr->next) {
         num_terms++;
     }
     terms = (char**) my_calloc(num_terms, sizeof(char *));
 
     /* Extract truth table terms */
     for (list_ptr = truth_table, term_idx = 0; list_ptr != NULL; list_ptr =
             list_ptr->next, term_idx++) {
         terms[term_idx] = (char*) my_calloc(LUT_size + 1, sizeof(char));
 
         strcpy(buffer, (char*) list_ptr->data_vptr);
         str_loc = strtok(buffer, " \t");
         strcpy(terms[term_idx], str_loc);
 
         /* Fill don't cares for lower bits (when LUT is larger than term size) */
         for (bit_idx = dont_care_start_pos; bit_idx < LUT_size; bit_idx++) {
             terms[term_idx][bit_idx] = '-';
         }
 
         /* Verify on/off consistency */
         str_loc = strtok(NULL, " \t");
         if (on_set) {
             assert(str_loc[0] == '1');
         } else {
             assert(str_loc[0] == '0');
         }
     }
 
     /* Loop through all SRAM bits */
     for (i = 0; i < num_SRAM_bits; i++) {
         /* Set default value */
         if (on_set) {
             SRAM_values[i] = '0';
         } else {
             SRAM_values[i] = '1';
         }
 
         /* Get binary number representing this SRAM index */
         int_2_binary_str(binary_str, i, LUT_size);
 
         /* Loop through truth table terms */
         for (term_idx = 0; term_idx < num_terms; term_idx++) {
             boolean match = TRUE;
 
             for (bit_idx = 0; bit_idx < LUT_size; bit_idx++) {
                 if ((terms[term_idx][bit_idx] != '-')
                         && (terms[term_idx][bit_idx] != binary_str[bit_idx])) {
                     match = FALSE;
                     break;
                 }
             }
 
             if (match) {
                 if (on_set) {
                     SRAM_values[i] = '1';
                 } else {
                     SRAM_values[i] = '0';
                 }
 
                 /* No need to check the other terms, already matched */
                 break;
             }
         }
 
     }
     free(binary_str);
     free(buffer);
     for (term_idx = 0; term_idx < num_terms; term_idx++) {
         free(terms[term_idx]);
     }
     free(terms);
 
     return SRAM_values;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float calc_buffer_stage_effort	(	int	N,
		float	final_stage_size
	)

Calculates the required effort of each stage of a buffer

N: The number of stages of the buffer
final_stage_size: Size of the final inverter in the buffer, relative to a min size

Definition at line 204 of file power_util.c.

                                                               {
     if (N > 1)
         return pow((double) final_stage_size, (1.0 / ((double) N - 1)));
     else
         return 1.0;
 }

Here is the caller graph for this function:

float clb_net_density ( int net_idx )

Definition at line 420 of file power_util.c.

                                    {
     if (net_idx == OPEN) {
         return 0.;
     } else {
         return clb_net[net_idx].net_power->density;
     }
 }

Here is the caller graph for this function:

float clb_net_prob ( int net_idx )

Definition at line 428 of file power_util.c.

                                 {
     if (net_idx == OPEN) {
         return 0.;
     } else {
         return clb_net[net_idx].net_power->probability;
     }
 }

Here is the caller graph for this function:

char* interconnect_type_name ( enum e_interconnect type )

Definition at line 436 of file power_util.c.

                                                         {
     switch (type) {
     case COMPLETE_INTERC:
         return "complete";
     case MUX_INTERC:
         return "mux";
     case DIRECT_INTERC:
         return "direct";
     default:
         return "";
     }
 }

void mux_arch_fix_levels ( t_mux_arch * mux_arch )

Definition at line 413 of file power_util.c.

                                                 {
     while (((1 << mux_arch->levels) > mux_arch->num_inputs)
             && (mux_arch->levels > 1)) {
         mux_arch->levels--;
     }
 }

Here is the caller graph for this function:

boolean mux_find_selector_values	(	int *	selector_values,
		t_mux_node *	mux_node,
		int	selected_input_pin
	)

This function determines the values of the selectors in a static mux, based on the routing information.

selector_values: (Return values) selected index at each mux level
mux_node:
selected_input_pin: The input index to the multi-level mux that is chosen

Definition at line 119 of file power_util.c.

                                 {
     if (mux_node->level == 0) {
         if ((selected_input_pin >= mux_node->starting_pin_idx)
                 && (selected_input_pin
                         <= (mux_node->starting_pin_idx + mux_node->num_inputs))) {
             selector_values[mux_node->level] = selected_input_pin
                     - mux_node->starting_pin_idx;
             return TRUE;
         }
     } else {
         int input_idx;
         for (input_idx = 0; input_idx < mux_node->num_inputs; input_idx++) {
             if (mux_find_selector_values(selector_values,
                     &mux_node->children[input_idx], selected_input_pin)) {
                 selector_values[mux_node->level] = input_idx;
                 return TRUE;
             }
         }
     }
     return FALSE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void output_log	(	t_log *	log_ptr,
		FILE *	fp
	)

Definition at line 449 of file power_util.c.

                                             {
     int msg_idx;
 
     for (msg_idx = 0; msg_idx < log_ptr->num_messages; msg_idx++) {
         fprintf(fp, "%s\n", log_ptr->messages[msg_idx]);
     }
 }

Here is the caller graph for this function:

void output_logs	(	FILE *	fp,
		t_log *	logs,
		int	num_logs
	)

Definition at line 457 of file power_util.c.

                                                         {
     int log_idx;
 
     for (log_idx = 0; log_idx < num_logs; log_idx++) {
         if (logs[log_idx].num_messages) {
             power_print_title(fp, logs[log_idx].name);
             output_log(&logs[log_idx], fp);
             fprintf(fp, "\n");
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void pb_foreach_pin	(	t_pb_graph_node *	pb_node,
		void()(t_pb_graph_pin , void *)	fn,
		void *	context
	)

float pin_dens	(	t_pb *	pb,
		t_pb_graph_pin *	pin
	)

This file provides utility functions used by power estimation.

Definition at line 81 of file power_util.c.

                                                 {
     float density = 0.;
 
     if (pb) {
         int net_num;
         net_num = pb->rr_graph[pin->pin_count_in_cluster].net_num;
 
         if (net_num != OPEN) {
             density = vpack_net[net_num].net_power->density;
         }
     }
 
     return density;
 }

Here is the caller graph for this function:

float pin_prob	(	t_pb *	pb,
		t_pb_graph_pin *	pin
	)

Definition at line 96 of file power_util.c.

                                                 {
     /* Assumed pull-up on unused interconnect */
     float prob = 1.;
 
     if (pb) {
         int net_num;
         net_num = pb->rr_graph[pin->pin_count_in_cluster].net_num;
 
         if (net_num != OPEN) {
             prob = vpack_net[net_num].net_power->probability;
         }
     }
 
     return prob;
 }

Here is the caller graph for this function:

void power_add_usage	(	t_power_usage *	dest,
		const t_power_usage *	src
	)

Definition at line 49 of file power_util.c.

                                                                       {
     dest->dynamic += src->dynamic;
     dest->leakage += src->leakage;
 }

Here is the caller graph for this function:

float power_buffer_size_from_logical_effort ( float C_load )

Definition at line 469 of file power_util.c.

                                                           {
     return max(1.0f,
             C_load / g_power_commonly_used->INV_1X_C_in
                     / (2 * g_power_arch->logical_effort_factor));
 }

Here is the caller graph for this function:

int power_calc_buffer_num_stages	(	float	final_stage_size,
		float	desired_stage_effort
	)

Calculates the number of buffer stages required, to achieve a given buffer fanout final_stage_size: Size of the final inverter in the buffer, relative to a min size desired_stage_effort: The desired gain between stages, typically 4

Definition at line 179 of file power_util.c.

                                     {
     int N = 1;
 
     if (final_stage_size <= 1.0) {
         N = 1;
     } else if (final_stage_size < desired_stage_effort)
         N = 2;
     else {
         N = (int) (log(final_stage_size) / log(desired_stage_effort) + 1);
 
         /* We always round down.
          * Perhaps N+1 would be closer to the desired stage effort, but the delay savings
          * would likely not be worth the extra power/area
          */
     }
 
     return N;
 }

Here is the caller graph for this function:

int power_calc_pin_fanout	(	t_pb_graph_pin *	pin,
		int	mode_idx
	)

t_mux_arch* power_get_mux_arch	(	int	num_mux_inputs,
		float	transistor_size
	)

Definition at line 490 of file power_util.c.

                                                                            {
     int i;
 
     t_power_mux_info * mux_info = NULL;
 
     /* Find the mux archs for the given transistor size */
     std::map<float, t_power_mux_info*>::iterator it;
 
     it = g_power_commonly_used->mux_info.find(transistor_size);
 
     if (it == g_power_commonly_used->mux_info.end()) {
         mux_info = new t_power_mux_info;
         mux_info->mux_arch = NULL;
         mux_info->mux_arch_max_size = 0;
         g_power_commonly_used->mux_info[transistor_size] = mux_info;
     } else {
         mux_info = it->second;
     }
 
     if (num_mux_inputs > mux_info->mux_arch_max_size) {
         mux_info->mux_arch = (t_mux_arch*) my_realloc(mux_info->mux_arch,
                 (num_mux_inputs + 1) * sizeof(t_mux_arch));
 
         for (i = mux_info->mux_arch_max_size + 1; i <= num_mux_inputs; i++) {
             init_mux_arch_default(&mux_info->mux_arch[i], 2, i,
                     transistor_size);
         }
         mux_info->mux_arch_max_size = num_mux_inputs;
     }
     return &mux_info->mux_arch[num_mux_inputs];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void power_log_msg	(	e_power_log_type	log_type,
		char *	msg
	)

Definition at line 67 of file power_util.c.

                                                           {
     log_msg(&g_power_output->logs[log_type], msg);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean power_method_is_recursive ( e_power_estimation_method method )

Definition at line 587 of file power_util.c.

                                                                     {
     switch (method) {
     case POWER_METHOD_IGNORE:
     case POWER_METHOD_TOGGLE_PINS:
     case POWER_METHOD_C_INTERNAL:
     case POWER_METHOD_ABSOLUTE:
         return FALSE;
     case POWER_METHOD_AUTO_SIZES:
     case POWER_METHOD_SPECIFY_SIZES:
     case POWER_METHOD_SUM_OF_CHILDREN:
         return TRUE;
     case POWER_METHOD_UNDEFINED:
     default:
         assert(0);
     }
 
 // to get rid of warning
     return FALSE;
 }

Here is the caller graph for this function:

boolean power_method_is_transistor_level ( e_power_estimation_method estimation_method )

Definition at line 576 of file power_util.c.

                                                      {
     switch (estimation_method) {
     case POWER_METHOD_AUTO_SIZES:
     case POWER_METHOD_SPECIFY_SIZES:
         return TRUE;
     default:
         return FALSE;
     }
 }

Here is the caller graph for this function:

float power_perc_dynamic ( t_power_usage * power_usage )

Definition at line 63 of file power_util.c.

                                                       {
     return power_usage->dynamic / power_sum_usage(power_usage);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void power_print_title	(	FILE *	fp,
		char *	title
	)

Definition at line 475 of file power_util.c.

                                                 {
     int i;
     const int width = 80;
 
     int firsthalf = (width - strlen(title) - 2) / 2;
     int secondhalf = width - strlen(title) - 2 - firsthalf;
 
     for (i = 1; i <= firsthalf; i++)
         fprintf(fp, "-");
     fprintf(fp, " %s ", title);
     for (i = 1; i <= secondhalf; i++)
         fprintf(fp, "-");
     fprintf(fp, "\n");
 }

Here is the caller graph for this function:

void power_scale_usage	(	t_power_usage *	power_usage,
		float	scale_factor
	)

Definition at line 54 of file power_util.c.

                                                                         {
     power_usage->dynamic *= scale_factor;
     power_usage->leakage *= scale_factor;
 }

Here is the caller graph for this function:

float power_sum_usage ( t_power_usage * power_usage )

Definition at line 59 of file power_util.c.

                                                    {
     return power_usage->dynamic + power_usage->leakage;
 }

Here is the caller graph for this function:

void power_zero_usage ( t_power_usage * power_usage )

Definition at line 44 of file power_util.c.

                                                    {
     power_usage->dynamic = 0.;
     power_usage->leakage = 0.;
 }

Here is the caller graph for this function:

char* transistor_type_name ( e_tx_type type )

Definition at line 71 of file power_util.c.

                                             {
     if (type == NMOS) {
         return "NMOS";
     } else if (type == PMOS) {
         return "PMOS";
     } else {
         return "Unknown";
     }
 }

Here is the caller graph for this function:

Functions

Function Documentation