riscv
/
OpenFPGA
mirror of https://github.com/lnis-uofu/OpenFPGA.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
OpenFPGA/vpr/src/power/power_cmos_tech.cpp

740 lines
29 KiB
C++
Raw Normal View History

add vpr8 libs and core engine for further integration
2020-01-03 17:14:42 -06:00
/*********************************************************************
* 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>
#include "vtr_assert.h"
#include "pugixml.hpp"
#include "pugixml_util.hpp"
#include "vtr_util.h"
#include "vtr_memory.h"
#include "vtr_math.h"
#include "vpr_error.h"
#include "globals.h"
#include "power_cmos_tech.h"
#include "power.h"
#include "power_util.h"
#include "read_xml_util.h"
#include "PowerSpicedComponent.h"
#include "power_callibrate.h"
/************************* FILE SCOPE **********************************/
static t_transistor_inf* f_transistor_last_searched;
static t_power_buffer_strength_inf* f_buffer_strength_last_searched;
static t_power_mux_volt_inf* f_mux_volt_last_searched;
static t_power_nmos_leakage_inf* f_power_searching_nmos_leakage_info;
/************************* FUNCTION DECLARATIONS ********************/
static void power_tech_load_xml_file(const char* cmos_tech_behavior_filepath);
static void process_tech_xml_load_transistor_info(pugi::xml_node parent, const pugiutil::loc_data& loc_data);
static void power_tech_xml_load_multiplexer_info(pugi::xml_node parent, const pugiutil::loc_data& loc_data);
static void power_tech_xml_load_nmos_st_leakages(pugi::xml_node parent, const pugiutil::loc_data& loc_data);
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(pugi::xml_node parent, const pugiutil::loc_data& loc_data);
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(pugi::xml_node parent, const pugiutil::loc_data& loc_data);
static void power_tech_xml_load_component(pugi::xml_node parent, const pugiutil::loc_data& loc_data, PowerSpicedComponent** component, const char* name, float (*usage_fn)(int num_inputs, float transistor_size));
/************************* FUNCTION DEFINITIONS *********************/
void power_tech_init(const 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(const char* cmos_tech_behavior_filepath) {
pugi::xml_document doc;
pugiutil::loc_data loc_data;
try {
loc_data = pugiutil::load_xml(doc, cmos_tech_behavior_filepath);
} catch (const pugiutil::XmlError& e) {
vpr_throw(VPR_ERROR_POWER, cmos_tech_behavior_filepath, 0,
"Failed to load CMOS Tech Properties file '%s' (%s).", cmos_tech_behavior_filepath, e.what());
}
auto technology = get_single_child(doc, "technology", loc_data);
get_attribute(technology, "file", loc_data); //Check exists
auto& power_ctx = g_vpr_ctx.power();
auto tech_size = get_attribute(technology, "size", loc_data);
power_ctx.tech->tech_size = tech_size.as_float();
auto operating_point = get_single_child(technology, "operating_point", loc_data);
power_ctx.tech->temperature = get_attribute(operating_point, "temperature", loc_data).as_float();
power_ctx.tech->Vdd = get_attribute(operating_point, "Vdd", loc_data).as_float();
auto p_to_n = get_single_child(technology, "p_to_n", loc_data);
power_ctx.tech->PN_ratio = get_attribute(p_to_n, "ratio", loc_data).as_float();
/* Transistor Information
* We expect two <transistor> sections for P and N types
*/
auto child = get_first_child(technology, "transistor", loc_data);
process_tech_xml_load_transistor_info(child, loc_data);
child = child.next_sibling("transistor");
process_tech_xml_load_transistor_info(child, loc_data);
//Should be no more
auto next = child.next_sibling("transistor");
if (next) {
vpr_throw(VPR_ERROR_POWER, loc_data.filename_c_str(), loc_data.line(next),
"Encountered extra <transitor> section (expect 2 only: pmos and nmos)\n");
}
/* Multiplexer Voltage Information */
child = get_single_child(technology, "multiplexers", loc_data);
power_tech_xml_load_multiplexer_info(child, loc_data);
/* Vds Leakage Information */
child = get_single_child(technology, "nmos_leakages", loc_data);
power_tech_xml_load_nmos_st_leakages(child, loc_data);
/* Buffer SC Info */
/*
* child = get_single_child(technology, "buffer_sc", loc_data);
* power_tech_xml_load_sc(child);
*/
/* Components */
child = get_single_child(technology, "components", loc_data);
power_tech_xml_load_components(child, loc_data);
}
static void power_tech_xml_load_component(pugi::xml_node parent, const pugiutil::loc_data& loc_data, PowerSpicedComponent** component, const char* name, float (*usage_fn)(int num_inputs, float transistor_size)) {
std::string component_name(name);
*component = new PowerSpicedComponent(component_name, usage_fn);
auto cur = get_single_child(parent, name, loc_data);
auto child = get_first_child(cur, "inputs", loc_data);
while (child) {
int num_inputs = get_attribute(child, "num_inputs", loc_data).as_int(0);
auto gc = get_first_child(child, "size", loc_data);
while (gc) {
float transistor_size = get_attribute(gc, "transistor_size", loc_data).as_float(0.);
float power = get_attribute(gc, "power", loc_data).as_float(0.);
(*component)->add_data_point(num_inputs, transistor_size, power);
gc = gc.next_sibling("size");
}
child = child.next_sibling("inputs");
}
}
static void power_tech_xml_load_components(pugi::xml_node parent, const pugiutil::loc_data& loc_data) {
auto& power_ctx = g_vpr_ctx.power();
power_ctx.commonly_used->component_callibration = (PowerSpicedComponent**)vtr::calloc(POWER_CALLIB_COMPONENT_MAX,
sizeof(PowerSpicedComponent*));
power_tech_xml_load_component(parent, loc_data,
&power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER],
"buf", power_usage_buf_for_callibration);
power_tech_xml_load_component(parent, loc_data,
&power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR],
"buf_levr", power_usage_buf_levr_for_callibration);
power_tech_xml_load_component(parent, loc_data,
&power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF],
"dff", power_usage_ff_for_callibration);
power_tech_xml_load_component(parent, loc_data,
&power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX],
"mux", power_usage_mux_for_callibration);
power_tech_xml_load_component(parent, loc_data,
&power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT],
"lut", power_usage_lut_for_callibration);
}
/**
* 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(pugi::xml_node parent, const pugiutil::loc_data& loc_data) {
int num_nmos_sizes;
int num_leakage_pairs;
int i;
int nmos_idx;
auto& power_ctx = g_vpr_ctx.power();
num_nmos_sizes = count_children(parent, "nmos", loc_data);
power_ctx.tech->num_nmos_leakage_info = num_nmos_sizes;
power_ctx.tech->nmos_leakage_info = (t_power_nmos_leakage_inf*)vtr::calloc(num_nmos_sizes, sizeof(t_power_nmos_leakage_inf));
auto me = get_first_child(parent, "nmos", loc_data);
nmos_idx = 0;
while (me) {
t_power_nmos_leakage_inf* nmos_info = &power_ctx.tech->nmos_leakage_info[nmos_idx];
nmos_info->nmos_size = get_attribute(me, "size", loc_data).as_float(0.);
num_leakage_pairs = count_children(me, "nmos_leakage", loc_data);
nmos_info->num_leakage_pairs = num_leakage_pairs;
nmos_info->leakage_pairs = (t_power_nmos_leakage_pair*)vtr::calloc(num_leakage_pairs, sizeof(t_power_nmos_leakage_pair));
auto child = get_first_child(me, "nmos_leakage", loc_data);
i = 0;
while (child) {
nmos_info->leakage_pairs[i].v_ds = get_attribute(child, "Vds", loc_data).as_float(0.0);
nmos_info->leakage_pairs[i].i_ds = get_attribute(child, "Ids", loc_data).as_float(0.0);
child = child.next_sibling("nmos_leakage");
i++;
}
me = me.next_sibling("nmos");
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(pugi::xml_node parent, const pugiutil::loc_data& loc_data) {
int num_nmos_sizes;
int num_mux_sizes;
int i, j, nmos_idx;
auto& power_ctx = g_vpr_ctx.power();
/* Process all nmos sizes */
num_nmos_sizes = count_children(parent, "nmos", loc_data);
VTR_ASSERT(num_nmos_sizes > 0);
power_ctx.tech->num_nmos_mux_info = num_nmos_sizes;
power_ctx.tech->nmos_mux_info = (t_power_nmos_mux_inf*)vtr::calloc(num_nmos_sizes, sizeof(t_power_nmos_mux_inf));
auto me = get_first_child(parent, "nmos", loc_data);
nmos_idx = 0;
while (me) {
t_power_nmos_mux_inf* nmos_inf = &power_ctx.tech->nmos_mux_info[nmos_idx];
nmos_inf->nmos_size = get_attribute(me, "size", loc_data).as_float(0.0);
/* Process all multiplexer sizes */
num_mux_sizes = count_children(me, "multiplexer", loc_data);
/* 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*)vtr::calloc(nmos_inf->max_mux_sl_size + 1, sizeof(t_power_mux_volt_inf));
auto child = get_first_child(me, "multiplexer", loc_data);
i = 1;
while (child) {
int num_voltages;
VTR_ASSERT(i == get_attribute(child, "size", loc_data).as_int(0));
/* For each mux size, process all of the Vin levels */
num_voltages = count_children(child, "voltages", loc_data);
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*)vtr::calloc(num_voltages,
sizeof(t_power_mux_volt_pair));
auto gc = get_first_child(child, "voltages", loc_data);
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 = get_attribute(gc, "in", loc_data).as_float(0.0);
nmos_inf->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_min = get_attribute(gc, "out_min", loc_data).as_float(0.0);
nmos_inf->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_max = get_attribute(gc, "out_max", loc_data).as_float(0.0);
gc = gc.next_sibling("voltages");
j++;
}
child = child.next_sibling("multiplexer");
i++;
}
me = me.next_sibling("nmos");
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(pugi::xml_node parent, const pugiutil::loc_data& loc_data) {
t_transistor_inf* trans_inf;
int i;
auto& power_ctx = g_vpr_ctx.power();
/* Get transistor type: NMOS or PMOS */
auto prop = get_attribute(parent, "type", loc_data);
trans_inf = nullptr;
if (strcmp(prop.value(), "nmos") == 0) {
trans_inf = &power_ctx.tech->NMOS_inf;
} else if (strcmp(prop.value(), "pmos") == 0) {
trans_inf = &power_ctx.tech->PMOS_inf;
} else {
vpr_throw(VPR_ERROR_POWER, loc_data.filename_c_str(), loc_data.line(parent),
"Unrecognized transistor type '%s', expected 'nmos' or 'pmos'\n", prop.value());
}
/* Get long transistor information (W=1,L=2) */
trans_inf->long_trans_inf = (t_transistor_size_inf*)vtr::malloc(sizeof(t_transistor_size_inf));
auto child = get_single_child(parent, "long_size", loc_data);
VTR_ASSERT(get_attribute(child, "L", loc_data).as_int(0) == 2);
trans_inf->long_trans_inf->size = get_attribute(child, "W", loc_data).as_float(0.);
auto grandchild = get_single_child(child, "leakage_current", loc_data);
trans_inf->long_trans_inf->leakage_subthreshold = get_attribute(grandchild, "subthreshold", loc_data).as_float(0.);
grandchild = get_single_child(child, "capacitance", loc_data);
trans_inf->long_trans_inf->C_g = get_attribute(grandchild, "C_g", loc_data).as_float(0);
trans_inf->long_trans_inf->C_d = get_attribute(grandchild, "C_d", loc_data).as_float(0);
trans_inf->long_trans_inf->C_s = get_attribute(grandchild, "C_s", loc_data).as_float(0);
/* Process all transistor sizes */
trans_inf->num_size_entries = count_children(parent, "size", loc_data);
trans_inf->size_inf = (t_transistor_size_inf*)vtr::calloc(trans_inf->num_size_entries, sizeof(t_transistor_size_inf));
child = get_first_child(parent, "size", loc_data);
i = 0;
while (child) {
VTR_ASSERT(get_attribute(child, "L", loc_data).as_int(0) == 1);
trans_inf->size_inf[i].size = get_attribute(child, "W", loc_data).as_float(0);
/* Get leakage currents */
grandchild = get_single_child(child, "leakage_current", loc_data);
trans_inf->size_inf[i].leakage_subthreshold = get_attribute(grandchild, "subthreshold", loc_data).as_float(0);
trans_inf->size_inf[i].leakage_gate = get_attribute(grandchild, "gate", loc_data).as_float(0);
/* Get node capacitances */
grandchild = get_single_child(child, "capacitance", loc_data);
trans_inf->size_inf[i].C_g = get_attribute(grandchild, "C_g", loc_data).as_float(0);
trans_inf->size_inf[i].C_s = get_attribute(grandchild, "C_s", loc_data).as_float(0);
trans_inf->size_inf[i].C_d = get_attribute(grandchild, "C_d", loc_data).as_float(0);
child = child.next_sibling("size");
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)
*/
bool 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;
bool error = false;
auto& power_ctx = g_vpr_ctx.power();
key.size = size;
/* Find the appropriate global transistor records */
trans_info = nullptr;
if (type == NMOS) {
trans_info = &power_ctx.tech->NMOS_inf;
} else if (type == PMOS) {
trans_info = &power_ctx.tech->PMOS_inf;
} else {
VTR_ASSERT(0);
}
/* No transistor data exists */
if (trans_info->size_inf == nullptr) {
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 */
f_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);
VTR_ASSERT(found);
if (size < min_size) {
/* Too small */
VTR_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 = nullptr;
*upper = found;
} else if (size > max_size) {
/* Too large */
VTR_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 = nullptr;
} 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
*/
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;
f_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);
VTR_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 = nullptr;
} 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;
VTR_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 = nullptr;
} 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;
VTR_ASSERT(input_mux_size >= 1);
key.mux_size = input_mux_size;
f_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 */
VTR_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 = nullptr;
} 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 == &f_power_searching_nmos_leakage_info->leakage_pairs[f_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;
f_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);
VTR_ASSERT(found);
if (found
== &volt_inf->mux_voltage_pairs[volt_inf->num_voltage_pairs - 1]) {
*lower = found;
*upper = nullptr;
} 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
== &f_buffer_strength_last_searched->sc_levr_inf[f_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 == &f_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
== &f_transistor_last_searched->size_inf[f_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 == &f_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
== &f_mux_volt_last_searched->mux_voltage_pairs[f_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;
}
}