power_cmos_tech.h File Reference

#include "power.h"

Include dependency graph for power_cmos_tech.h:

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

Go to the source code of this file.

Functions
void	power_tech_init (char *cmos_tech_behavior_filepath)
boolean	power_find_transistor_info (t_transistor_size_inf **lower, t_transistor_size_inf **upper, e_tx_type type, float size)
void	power_find_mux_volt_inf (t_power_mux_volt_pair **lower, t_power_mux_volt_pair **upper, t_power_mux_volt_inf *volt_inf, float v_in)
void	power_find_nmos_leakage (t_power_nmos_leakage_inf *nmos_leakage_info, t_power_nmos_leakage_pair **lower, t_power_nmos_leakage_pair **upper, float v_ds)
void	power_find_buffer_strength_inf (t_power_buffer_strength_inf **lower, t_power_buffer_strength_inf **upper, t_power_buffer_size_inf *size_inf, float stage_gain)
void	power_find_buffer_sc_levr (t_power_buffer_sc_levr_inf **lower, t_power_buffer_sc_levr_inf **upper, t_power_buffer_strength_inf *buffer_sc, int input_mux_size)

Function Documentation

void power_find_buffer_sc_levr	(	t_power_buffer_sc_levr_inf **	lower,
		t_power_buffer_sc_levr_inf **	upper,
		t_power_buffer_strength_inf *	buffer_strength,
		int	input_mux_size
	)

This function searches for short-circuit current information for a level-restoring buffer, based on the size of the multiplexer driving the input

• lower: (Return value) The lower-bound matching record
• upper: (Return value) The upper-bound matching record
• buffer_strength: The set of records to search withing, which are for a specific buffer size/strength
• input_mux_size: The input mux size to search for

Definition at line 656 of file power_cmos_tech.c.

                                                                           {
    t_power_buffer_sc_levr_inf key;
    t_power_buffer_sc_levr_inf * found;
    char msg[1024];
    int max_size;

    assert(input_mux_size >= 1);

    key.mux_size = input_mux_size;

    g_buffer_strength_last_searched = buffer_strength;
    found = (t_power_buffer_sc_levr_inf*) bsearch(&key,
            buffer_strength->sc_levr_inf, buffer_strength->num_levr_entries,
            sizeof(t_power_buffer_sc_levr_inf), power_compare_buffer_sc_levr);

    max_size = buffer_strength->sc_levr_inf[buffer_strength->num_levr_entries
            - 1].mux_size;
    if (input_mux_size > max_size) {
        /* Input mux too large */
        assert(
                found
                        == &buffer_strength->sc_levr_inf[buffer_strength->num_levr_entries
                                - 1]);
        sprintf(msg,
                "Using buffer driven by mux of size '%d', which is larger than the largest modeled size (%d) in the technology behavior file.",
                input_mux_size, max_size);
        power_log_msg(POWER_LOG_WARNING, msg);
        *lower = found;
        *upper = NULL;
    } else {
        *lower = found;
        *upper = found + 1;
    }
}

Here is the call graph for this function:

void power_find_buffer_strength_inf	(	t_power_buffer_strength_inf **	lower,
		t_power_buffer_strength_inf **	upper,
		t_power_buffer_size_inf *	size_inf,
		float	stage_gain
	)

This function searches for the information for a given buffer strength.

• lower: (Return value) The lower-bound matching record
• upper: (Return value) The upper-bound matching record
• stage_gain: The buffer strength to search for

Definition at line 619 of file power_cmos_tech.c.

                                                              {
    t_power_buffer_strength_inf key;
    t_power_buffer_strength_inf * found;

    float min_size;
    float max_size;

    min_size = size_inf->strength_inf[0].stage_gain;
    max_size = size_inf->strength_inf[size_inf->num_strengths - 1].stage_gain;

    assert(stage_gain >= min_size && stage_gain <= max_size);

    key.stage_gain = stage_gain;

    found = (t_power_buffer_strength_inf*) bsearch(&key, size_inf->strength_inf,
            size_inf->num_strengths, sizeof(t_power_buffer_strength_inf),
            power_compare_buffer_strength);

    if (stage_gain == max_size) {
        *lower = found;
        *upper = NULL;
    } else {
        *lower = found;
        *upper = found + 1;
    }
}

Here is the call graph for this function:

void power_find_mux_volt_inf	(	t_power_mux_volt_pair **	lower,
		t_power_mux_volt_pair **	upper,
		t_power_mux_volt_inf *	volt_inf,
		float	v_in
	)

This function searches for multiplexer output voltage information, based on input voltage

• lower: (Return value) The lower-bound matching record
• upper: (Return value) The upper-bound matching record
• volt_inf: The set of records to search within, which are for a specific mux size
• v_in: The input voltage to search for

Definition at line 735 of file power_cmos_tech.c.

                    {
    t_power_mux_volt_pair key;
    t_power_mux_volt_pair * found;

    key.v_in = v_in;

    g_mux_volt_last_searched = volt_inf;
    found = (t_power_mux_volt_pair*) bsearch(&key, volt_inf->mux_voltage_pairs,
            volt_inf->num_voltage_pairs, sizeof(t_power_mux_volt_pair),
            power_compare_voltage_pair);
    assert(found);

    if (found
            == &volt_inf->mux_voltage_pairs[volt_inf->num_voltage_pairs - 1]) {
        *lower = found;
        *upper = NULL;
    } else {
        *lower = found;
        *upper = found + 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_find_nmos_leakage	(	t_power_nmos_leakage_inf *	nmos_leakage_info,
		t_power_nmos_leakage_pair **	lower,
		t_power_nmos_leakage_pair **	upper,
		float	v_ds
	)

Definition at line 585 of file power_cmos_tech.c.

                    {
    t_power_nmos_leakage_pair key;
    t_power_nmos_leakage_pair * found;

    key.v_ds = v_ds;

    g_power_searching_nmos_leakage_info = nmos_leakage_info;

    found = (t_power_nmos_leakage_pair*) bsearch(&key,
            nmos_leakage_info->leakage_pairs,
            nmos_leakage_info->num_leakage_pairs,
            sizeof(t_power_nmos_leakage_pair), power_compare_leakage_pair);
    assert(found);

    if (found
            == &nmos_leakage_info->leakage_pairs[nmos_leakage_info->num_leakage_pairs
                    - 1]) {
        /* The results equal to the max voltage (Vdd) */
        *lower = found;
        *upper = NULL;
    } else {
        *lower = found;
        *upper = found + 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean power_find_transistor_info	(	t_transistor_size_inf **	lower,
		t_transistor_size_inf **	upper,
		e_tx_type	type,
		float	size
	)

This function searches for a transistor by size

• lower: (Return value) The lower-bound matching transistor
• upper: (Return value) The upper-bound matching transistor
• type: The transistor type to search for
• size: The transistor size to search for (size = W/L)

Definition at line 509 of file power_cmos_tech.c.

                                                                    {
    char msg[1024];
    t_transistor_size_inf key;
    t_transistor_size_inf * found;
    t_transistor_inf * trans_info;
    float min_size, max_size;
    boolean error = FALSE;

    key.size = size;

    /* Find the appropriate global transistor records */
    trans_info = NULL;
    if (type == NMOS) {
        trans_info = &g_power_tech->NMOS_inf;
    } else if (type == PMOS) {
        trans_info = &g_power_tech->PMOS_inf;
    } else {
        assert(0);
    }

    /* No transistor data exists */
    if (trans_info->size_inf == NULL) {
        power_log_msg(POWER_LOG_ERROR,
                "No transistor information exists.  Cannot determine transistor properties.");
        error = TRUE;
        return error;
    }

    /* Make note of the transistor record we are searching in, and the bounds */
    g_transistor_last_searched = trans_info;
    min_size = trans_info->size_inf[0].size;
    max_size = trans_info->size_inf[trans_info->num_size_entries - 1].size;

    found = (t_transistor_size_inf*) bsearch(&key, trans_info->size_inf,
            trans_info->num_size_entries, sizeof(t_transistor_size_inf),
            &power_compare_transistor_size);
    assert(found);

    if (size < min_size) {
        /* Too small */
        assert(found == &trans_info->size_inf[0]);
        sprintf(msg,
                "Using %s transistor of size '%f', which is smaller than the smallest modeled transistor (%f) in the technology behavior file.",
                transistor_type_name(type), size, min_size);
        power_log_msg(POWER_LOG_WARNING, msg);
        *lower = NULL;
        *upper = found;
    } else if (size > max_size) {
        /* Too large */
        assert(
                found
                        == &trans_info->size_inf[trans_info->num_size_entries
                                - 1]);
        sprintf(msg,
                "Using %s transistor of size '%f', which is larger than the largest modeled transistor (%f) in the technology behavior file.",
                transistor_type_name(type), size, max_size);
        power_log_msg(POWER_LOG_WARNING, msg);
        *lower = found;
        *upper = NULL;
    } else {
        *lower = found;
        *upper = found + 1;
    }

    return error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void power_tech_init

(

char *

cmos_tech_behavior_filepath

)

This file provides functions relating to the cmos technology. It includes functions to read the transistor characteristics from the xml file into data structures, and functions to search within these data structures.

Definition at line 68 of file power_cmos_tech.c.

                                                         {
    power_tech_load_xml_file(cmos_tech_behavior_filepath);
}

Here is the call graph for this function:

Here is the caller graph for this function: