power_util.c File Reference

#include <cstring>
#include <map>
#include <assert.h>
#include "power_util.h"
#include "globals.h"

Include dependency graph for power_util.c:

Go to the source code of this file.

Functions
static void	log_msg (t_log *log_ptr, char *msg)
static void	int_2_binary_str (char *binary_str, int value, int str_length)
static void	init_mux_arch_default (t_mux_arch *mux_arch, int levels, int num_inputs, float transistor_size)
static void	alloc_and_load_mux_graph_recursive (t_mux_node *node, int num_primary_inputs, int level, int starting_pin_idx)
static t_mux_node *	alloc_and_load_mux_graph (int num_inputs, int levels)
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)
char *	transistor_type_name (e_tx_type type)
float	pin_dens (t_pb *pb, t_pb_graph_pin *pin)
float	pin_prob (t_pb *pb, t_pb_graph_pin *pin)
boolean	mux_find_selector_values (int *selector_values, t_mux_node *mux_node, int selected_input_pin)
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)
char *	alloc_SRAM_values_from_truth_table (int LUT_size, t_linked_vptr *truth_table)
void	mux_arch_fix_levels (t_mux_arch *mux_arch)
float	clb_net_density (int net_idx)
float	clb_net_prob (int net_idx)
char *	interconnect_type_name (enum e_interconnect type)
void	output_log (t_log *log_ptr, FILE *fp)
void	output_logs (FILE *fp, t_log *logs, int num_logs)
float	power_buffer_size_from_logical_effort (float C_load)
void	power_print_title (FILE *fp, char *title)
t_mux_arch *	power_get_mux_arch (int num_mux_inputs, float transistor_size)
boolean	power_method_is_transistor_level (e_power_estimation_method estimation_method)
boolean	power_method_is_recursive (e_power_estimation_method method)

Function Documentation

static t_mux_node * alloc_and_load_mux_graph ( int  num_inputs, int  levels  )

static

Allocates a builds a multiplexer graph with given # inputs and levels

Definition at line 542 of file power_util.c.

                                                                         {
    t_mux_node * node;

    node = (t_mux_node*) my_malloc(sizeof(t_mux_node));
    alloc_and_load_mux_graph_recursive(node, num_inputs, levels - 1, 0);

    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void alloc_and_load_mux_graph_recursive ( t_mux_node *  node, int  num_primary_inputs, int  level, int  starting_pin_idx  )

static

Definition at line 551 of file power_util.c.

                                                                 {
    int child_idx;
    int pin_idx = starting_pin_idx;

    node->num_inputs = (int) (pow(num_primary_inputs, 1 / ((float) level + 1))
            + 0.5);
    node->level = level;
    node->starting_pin_idx = starting_pin_idx;

    if (level != 0) {
        node->children = (t_mux_node*) my_calloc(node->num_inputs,
                sizeof(t_mux_node));
        for (child_idx = 0; child_idx < node->num_inputs; child_idx++) {
            int num_child_pi = num_primary_inputs / node->num_inputs;
            if (child_idx < (num_primary_inputs % node->num_inputs)) {
                num_child_pi++;
            }
            alloc_and_load_mux_graph_recursive(&node->children[child_idx],
                    num_child_pi, level - 1, pin_idx);
            pin_idx += num_child_pi;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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:

static void init_mux_arch_default ( t_mux_arch *  mux_arch, int  levels, int  num_inputs, float  transistor_size  )

static

Generates a default multiplexer architecture of given size and number of levels

Definition at line 525 of file power_util.c.

                                               {

    mux_arch->levels = levels;
    mux_arch->num_inputs = num_inputs;

    mux_arch_fix_levels(mux_arch);

    mux_arch->transistor_size = transistor_size;

    mux_arch->mux_graph_head = alloc_and_load_mux_graph(num_inputs,
            mux_arch->levels);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void int_2_binary_str ( char *  binary_str, int  value, int  str_length  )

static

This function converts an integer to a binary string

• binary_str: (Return value) The created binary string
• value: The integer value to convert
• str_length: The length of the binary string

Definition at line 252 of file power_util.c.

                                                                           {
    int i;
    int odd;

    binary_str[str_length] = '\0';

    for (i = str_length - 1; i >= 0; i--, value >>= 1) {
        odd = value % 2;
        if (odd == 0) {
            binary_str[i] = '0';
        } else {
            binary_str[i] = '1';
        }
    }
}

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

static void log_msg ( t_log *  log_ptr, char *  msg  )

static

Definition at line 142 of file power_util.c.

                                                 {
    int msg_idx;

    /* Check if this message is already in the log */
    for (msg_idx = 0; msg_idx < log_ptr->num_messages; msg_idx++) {
        if (strcmp(log_ptr->messages[msg_idx], msg) == 0) {
            return;
        }
    }

    if (log_ptr->num_messages <= MAX_LOGS) {
        log_ptr->num_messages++;
        log_ptr->messages = (char**) my_realloc(log_ptr->messages,
                log_ptr->num_messages * sizeof(char*));
    } else {
        /* Can't add any more messages */
        return;
    }

    if (log_ptr->num_messages == (MAX_LOGS + 1)) {
        const char * full_msg = "\n***LOG IS FULL***\n";
        log_ptr->messages[log_ptr->num_messages - 1] = (char*) my_calloc(
                strlen(full_msg) + 1, sizeof(char));
        strncpy(log_ptr->messages[log_ptr->num_messages - 1], full_msg,
                strlen(full_msg));
    } else {
        log_ptr->messages[log_ptr->num_messages - 1] = (char*) my_calloc(
                strlen(msg) + 1, sizeof(char));
        strncpy(log_ptr->messages[log_ptr->num_messages - 1], msg, strlen(msg));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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:

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:

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: