power_components.h File Reference

#include "power.h"

Include dependency graph for power_components.h:

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

Go to the source code of this file.

Data Structures
struct	s_power_breakdown

Macros
#define	POWER_LUT_SLOW

Typedefs
typedef struct s_power_breakdown	t_power_components

Enumerations
enum	e_power_component_type {   POWER_COMPONENT_IGNORE = 0, POWER_COMPONENT_TOTAL, POWER_COMPONENT_ROUTING, POWER_COMPONENT_ROUTE_SB,   POWER_COMPONENT_ROUTE_CB, POWER_COMPONENT_ROUTE_GLB_WIRE, POWER_COMPONENT_CLOCK, POWER_COMPONENT_CLOCK_BUFFER,   POWER_COMPONENT_CLOCK_WIRE, POWER_COMPONENT_PB, POWER_COMPONENT_PB_PRIMITIVES, POWER_COMPONENT_PB_INTERC_MUXES,   POWER_COMPONENT_PB_BUFS_WIRE, POWER_COMPONENT_PB_OTHER, POWER_COMPONENT_MAX_NUM }

Functions
void	power_components_init (void)
void	power_components_uninit (void)
void	power_component_get_usage (t_power_usage *power_usage, e_power_component_type component_idx)
void	power_component_add_usage (t_power_usage *power_usage, e_power_component_type component_idx)
float	power_component_get_usage_sum (e_power_component_type component_idx)
void	power_usage_ff (t_power_usage *power_usage, float size, float D_prob, float D_dens, float Q_prob, float Q_dens, float clk_prob, float clk_dens, float period)
void	power_usage_lut (t_power_usage *power_usage, int LUT_size, float transistor_size, char *SRAM_values, float *input_densities, float *input_probabilities, float period)
void	power_usage_local_interc_mux (t_power_usage *power_usage, t_pb *pb, t_interconnect_pins *interc_pins)
void	power_usage_mux_multilevel (t_power_usage *power_usage, t_mux_arch *mux_arch, float *in_prob, float *in_dens, int selected_input, boolean output_level_restored, float period)
void	power_usage_buffer (t_power_usage *power_usage, float size, float in_prob, float in_dens, boolean level_restored, float period)

Variables
t_power_components	g_power_by_component

Macro Definition Documentation

#define POWER_LUT_SLOW

This file offers functions to estimate power of major components within the FPGA (flip-flops, LUTs, interconnect structures, etc).

Definition at line 37 of file power_components.h.

Typedef Documentation

typedef struct s_power_breakdown t_power_components

Definition at line 67 of file power_components.h.

Enumeration Type Documentation

enum e_power_component_type

Enumerator
POWER_COMPONENT_IGNORE
POWER_COMPONENT_TOTAL
POWER_COMPONENT_ROUTING
POWER_COMPONENT_ROUTE_SB
POWER_COMPONENT_ROUTE_CB
POWER_COMPONENT_ROUTE_GLB_WIRE
POWER_COMPONENT_CLOCK
POWER_COMPONENT_CLOCK_BUFFER
POWER_COMPONENT_CLOCK_WIRE
POWER_COMPONENT_PB
POWER_COMPONENT_PB_PRIMITIVES
POWER_COMPONENT_PB_INTERC_MUXES
POWER_COMPONENT_PB_BUFS_WIRE
POWER_COMPONENT_PB_OTHER
POWER_COMPONENT_MAX_NUM

Definition at line 43 of file power_components.h.

             {
    POWER_COMPONENT_IGNORE = 0, /* */
    POWER_COMPONENT_TOTAL, /* Total power for entire FPGA */

    POWER_COMPONENT_ROUTING, /* Power for routing fabric (not local routing) */
    POWER_COMPONENT_ROUTE_SB, /* Switch-box */
    POWER_COMPONENT_ROUTE_CB, /* Connection box*/
    POWER_COMPONENT_ROUTE_GLB_WIRE, /* Wires */

    POWER_COMPONENT_CLOCK, /* Clock network */
    POWER_COMPONENT_CLOCK_BUFFER, /* Buffers in clock network */
    POWER_COMPONENT_CLOCK_WIRE, /* Wires in clock network */

    POWER_COMPONENT_PB, /* Logic Blocks, and other hard blocks */
    POWER_COMPONENT_PB_PRIMITIVES, /* Primitives (LUTs, FF, etc) */
    POWER_COMPONENT_PB_INTERC_MUXES, /* Local interconnect structures (muxes) */
    POWER_COMPONENT_PB_BUFS_WIRE, /* Local buffers and wire capacitance */

    POWER_COMPONENT_PB_OTHER, /* Power from other estimation methods - not transistor-level */

    POWER_COMPONENT_MAX_NUM
} e_power_component_type;

Function Documentation

void power_component_add_usage	(	t_power_usage *	power_usage,
		e_power_component_type	component_idx
	)

Adds power usage for a component to the global component tracker

• power_usage: Power usage to add
• component_idx: Type of component

Definition at line 74 of file power_components.c.

                                              {
    power_add_usage(&g_power_by_component.components[component_idx],
            power_usage);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_component_get_usage	(	t_power_usage *	power_usage,
		e_power_component_type	component_idx
	)

Gets power usage for a component

• power_usage: (Return value) Power usage for the given component
• component_idx: Type of component

Definition at line 85 of file power_components.c.

                                              {
    memcpy(power_usage, &g_power_by_component.components[component_idx],
            sizeof(t_power_usage));
}

float power_component_get_usage_sum

(

e_power_component_type

component_idx

)

Returns total power for a given component

• component_idx: Type of component

Definition at line 95 of file power_components.c.

                                                                          {
    return power_sum_usage(&g_power_by_component.components[component_idx]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_components_init

(

void

)

Module initializer function, called by power_init

Definition at line 52 of file power_components.c.

                                 {
    int i;

    g_power_by_component.components = (t_power_usage*) my_calloc(
            POWER_COMPONENT_MAX_NUM, sizeof(t_power_usage));
    for (i = 0; i < POWER_COMPONENT_MAX_NUM; i++) {
        power_zero_usage(&g_power_by_component.components[i]);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_components_uninit

(

void

)

Module un-initializer function, called by power_uninit

Definition at line 65 of file power_components.c.

                                   {
    free(g_power_by_component.components);
}

void power_usage_buffer	(	t_power_usage *	power_usage,
		float	size,
		float	in_prob,
		float	in_dens,
		boolean	level_restorer,
		float	period
	)

This function calculates the power of a multistage buffer

• power_usage: (Return value) Power usage of buffer
• size: The size of the final buffer stage, relative to min-sized inverter
• in_prob: The signal probability of the input
• in_dens: The transition density of the input
• level_restored: Whether this buffer must level restore the input
• input_mux_size: If fed by a mux, the size of this mutliplexer

Definition at line 633 of file power_components.c.

                                                             {
    t_power_usage sub_power_usage;
    int i, num_stages;
    float stage_effort;
    float stage_inv_size;
    float stage_in_prob;
    float input_dyn_power;
    float scale_factor;
    PowerSpicedComponent * callibration;

    power_zero_usage(power_usage);

    if (size == 0.) {
        return;
    }

    num_stages = power_calc_buffer_num_stages(size,
            g_power_arch->logical_effort_factor);
    stage_effort = calc_buffer_stage_effort(num_stages, size);

    stage_in_prob = in_prob;
    for (i = 0; i < num_stages; i++) {
        stage_inv_size = pow(stage_effort, i);

        if (i == 0) {
            if (level_restorer) {
                /* Sense Buffer */
                power_usage_level_restorer(&sub_power_usage, &input_dyn_power,
                        in_dens, stage_in_prob, period);
            } else {
                power_usage_inverter(&sub_power_usage, in_dens, stage_in_prob,
                        stage_inv_size, period);
            }
        } else {
            power_usage_inverter(&sub_power_usage, in_dens, stage_in_prob,
                    stage_inv_size, period);
        }
        power_add_usage(power_usage, &sub_power_usage);

        stage_in_prob = 1 - stage_in_prob;
    }

    /* Callibration */
    if (level_restorer) {
        callibration =
                g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR];
    } else {
        callibration =
                g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER];
    }

    if (callibration->is_done_callibration()) {
        scale_factor = callibration->scale_factor(1, size);
        power_scale_usage(power_usage, scale_factor);
    }

    /* Short-circuit: add a factor to dynamic power, but the factor is not in addition to the input power
     * Need to subtract input before adding factor - this matters for small buffers
     */
    /*power_usage->dynamic += (power_usage->dynamic - input_dyn_power)
     * power_calc_buffer_sc(num_stages, stage_effort, level_restorer,
     input_mux_size); */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_usage_ff	(	t_power_usage *	power_usage,
		float	size,
		float	D_prob,
		float	D_dens,
		float	Q_prob,
		float	Q_dens,
		float	clk_prob,
		float	clk_dens,
		float	period
	)

Calculates power of a D flip-flop

• power_usage: (Return value) power usage of the flip-flop
• D_prob: Signal probability of the input
• D_dens: Transition density of the input
• Q_prob: Signal probability of the output
• Q_dens: Transition density of the output
• clk_prob: Signal probability of the clock
• clk_dens: Transition density of the clock

Definition at line 109 of file power_components.c.

                                      {
    t_power_usage sub_power_usage;
    float mux_in_dens[2];
    float mux_in_prob[2];
    PowerSpicedComponent * callibration;
    float scale_factor;

    power_zero_usage(power_usage);

    /* DFF is build using a master loop and slave loop.
     * Each loop begins with a MUX and contains 2 inverters
     * in a feedback loop to the mux.
     * Each mux is built using two transmission gates.
     */

    /* Master */
    mux_in_dens[0] = D_dens;
    mux_in_dens[1] = (1 - clk_prob) * D_dens;
    mux_in_prob[0] = D_prob;
    mux_in_prob[1] = D_prob;
    power_usage_MUX2_transmission(&sub_power_usage, size, mux_in_dens,
            mux_in_prob, clk_dens, (1 - clk_prob) * D_dens, period);
    power_add_usage(power_usage, &sub_power_usage);

    power_usage_inverter(&sub_power_usage, (1 - clk_prob) * D_dens, D_prob,
            size, period);
    power_add_usage(power_usage, &sub_power_usage);

    power_usage_inverter(&sub_power_usage, (1 - clk_prob) * D_dens, 1 - D_prob,
            size, period);
    power_add_usage(power_usage, &sub_power_usage);

    /* Slave */
    mux_in_dens[0] = Q_dens;
    mux_in_dens[1] = (1 - clk_prob) * D_dens;
    mux_in_prob[0] = (1 - Q_prob);
    mux_in_prob[1] = (1 - D_prob);
    power_usage_MUX2_transmission(&sub_power_usage, size, mux_in_dens,
            mux_in_prob, clk_dens, Q_dens, period);
    power_add_usage(power_usage, &sub_power_usage);

    power_usage_inverter(&sub_power_usage, Q_dens, 1 - Q_prob, size, period);
    power_add_usage(power_usage, &sub_power_usage);

    power_usage_inverter(&sub_power_usage, Q_dens, Q_prob, size, period);
    power_add_usage(power_usage, &sub_power_usage);

    /* Callibration */
    callibration =
            g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF];
    if (callibration->is_done_callibration()) {
        scale_factor = callibration->scale_factor(1, size);
        power_scale_usage(power_usage, scale_factor);
    }

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_usage_local_interc_mux	(	t_power_usage *	power_usage,
		t_pb *	pb,
		t_interconnect_pins *	interc_pins
	)

This function calculates power of a local interconnect structure

• power_usage: (Return value) Power usage of the structure
• pb: The physical block to which this interconnect belongs
• interc_pins: The interconnect input/ouput pin information
• interc_length: The physical length spanned by the interconnect (meters)

Definition at line 404 of file power_components.c.

                                           {
    int pin_idx;
    int out_port_idx;
    int in_port_idx;
    float * in_dens;
    float * in_prob;
    t_power_usage MUX_power;
    t_interconnect * interc = interc_pins->interconnect;
    t_interconnect_power * interc_power = interc->interconnect_power;

    power_zero_usage(power_usage);

    /* Ensure port/pins are structured as expected */
    switch (interc_pins->interconnect->type) {
    case DIRECT_INTERC:
        assert(interc_power->num_input_ports == 1);
        assert(interc_power->num_output_ports == 1);
        break;
    case MUX_INTERC:
        assert(interc_power->num_output_ports == 1);
        break;
    case COMPLETE_INTERC:
        break;
    }

    /* Power of transistors to build interconnect structure */
    switch (interc_pins->interconnect->type) {
    case DIRECT_INTERC:
        /* Direct connections require no transistors */
        break;
    case MUX_INTERC:
    case COMPLETE_INTERC:
        /* Many-to-1, or Many-to-Many
         * Implemented as a multiplexer for each output
         * */
        in_dens = (float*) my_calloc(
                interc->interconnect_power->num_input_ports, sizeof(float));
        in_prob = (float*) my_calloc(
                interc->interconnect_power->num_input_ports, sizeof(float));

        for (out_port_idx = 0;
                out_port_idx < interc->interconnect_power->num_output_ports;
                out_port_idx++) {
            for (pin_idx = 0;
                    pin_idx < interc->interconnect_power->num_pins_per_port;
                    pin_idx++) {

                int selected_input = OPEN;

                /* Clear input densities */
                for (in_port_idx = 0;
                        in_port_idx
                                < interc->interconnect_power->num_input_ports;
                        in_port_idx++) {
                    in_dens[in_port_idx] = 0.;
                    in_prob[in_port_idx] = 0.;
                }

                /* Get probability/density of input signals */
                if (pb) {
                    int output_pin_net =
                            pb->rr_graph[interc_pins->output_pins[out_port_idx][pin_idx]->pin_count_in_cluster].net_num;

                    if (output_pin_net == OPEN) {
                        selected_input = 0;
                    } else {
                        for (in_port_idx = 0;
                                in_port_idx
                                        < interc->interconnect_power->num_input_ports;
                                in_port_idx++) {
                            t_pb_graph_pin * input_pin =
                                    interc_pins->input_pins[in_port_idx][pin_idx];
                            int input_pin_net =
                                    pb->rr_graph[input_pin->pin_count_in_cluster].net_num;

                            /* Find input pin that connects through the mux to the output pin */
                            if (output_pin_net == input_pin_net) {
                                selected_input = in_port_idx;
                            }

                            /* Initialize input densities */
                            if (input_pin_net != OPEN) {
                                in_dens[in_port_idx] = pin_dens(pb, input_pin);
                                in_prob[in_port_idx] = pin_prob(pb, input_pin);
                            }
                        }

                        /* Check that the input pin was found with a matching net to the output pin */
                        assert(selected_input != OPEN);
                    }
                } else {
                    selected_input = 0;
                }

                /* Calculate power of the multiplexer */
                power_usage_mux_multilevel(&MUX_power,
                        power_get_mux_arch(
                                interc_pins->interconnect->interconnect_power->num_input_ports,
                                g_power_arch->mux_transistor_size), in_prob,
                        in_dens, selected_input, TRUE, g_solution_inf.T_crit);

                power_add_usage(power_usage, &MUX_power);
            }
        }

        free(in_dens);
        free(in_prob);
        break;
    default:
        assert(0);
    }

    power_add_usage(&interc_pins->interconnect->interconnect_power->power_usage,
            power_usage);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_usage_lut	(	t_power_usage *	power_usage,
		int	lut_size,
		float	transistor_size,
		char *	SRAM_values,
		float *	input_prob,
		float *	input_dens,
		float	period
	)

Calculated power of a look-up table (LUT)

• power_usage: (Return value) The power usage of the LUT
• LUT_size: Number of LUT inputs
• SRAM_values: The 2^(LUT_size) truth table values. String of '0' and '1' characters. First characters is for all inputs = 0 and last characters is for all inputs = 1.
• input_prob: Array of input signal probabilities
• input_dens: Array of input transition densities

NOTE: The following provides a diagram of a 3-LUT, the sram bit ordering, and the input array ordering.

X - NMOS gate controlled by complement of input Z - NMOS gate controlled by input

S R I I I A N N N M 2 1 0 | | | | v v | | v | 0 X | |_X_ v 1 Z| | |_X_ 2 X | | |_Z_| | 3 Z| | |---— out 4 X | |_X_ | 5 Z| | | |_Z_| 6 X | |_Z_| 7 Z|

Definition at line 208 of file power_components.c.

                                          {
    float **internal_prob;
    float **internal_dens;
    float **internal_v;
    int i;
    int level_idx;
    PowerSpicedComponent * callibration;
    float scale_factor;

    int num_SRAM_bits;

    boolean level_restorer_this_level = FALSE;

    power_zero_usage(power_usage);

    num_SRAM_bits = 1 << lut_size;

    /* Initialize internal node data */
    internal_prob = (float**) my_calloc(lut_size + 1, sizeof(float*));
    internal_dens = (float**) my_calloc(lut_size + 1, sizeof(float*));
    internal_v = (float**) my_calloc(lut_size + 1, sizeof(float*));
    for (i = 0; i <= lut_size; i++) {
        internal_prob[i] = (float*) my_calloc(1 << (lut_size - i),
                sizeof(float));
        internal_dens[i] = (float*) my_calloc(1 << (lut_size - i),
                sizeof(float));
        internal_v[i] = (float*) my_calloc(1 << (lut_size - i), sizeof(float));
    }

    /* Initialize internal probabilities/densities from SRAM bits */
    for (i = 0; i < num_SRAM_bits; i++) {
        if (SRAM_values[i] == '0') {
            internal_prob[0][i] = 0.;
        } else {
            internal_prob[0][i] = 1.;
        }
        internal_dens[0][i] = 0.;
        internal_v[0][i] = g_power_tech->Vdd;
    }

    for (level_idx = 0; level_idx < lut_size; level_idx++) {
        t_power_usage driver_power_usage;
        int MUXs_this_level;
        int MUX_idx;
        int reverse_idx = lut_size - level_idx - 1;

        MUXs_this_level = 1 << (reverse_idx);

        /* Power of input drivers */
        power_usage_inverter(&driver_power_usage, input_dens[reverse_idx],
                input_prob[reverse_idx], 1.0, period);
        power_add_usage(power_usage, &driver_power_usage);

        power_usage_inverter(&driver_power_usage, input_dens[reverse_idx],
                input_prob[reverse_idx], 2.0, period);
        power_add_usage(power_usage, &driver_power_usage);

        power_usage_inverter(&driver_power_usage, input_dens[reverse_idx],
                1 - input_prob[reverse_idx], 2.0, period);
        power_add_usage(power_usage, &driver_power_usage);

        /* Add level restorer after every 2 stages (level_idx %2 == 1)
         * But if there is an odd # of stages, just put one at the last
         * stage (level_idx == LUT_size - 1) and not at the stage just before
         * the last stage (level_idx != LUT_size - 2)
         */
        if (((level_idx % 2 == 1) && (level_idx != lut_size - 2))
                || (level_idx == lut_size - 1)) {
            level_restorer_this_level = TRUE;
        } else {
            level_restorer_this_level = FALSE;
        }

        /* Loop through the 2-muxs at each level */
        for (MUX_idx = 0; MUX_idx < MUXs_this_level; MUX_idx++) {
            t_power_usage sub_power;
            float out_prob;
            float out_dens;
            float sum_prob = 0;
            int sram_offset = MUX_idx * ipow(2, level_idx + 1);
            int sram_per_branch = ipow(2, level_idx);
            int branch_lvl_idx;
            int sram_idx;
            float v_out;

            /* Calculate output probability of multiplexer */
            out_prob = internal_prob[level_idx][MUX_idx * 2]
                    * (1 - input_prob[reverse_idx])
                    + internal_prob[level_idx][MUX_idx * 2 + 1]
                            * input_prob[reverse_idx];

            /* Calculate output density of multiplexer */
            out_dens = internal_dens[level_idx][MUX_idx * 2]
                    * (1 - input_prob[reverse_idx])
                    + internal_dens[level_idx][MUX_idx * 2 + 1]
                            * input_prob[reverse_idx];

#ifdef POWER_LUT_FAST
            out_dens += ((1 - internal_prob[level_idx][MUX_idx * 2]) * internal_prob[level_idx][MUX_idx * 2 + 1]
                    + internal_prob[level_idx][MUX_idx * 2] * (1 - internal_prob[level_idx][MUX_idx * 2 + 1]))
            * input_dens[reverse_idx];
#elif defined(POWER_LUT_SLOW)
            for (sram_idx = sram_offset;
                    sram_idx < sram_offset + sram_per_branch; sram_idx++) {
                float branch_prob = 1.;
                if (SRAM_values[sram_idx]
                        == SRAM_values[sram_idx + sram_per_branch]) {
                    continue;
                }
                for (branch_lvl_idx = 0; branch_lvl_idx < level_idx;
                        branch_lvl_idx++) {
                    int branch_lvl_reverse_idx = lut_size - branch_lvl_idx - 1;
                    int even_odd = sram_idx / ipow(2, branch_lvl_idx);
                    if (even_odd % 2 == 0) {
                        branch_prob *= (1 - input_prob[branch_lvl_reverse_idx]);
                    } else {
                        branch_prob *= input_prob[branch_lvl_reverse_idx];
                    }
                }
                sum_prob += branch_prob;
            }
            out_dens += sum_prob * input_dens[reverse_idx];
#endif

            /* Calculate output voltage of multiplexer */
            if (level_restorer_this_level) {
                v_out = g_power_tech->Vdd;
            } else {
                v_out = (1 - input_prob[reverse_idx])
                        * power_calc_mux_v_out(2, 1.0,
                                internal_v[level_idx][MUX_idx * 2],
                                internal_prob[level_idx][MUX_idx * 2 + 1])
                        + input_prob[reverse_idx]
                                * power_calc_mux_v_out(2, 1.0,
                                        internal_v[level_idx][MUX_idx * 2 + 1],
                                        internal_prob[level_idx][MUX_idx * 2]);
            }

            /* Save internal node info */
            internal_dens[level_idx + 1][MUX_idx] = out_dens;
            internal_prob[level_idx + 1][MUX_idx] = out_prob;
            internal_v[level_idx + 1][MUX_idx] = v_out;

            /* Calculate power of the 2-mux */
            power_usage_mux_singlelevel_dynamic(&sub_power, 2,
                    internal_dens[level_idx + 1][MUX_idx],
                    internal_v[level_idx + 1][MUX_idx],
                    &internal_prob[level_idx][MUX_idx * 2],
                    &internal_dens[level_idx][MUX_idx * 2],
                    &internal_v[level_idx][MUX_idx * 2],
                    input_dens[reverse_idx], input_prob[reverse_idx],
                    transistor_size, period);
            power_add_usage(power_usage, &sub_power);

            /* Add the level-restoring buffer if necessary */
            if (level_restorer_this_level) {
                /* Level restorer */
                power_usage_buffer(&sub_power, 1,
                        internal_prob[level_idx + 1][MUX_idx],
                        internal_dens[level_idx + 1][MUX_idx], TRUE, period);
                power_add_usage(power_usage, &sub_power);
            }
        }

    }

    /* Free allocated memory */
    for (i = 0; i <= lut_size; i++) {
        free(internal_prob[i]);
        free(internal_dens[i]);
        free(internal_v[i]);
    }
    free(internal_prob);
    free(internal_dens);
    free(internal_v);

    /* Callibration */
    callibration =
            g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT];
    if (callibration->is_done_callibration()) {
        scale_factor = callibration->scale_factor(lut_size, transistor_size);
        power_scale_usage(power_usage, scale_factor);
    }

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_usage_mux_multilevel	(	t_power_usage *	power_usage,
		t_mux_arch *	mux_arch,
		float *	in_prob,
		float *	in_dens,
		int	selected_input,
		boolean	output_level_restored,
		float	period
	)

This calculates the power of a multilevel multiplexer, with static inputs

• power_usage: (Return value) The power usage of the multiplexer
• mux_arch: The information on the multiplexer architecture
• in_prob: Array of input signal probabilities
• in_dens: Array of input transition densitites
• selected_input: The index of the input that has been statically selected
• output_level_restored: Whether the output is level restored to Vdd.

Definition at line 530 of file power_components.c.

                                                                         {
    float output_density;
    float output_prob;
    float V_out;
    boolean found;
    PowerSpicedComponent * callibration;
    float scale_factor;
    int * selector_values = (int*) my_calloc(mux_arch->levels, sizeof(int));

    assert(selected_input != OPEN);

    power_zero_usage(power_usage);

    /* Find selection index at each level */
    found = mux_find_selector_values(selector_values, mux_arch->mux_graph_head,
            selected_input);

    assert(found);

    /* Calculate power of the multiplexor stages, from final stage, to first stages */
    power_usage_mux_rec(power_usage, &output_density, &output_prob, &V_out,
            mux_arch->mux_graph_head, mux_arch, selector_values, in_prob,
            in_dens, output_level_restored, period);

    free(selector_values);

    callibration =
            g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX];
    if (callibration->is_done_callibration()) {
        scale_factor = callibration->scale_factor(mux_arch->num_inputs,
                mux_arch->transistor_size);
        power_scale_usage(power_usage, scale_factor);
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

t_power_components g_power_by_component

Definition at line 38 of file power_components.c.