power_cmos_tech.c

Go to the documentation of this file.

/*********************************************************************
 *  The following code is part of the power modelling feature of VTR.
 *
 * For support:
 * http://code.google.com/p/vtr-verilog-to-routing/wiki/Power
 *
 * or email:
 * vtr.power.estimation@gmail.com
 *
 * If you are using power estimation for your researach please cite:
 *
 * Jeffrey Goeders and Steven Wilton.  VersaPower: Power Estimation
 * for Diverse FPGA Architectures.  In International Conference on
 * Field Programmable Technology, 2012.
 *
 ********************************************************************/

/**
 * 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.
 */

/************************* INCLUDES *********************************/
#include <cstring>
using namespace std;

#include <assert.h>

#include "power_cmos_tech.h"
#include "power.h"
#include "power_util.h"
#include "ezxml.h"
#include "util.h"
#include "read_xml_util.h"
#include "PowerSpicedComponent.h"
#include "power_callibrate.h"

/************************* GLOBALS **********************************/
static t_transistor_inf * g_transistor_last_searched;
static t_power_buffer_strength_inf * g_buffer_strength_last_searched;
static t_power_mux_volt_inf * g_mux_volt_last_searched;

/************************* FUNCTION DECLARATIONS ********************/

static void power_tech_load_xml_file(char * cmos_tech_behavior_filepath);
static void process_tech_xml_load_transistor_info(ezxml_t parent);
static void power_tech_xml_load_multiplexer_info(ezxml_t parent);
static void power_tech_xml_load_nmos_st_leakages(ezxml_t parent);
static int power_compare_transistor_size(const void * key_void,
        const void * elem_void);
static int power_compare_voltage_pair(const void * key_void,
        const void * elem_void);
static int power_compare_leakage_pair(const void * key_void,
        const void * elem_void);
//static void power_tech_xml_load_sc(ezxml_t parent);
static int power_compare_buffer_strength(const void * key_void,
        const void * elem_void);
static int power_compare_buffer_sc_levr(const void * key_void,
        const void * elem_void);
static void power_tech_xml_load_components(ezxml_t parent);
static void power_tech_xml_load_component(ezxml_t parent,
        PowerSpicedComponent ** component, char * name,
        float (*usage_fn)(int num_inputs, float transistor_size));
/************************* FUNCTION DEFINITIONS *********************/

void power_tech_init(char * cmos_tech_behavior_filepath) {
    power_tech_load_xml_file(cmos_tech_behavior_filepath);
}

/**
 * Reads the transistor properties from the .xml file
 */
void power_tech_load_xml_file(char * cmos_tech_behavior_filepath) {
    ezxml_t cur, child, prev;
    const char * prop;
    char msg[BUFSIZE];

    if (!file_exists(cmos_tech_behavior_filepath)) {
        /* .xml transistor characteristics is missing */
        sprintf(msg,
                "The CMOS technology behavior file ('%s') does not exist.  No power information will be calculated.",
                cmos_tech_behavior_filepath);
        power_log_msg(POWER_LOG_ERROR, msg);

        g_power_tech->NMOS_inf.num_size_entries = 0;
        g_power_tech->NMOS_inf.long_trans_inf = NULL;
        g_power_tech->NMOS_inf.size_inf = NULL;

        g_power_tech->PMOS_inf.num_size_entries = 0;
        g_power_tech->PMOS_inf.long_trans_inf = NULL;
        g_power_tech->PMOS_inf.size_inf = NULL;

        g_power_tech->Vdd = 0.;
        g_power_tech->temperature = 85;
        g_power_tech->PN_ratio = 1.;
        return;
    }
    cur = ezxml_parse_file(cmos_tech_behavior_filepath);

    prop = FindProperty(cur, "file", TRUE);
    ezxml_set_attr(cur, "file", NULL);

    prop = FindProperty(cur, "size", TRUE);
    g_power_tech->tech_size = atof(prop);
    ezxml_set_attr(cur, "size", NULL);

    child = FindElement(cur, "operating_point", TRUE);
    g_power_tech->temperature = GetFloatProperty(child, "temperature", TRUE, 0);
    g_power_tech->Vdd = GetFloatProperty(child, "Vdd", TRUE, 0);
    FreeNode(child);

    child = FindElement(cur, "p_to_n", TRUE);
    g_power_tech->PN_ratio = GetFloatProperty(child, "ratio", TRUE, 0);
    FreeNode(child);

    /* Transistor Information */
    child = FindFirstElement(cur, "transistor", TRUE);
    process_tech_xml_load_transistor_info(child);

    prev = child;
    child = child->next;
    FreeNode(prev);

    process_tech_xml_load_transistor_info(child);
    FreeNode(child);

    /* Multiplexer Voltage Information */
    child = FindElement(cur, "multiplexers", TRUE);
    power_tech_xml_load_multiplexer_info(child);
    FreeNode(child);

    /* Vds Leakage Information */
    child = FindElement(cur, "nmos_leakages", TRUE);
    power_tech_xml_load_nmos_st_leakages(child);
    FreeNode(child);

    /* Buffer SC Info */
    /*
     child = FindElement(cur, "buffer_sc", TRUE);
     power_tech_xml_load_sc(child);
     FreeNode(child);
     */

    /* Components */
    child = FindElement(cur, "components", TRUE);
    power_tech_xml_load_components(child);
    FreeNode(child);

    FreeNode(cur);
}

static void power_tech_xml_load_component(ezxml_t parent,
        PowerSpicedComponent ** component, char * name,
        float (*usage_fn)(int num_inputs, float transistor_size)) {
    ezxml_t cur, child, gc, prev;

    *component = new PowerSpicedComponent(usage_fn);

    cur = FindElement(parent, name, TRUE);

    child = FindFirstElement(cur, "inputs", TRUE);
    while (child) {
        int num_inputs = GetIntProperty(child, "num_inputs", TRUE, 0);

        gc = FindFirstElement(child, "size", TRUE);
        while (gc) {
            float transistor_size = GetFloatProperty(gc, "transistor_size",
                    TRUE, 0.);
            float power = GetFloatProperty(gc, "power", TRUE, 0.);
            (*component)->add_data_point(num_inputs, transistor_size, power);

            prev = gc;
            gc = gc->next;
            FreeNode(prev);
        }
        prev = child;
        child = child->next;
        FreeNode(prev);
    }
    FreeNode(cur);
}

static void power_tech_xml_load_components(ezxml_t parent) {

    g_power_commonly_used->component_callibration =
            (PowerSpicedComponent**) my_calloc(POWER_CALLIB_COMPONENT_MAX,
                    sizeof(PowerSpicedComponent*));

    power_tech_xml_load_component(parent,
            &g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER],
            "buf", power_usage_buf_for_callibration);

    power_tech_xml_load_component(parent,
            &g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR],
            "buf_levr", power_usage_buf_levr_for_callibration);

    power_tech_xml_load_component(parent,
            &g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF],
            "dff", power_usage_ff_for_callibration);

    power_tech_xml_load_component(parent,
            &g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX],
            "mux", power_usage_mux_for_callibration);

    power_tech_xml_load_component(parent,
            &g_power_commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT],
            "lut", power_usage_lut_for_callibration);

}

/**
 * Read short-circuit buffer information from the transistor .xml file.
 * This contains values for buffers of various 1) # Stages 2) Stage strength 3) Input type & capacitance
 */
#if 0
static void power_tech_xml_load_sc(ezxml_t parent) {
    ezxml_t child, prev, gc, ggc;
    int i, j, k;
    int num_buffer_sizes;

    /* Information for buffers, based on # of stages in buffer */
    num_buffer_sizes = CountChildren(parent, "stages", 1);
    g_power_tech->max_buffer_size = num_buffer_sizes; /* buffer size starts at 1, not 0 */
    g_power_tech->buffer_size_inf = (t_power_buffer_size_inf*) my_calloc(
            g_power_tech->max_buffer_size + 1, sizeof(t_power_buffer_size_inf));

    child = FindFirstElement(parent, "stages", TRUE);
    i = 1;
    while (child) {
        t_power_buffer_size_inf * size_inf = &g_power_tech->buffer_size_inf[i];

        GetIntProperty(child, "num_stages", TRUE, 1);

        /* For the given # of stages, find the records for the strength of each stage */
        size_inf->num_strengths = CountChildren(child, "strength", 1);
        size_inf->strength_inf = (t_power_buffer_strength_inf*) my_calloc(
                size_inf->num_strengths, sizeof(t_power_buffer_strength_inf));

        gc = FindFirstElement(child, "strength", TRUE);
        j = 0;
        while (gc) {
            t_power_buffer_strength_inf * strength_inf =
            &size_inf->strength_inf[j];

            /* Get the short circuit factor for a buffer with no level restorer at the input */
            strength_inf->stage_gain = GetFloatProperty(gc, "gain", TRUE, 0.0);
            strength_inf->sc_no_levr = GetFloatProperty(gc, "sc_nolevr", TRUE,
                    0.0);

            /* Get the short circuit factor for buffers with level restorers at the input */
            strength_inf->num_levr_entries = CountChildren(gc, "input_cap", 1);
            strength_inf->sc_levr_inf = (t_power_buffer_sc_levr_inf*) my_calloc(
                    strength_inf->num_levr_entries,
                    sizeof(t_power_buffer_sc_levr_inf));

            ggc = FindFirstElement(gc, "input_cap", TRUE);
            k = 0;
            while (ggc) {
                t_power_buffer_sc_levr_inf * levr_inf =
                &strength_inf->sc_levr_inf[k];

                /* Short circuit factor is depdent on size of mux that drives the buffer */
                levr_inf->mux_size = GetIntProperty(ggc, "mux_size", TRUE, 0);
                levr_inf->sc_levr = GetFloatProperty(ggc, "sc_levr", TRUE, 0.0);

                prev = ggc;
                ggc = ggc->next;
                FreeNode(prev);
                k++;
            }

            prev = gc;
            gc = gc->next;
            FreeNode(prev);
            j++;
        }

        prev = child;
        child = child->next;
        FreeNode(prev);
        i++;
    }
}
#endif

/**
 *  Read NMOS subthreshold leakage currents from the .xml transistor characteristics
 *  This builds a table of (Vds,Ids) value pairs
 *  */
static void power_tech_xml_load_nmos_st_leakages(ezxml_t parent) {
    ezxml_t me, child, prev;
    int num_nmos_sizes;
    int num_leakage_pairs;
    int i;
    int nmos_idx;

    num_nmos_sizes = CountChildren(parent, "nmos", 1);
    g_power_tech->num_nmos_leakage_info = num_nmos_sizes;
    g_power_tech->nmos_leakage_info = (t_power_nmos_leakage_inf*) my_calloc(
            num_nmos_sizes, sizeof(t_power_nmos_leakage_inf));

    me = FindFirstElement(parent, "nmos", TRUE);
    nmos_idx = 0;
    while (me) {
        t_power_nmos_leakage_inf * nmos_info =
                &g_power_tech->nmos_leakage_info[nmos_idx];
        nmos_info->nmos_size = GetFloatProperty(me, "size", TRUE, 0.);

        num_leakage_pairs = CountChildren(me, "nmos_leakage", 1);
        nmos_info->num_leakage_pairs = num_leakage_pairs;
        nmos_info->leakage_pairs = (t_power_nmos_leakage_pair*) my_calloc(
                num_leakage_pairs, sizeof(t_power_nmos_leakage_pair));

        child = FindFirstElement(me, "nmos_leakage", TRUE);
        i = 0;
        while (child) {
            nmos_info->leakage_pairs[i].v_ds = GetFloatProperty(child, "Vds",
                    TRUE, 0.0);
            nmos_info->leakage_pairs[i].i_ds = GetFloatProperty(child, "Ids",
                    TRUE, 0.0);

            prev = child;
            child = child->next;
            FreeNode(prev);
            i++;
        }

        prev = me;
        me = me->next;
        FreeNode(prev);
        nmos_idx++;
    }

}

/**
 *  Read multiplexer information from the .xml transistor characteristics.
 *  This contains the estimates of mux output voltages, depending on 1) Mux Size 2) Mux Vin
 *  */
static void power_tech_xml_load_multiplexer_info(ezxml_t parent) {
    ezxml_t me, child, prev, gc;
    int num_nmos_sizes;
    int num_mux_sizes;
    int i, j, nmos_idx;

    /* Process all nmos sizes */
    num_nmos_sizes = CountChildren(parent, "nmos", 1);
    g_power_tech->num_nmos_mux_info = num_nmos_sizes;
    g_power_tech->nmos_mux_info = (t_power_nmos_mux_inf*) my_calloc(
            num_nmos_sizes, sizeof(t_power_nmos_mux_inf));

    me = FindFirstElement(parent, "nmos", TRUE);
    nmos_idx = 0;
    while (me) {
        t_power_nmos_mux_inf * nmos_inf = &g_power_tech->nmos_mux_info[nmos_idx];
        nmos_inf->nmos_size = GetFloatProperty(me, "size", TRUE, 0.0);
//      ezxml_set_attr(me, "size", NULL);

        /* Process all multiplexer sizes */
        num_mux_sizes = CountChildren(me, "multiplexer", 1);

        /* Add entries for 0 and 1, for convenience, although
         * they will never be used
         */
        nmos_inf->max_mux_sl_size = 1 + num_mux_sizes;
        nmos_inf->mux_voltage_inf = (t_power_mux_volt_inf*) my_calloc(
                nmos_inf->max_mux_sl_size + 1, sizeof(t_power_mux_volt_inf));

        child = FindFirstElement(me, "multiplexer", TRUE);
        i = 1;
        while (child) {
            int num_voltages;

            assert(i == GetFloatProperty(child, "size", TRUE, 0));

            /* For each mux size, process all of the Vin levels */
            num_voltages = CountChildren(child, "voltages", 1);

            nmos_inf->mux_voltage_inf[i].num_voltage_pairs = num_voltages;
            nmos_inf->mux_voltage_inf[i].mux_voltage_pairs =
                    (t_power_mux_volt_pair*) my_calloc(num_voltages,
                            sizeof(t_power_mux_volt_pair));

            gc = FindFirstElement(child, "voltages", TRUE);
            j = 0;
            while (gc) {
                /* For each mux size, and Vin level, get the min/max V_out */
                nmos_inf->mux_voltage_inf[i].mux_voltage_pairs[j].v_in =
                        GetFloatProperty(gc, "in", TRUE, 0.0);
                nmos_inf->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_min =
                        GetFloatProperty(gc, "out_min", TRUE, 0.0);
                nmos_inf->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_max =
                        GetFloatProperty(gc, "out_max", TRUE, 0.0);

                prev = gc;
                gc = gc->next;
                FreeNode(prev);
                j++;
            }

            prev = child;
            child = child->next;
            FreeNode(prev);
            i++;
        }

        prev = me;
        me = me->next;
        FreeNode(prev);
        nmos_idx++;
    }

}

/**
 * Read the transistor information from the .xml transistor characteristics.
 * For each transistor size, it extracts the:
 * - transistor node capacitances
 * - subthreshold leakage
 * - gate leakage
 */
static void process_tech_xml_load_transistor_info(ezxml_t parent) {
    t_transistor_inf * trans_inf;
    const char * prop;
    ezxml_t child, prev, grandchild;
    int i;

    /* Get transistor type: NMOS or PMOS */
    prop = FindProperty(parent, "type", TRUE);
    trans_inf = NULL;
    if (strcmp(prop, "nmos") == 0) {
        trans_inf = &g_power_tech->NMOS_inf;
    } else if (strcmp(prop, "pmos") == 0) {
        trans_inf = &g_power_tech->PMOS_inf;
    } else {
        assert(0);
    }
    ezxml_set_attr(parent, "type", NULL);

    /* Get long transistor information (W=1,L=2) */
    trans_inf->long_trans_inf = (t_transistor_size_inf*) my_malloc(
            sizeof(t_transistor_size_inf));

    child = FindElement(parent, "long_size", TRUE);
    assert(GetIntProperty(child, "L", TRUE, 0) == 2);
    trans_inf->long_trans_inf->size = GetFloatProperty(child, "W", TRUE, 0);

    grandchild = FindElement(child, "leakage_current", TRUE);
    trans_inf->long_trans_inf->leakage_subthreshold = GetFloatProperty(
            grandchild, "subthreshold", TRUE, 0);
    FreeNode(grandchild);

    grandchild = FindElement(child, "capacitance", TRUE);
    trans_inf->long_trans_inf->C_g = GetFloatProperty(grandchild, "C_g", TRUE,
            0);
    trans_inf->long_trans_inf->C_d = GetFloatProperty(grandchild, "C_d", TRUE,
            0);
    trans_inf->long_trans_inf->C_s = GetFloatProperty(grandchild, "C_s", TRUE,
            0);
    FreeNode(grandchild);

    /* Process all transistor sizes */
    trans_inf->num_size_entries = CountChildren(parent, "size", 1);
    trans_inf->size_inf = (t_transistor_size_inf*) my_calloc(
            trans_inf->num_size_entries, sizeof(t_transistor_size_inf));
    FreeNode(child);

    child = FindFirstElement(parent, "size", TRUE);
    i = 0;
    while (child) {
        assert(GetIntProperty(child, "L", TRUE, 0) == 1);

        trans_inf->size_inf[i].size = GetFloatProperty(child, "W", TRUE, 0);

        /* Get leakage currents */
        grandchild = FindElement(child, "leakage_current", TRUE);
        trans_inf->size_inf[i].leakage_subthreshold = GetFloatProperty(
                grandchild, "subthreshold", TRUE, 0);
        trans_inf->size_inf[i].leakage_gate = GetFloatProperty(grandchild,
                "gate", TRUE, 0);
        FreeNode(grandchild);

        /* Get node capacitances */
        grandchild = FindElement(child, "capacitance", TRUE);
        trans_inf->size_inf[i].C_g = GetFloatProperty(grandchild, "C_g", TRUE,
                0);
        trans_inf->size_inf[i].C_s = GetFloatProperty(grandchild, "C_s", TRUE,
                0);
        trans_inf->size_inf[i].C_d = GetFloatProperty(grandchild, "C_d", TRUE,
                0);
        FreeNode(grandchild);

        prev = child;
        child = child->next;
        FreeNode(prev);
        i++;
    }
}

/**
 * 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)
 */
boolean power_find_transistor_info(t_transistor_size_inf ** lower,
        t_transistor_size_inf ** upper, e_tx_type type, float size) {
    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;
}

/**
 * This function searches for the Ids leakage current, based on a given Vds.
 * This function is used for minimum-sized NMOS transistors (used in muxs).
 * - lower: (Return value) The lower-bound matching V/I pair
 * - upper: (Return value) The upper-bound matching V/I pair
 * - v_ds: The drain/source voltage to search for
 */
t_power_nmos_leakage_inf * g_power_searching_nmos_leakage_info;
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) {
    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;
    }
}

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

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

/**
 * Comparison function, used by power_find_nmos_leakage
 */
static int power_compare_leakage_pair(const void * key_void,
        const void * elem_void) {
    const t_power_nmos_leakage_pair * key =
            (const t_power_nmos_leakage_pair*) key_void;
    const t_power_nmos_leakage_pair * elem =
            (const t_power_nmos_leakage_pair*) elem_void;
    const t_power_nmos_leakage_pair * next =
            (const t_power_nmos_leakage_pair*) elem + 1;

    /* Compare against last? */
    if (elem
            == &g_power_searching_nmos_leakage_info->leakage_pairs[g_power_searching_nmos_leakage_info->num_leakage_pairs
                    - 1]) {
        if (key->v_ds >= elem->v_ds) {
            return 0;
        } else {
            return -1;
        }
    }

    /* Check for exact match to Vdd (upper end) */
    if (key->v_ds == elem->v_ds) {
        return 0;
    } else if (key->v_ds < elem->v_ds) {
        return -1;
    } else if (key->v_ds > next->v_ds) {
        return 1;
    } else {
        return 0;
    }
}

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

/**
 * Comparison function, used by power_find_buffer_sc_levr
 */
static int power_compare_buffer_sc_levr(const void * key_void,
        const void * elem_void) {
    const t_power_buffer_sc_levr_inf * key =
            (const t_power_buffer_sc_levr_inf*) key_void;
    const t_power_buffer_sc_levr_inf * elem =
            (const t_power_buffer_sc_levr_inf*) elem_void;
    const t_power_buffer_sc_levr_inf * next;

    /* Compare against last? */
    if (elem
            == &g_buffer_strength_last_searched->sc_levr_inf[g_buffer_strength_last_searched->num_levr_entries
                    - 1]) {
        if (key->mux_size >= elem->mux_size) {
            return 0;
        } else {
            return -1;
        }
    }

    /* Compare against first? */
    if (elem == &g_buffer_strength_last_searched->sc_levr_inf[0]) {
        if (key->mux_size < elem->mux_size) {
            return 0;
        }
    }

    /* Check if the key is between elem and the next element */
    next = elem + 1;
    if (key->mux_size > next->mux_size) {
        return 1;
    } else if (key->mux_size < elem->mux_size) {
        return -1;
    } else {
        return 0;
    }
}

/**
 * Comparison function, used by power_find_buffer_strength_inf
 */
static int power_compare_buffer_strength(const void * key_void,
        const void * elem_void) {
    const t_power_buffer_strength_inf * key =
            (const t_power_buffer_strength_inf*) key_void;
    const t_power_buffer_strength_inf * elem =
            (const t_power_buffer_strength_inf*) elem_void;
    const t_power_buffer_strength_inf * next =
            (const t_power_buffer_strength_inf*) elem + 1;

    /* Check for exact match */
    if (key->stage_gain == elem->stage_gain) {
        return 0;
    } else if (key->stage_gain < elem->stage_gain) {
        return -1;
    } else if (key->stage_gain > next->stage_gain) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * Comparison function, used by power_find_transistor_info
 */
static int power_compare_transistor_size(const void * key_void,
        const void * elem_void) {
    const t_transistor_size_inf * key = (const t_transistor_size_inf*) key_void;
    const t_transistor_size_inf * elem =
            (const t_transistor_size_inf*) elem_void;
    const t_transistor_size_inf * next;

    /* Check if we are comparing against the last element */
    if (elem
            == &g_transistor_last_searched->size_inf[g_transistor_last_searched->num_size_entries
                    - 1]) {
        /* Match if the desired value is larger than the largest item in the list */
        if (key->size >= elem->size) {
            return 0;
        } else {
            return -1;
        }
    }

    /* Check if we are comparing against the first element */
    if (elem == &g_transistor_last_searched->size_inf[0]) {
        /* Match the smallest if it is smaller than the smallest */
        if (key->size < elem->size) {
            return 0;
        }
    }

    /* Check if the key is between elem and the next element */
    next = elem + 1;
    if (key->size > next->size) {
        return 1;
    } else if (key->size < elem->size) {
        return -1;
    } else {
        return 0;
    }

}

/**
 * Comparison function, used by power_find_mux_volt_inf
 */
static int power_compare_voltage_pair(const void * key_void,
        const void * elem_void) {
    const t_power_mux_volt_pair * key = (const t_power_mux_volt_pair *) key_void;
    const t_power_mux_volt_pair * elem =
            (const t_power_mux_volt_pair *) elem_void;
    const t_power_mux_volt_pair * next = (const t_power_mux_volt_pair *) elem
            + 1;

    /* Check if we are comparing against the last element */
    if (elem
            == &g_mux_volt_last_searched->mux_voltage_pairs[g_mux_volt_last_searched->num_voltage_pairs
                    - 1]) {
        /* Match if the desired value is larger than the largest item in the list */
        if (key->v_in >= elem->v_in) {
            return 0;
        } else {
            return -1;
        }
    }

    /* Check for exact match to Vdd (upper end) */
    if (key->v_in == elem->v_in) {
        return 0;
    } else if (key->v_in < elem->v_in) {
        return -1;
    } else if (key->v_in > next->v_in) {
        return 1;
    } else {
        return 0;
    }
}