c1aecc05e6
This patch extensively modifies DSENT so that it can be accessed using Python. To access the Python interface, DSENT needs to compiled as a shared library. For this purpose a CMakeLists.txt file has been added. Some of the code that is not required is being removed.
344 lines
15 KiB
C++
344 lines
15 KiB
C++
/* Copyright (c) 2012 Massachusetts Institute of Technology
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include "tech/TechModel.h"
|
|
|
|
#include <cmath>
|
|
|
|
#include "model/std_cells/StdCellLib.h"
|
|
|
|
namespace DSENT
|
|
{
|
|
TechModel::TechModel()
|
|
: m_std_cell_lib_(NULL), m_available_wire_layers_(NULL)
|
|
{}
|
|
|
|
TechModel::~TechModel()
|
|
{}
|
|
|
|
const String& TechModel::get(const String &key_) const
|
|
{
|
|
return params.at(key_);
|
|
}
|
|
|
|
void TechModel::setStdCellLib(const StdCellLib* std_cell_lib_)
|
|
{
|
|
m_std_cell_lib_ = std_cell_lib_;
|
|
return;
|
|
}
|
|
|
|
const StdCellLib* TechModel::getStdCellLib() const
|
|
{
|
|
return m_std_cell_lib_;
|
|
}
|
|
|
|
TechModel* TechModel::clone() const
|
|
{
|
|
return new TechModel(*this);
|
|
}
|
|
|
|
void TechModel::readFile(const String& filename_)
|
|
{
|
|
// Read the main technology file
|
|
LibUtil::readFile(filename_, params);
|
|
|
|
// Search for "INCLUDE" to include more technology files
|
|
for (const auto &it : params)
|
|
{
|
|
const String& key = it.first;
|
|
if(key.compare(0, 8, "INCLUDE_") == 0)
|
|
{
|
|
const String& include_filename = it.second;
|
|
LibUtil::readFile(include_filename, params);
|
|
}
|
|
}
|
|
|
|
// Set the available wire layers
|
|
const vector<String>& available_wire_layer_vector = get("Wire->AvailableLayers").split("[,]");
|
|
m_available_wire_layers_ = new std::set<String>;
|
|
for(unsigned int i = 0; i < available_wire_layer_vector.size(); ++i)
|
|
{
|
|
m_available_wire_layers_->insert(available_wire_layer_vector[i]);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Transistor Related Functions
|
|
//-------------------------------------------------------------------------
|
|
//Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
|
|
double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
|
|
{
|
|
vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
|
|
return calculateNmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
|
|
}
|
|
|
|
//Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
|
|
double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
|
|
{
|
|
// Get technology parameters
|
|
double vdd = get("Vdd");
|
|
double temp = get("Temperature");
|
|
double char_temp = get("Nmos->CharacterizedTemperature");
|
|
double min_off_current = get("Nmos->MinOffCurrent");
|
|
double off_current = get("Nmos->OffCurrent");
|
|
double subthreshold_swing = get("Nmos->SubthresholdSwing");
|
|
double dibl = get("Nmos->DIBL");
|
|
double temp_swing = get("Nmos->SubthresholdTempSwing");
|
|
|
|
// Map dibl to a swing value for easier calculation
|
|
double dibl_swing = subthreshold_swing / dibl;
|
|
|
|
//Calculate the leakage current factor
|
|
double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);
|
|
|
|
// Calcualte actual leakage current at characterized temperature
|
|
double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
|
|
leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);
|
|
|
|
// Calculate actual leakage current at temp
|
|
double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);
|
|
|
|
return leakage_current;
|
|
}
|
|
|
|
double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
|
|
{
|
|
vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
|
|
return calculatePmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
|
|
}
|
|
|
|
//Returns the leakage current of PMOS transistors, given the transistor stakcing, transistor widths, and input combination
|
|
double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
|
|
{
|
|
// Get technology parameters
|
|
double vdd = get("Vdd");
|
|
double temp = get("Temperature");
|
|
double char_temp = get("Pmos->CharacterizedTemperature");
|
|
double min_off_current = get("Pmos->MinOffCurrent");
|
|
double off_current = get("Pmos->OffCurrent");
|
|
double dibl = get("Pmos->DIBL");
|
|
double subthreshold_swing = get("Pmos->SubthresholdSwing");
|
|
double temp_swing = get("Nmos->SubthresholdTempSwing");
|
|
|
|
// Map dibl to a swing value for easier calculation
|
|
double dibl_swing = subthreshold_swing / dibl;
|
|
|
|
//Calculate the leakage current factor
|
|
double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);
|
|
|
|
// Calcualte actual leakage current at characterized temperature
|
|
double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
|
|
leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);
|
|
|
|
// Calculate actual leakage current at temp
|
|
double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);
|
|
|
|
return leakage_current;
|
|
}
|
|
|
|
//Returns the leakage current, given the transistor stakcing, transistor widths, input combination,
|
|
//and technology information (vdd, subthreshold swing, subthreshold dibl swing)
|
|
double TechModel::calculateLeakageCurrentFactor(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_, double vdd_, double subthreshold_swing_, double dibl_swing_) const
|
|
{
|
|
// check everything is valid
|
|
ASSERT(num_stacks_ >= 1, "[Error] Number of stacks must be >= 1!");
|
|
ASSERT(stacked_mos_widths_.size() == num_stacks_, "[Error] Mismatch in number of stacks and the widths specified!");
|
|
|
|
//Use short name in this method
|
|
const double s1 = subthreshold_swing_;
|
|
const double s2 = dibl_swing_;
|
|
|
|
// Decode input combinations from input_vector_
|
|
std::vector<double> vs(num_stacks_, 0.0);
|
|
for(int i = 0; i < (int)num_stacks_; ++i)
|
|
{
|
|
double current_input = (double(input_vector_ & 0x1))*vdd_;
|
|
vs[i] = (current_input);
|
|
input_vector_ >>= 1;
|
|
}
|
|
// If the widths pointer is NULL, width is set to 1 by default
|
|
vector<double> ws = stacked_mos_widths_;
|
|
|
|
//Solve voltages at internal nodes of stacked transistors
|
|
// v[0] = 0
|
|
// v[num_stacks_] = vdd_
|
|
// v[i] = (1.0/(2*s1 + s2))*((s1 + s2)*v[i - 1] + s1*v[i + 1]
|
|
// + s2*(vs[i + 1] - vs[i]) + s1*s2*log10(ws[i + 1]/ws[i]))
|
|
//Use tri-matrix solver to solve the above linear system
|
|
|
|
double A = -(s1 + s2);
|
|
double B = 2*s1 + s2;
|
|
double C = -s1;
|
|
std::vector<double> a(num_stacks_ - 1, 0);
|
|
std::vector<double> b(num_stacks_ - 1, 0);
|
|
std::vector<double> c(num_stacks_ - 1, 0);
|
|
std::vector<double> d(num_stacks_ - 1, 0);
|
|
std::vector<double> v(num_stacks_ + 1, 0);
|
|
unsigned int eff_num_stacks = num_stacks_;
|
|
bool is_found_valid_v = false;
|
|
do
|
|
{
|
|
//Set boundary condition
|
|
v[0] = 0;
|
|
v[eff_num_stacks] = vdd_;
|
|
|
|
//If the effective number of stacks is 1, no matrix needs to be solved
|
|
if(eff_num_stacks == 1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//Setup the tri-matrix
|
|
//----------------------------------------------------------------------
|
|
for(int i = 0; i < (int)eff_num_stacks-2; ++i)
|
|
{
|
|
a[i + 1] = A;
|
|
c[i] = C;
|
|
}
|
|
for(int i = 0; i < (int)eff_num_stacks-1; ++i)
|
|
{
|
|
b[i] = B;
|
|
d[i] = s2*(vs[i + 1] - vs[i]) + s1*s2*std::log10(ws[i + 1]/ws[i]);
|
|
if(i == ((int)eff_num_stacks - 2))
|
|
{
|
|
d[i] -= C*vdd_;
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------
|
|
//Solve the tri-matrix
|
|
//----------------------------------------------------------------------
|
|
for(int i = 1; i < (int)eff_num_stacks-1; ++i)
|
|
{
|
|
double m = a[i]/b[i - 1];
|
|
b[i] -= m*c[i - 1];
|
|
d[i] -= m*d[i - 1];
|
|
}
|
|
|
|
v[eff_num_stacks - 1] = d[eff_num_stacks - 2]/b[eff_num_stacks - 2];
|
|
for(int i = eff_num_stacks - 3; i >= 0; --i)
|
|
{
|
|
v[i + 1] = (d[i] - c[i]*v[i + 2])/b[i];
|
|
}
|
|
//----------------------------------------------------------------------
|
|
|
|
//Check if the internal voltages are in increasing order
|
|
is_found_valid_v = true;
|
|
for(int i = 1; i <= (int)eff_num_stacks; ++i)
|
|
{
|
|
//If the ith internal voltage is not in increasing order
|
|
//(i-1)th transistor is in triode region
|
|
//Remove the transistors in triode region as it does not exist
|
|
if(v[i] < v[i - 1])
|
|
{
|
|
is_found_valid_v = false;
|
|
eff_num_stacks--;
|
|
vs.erase(vs.begin() + i - 1);
|
|
ws.erase(ws.begin() + i - 1);
|
|
break;
|
|
}
|
|
}
|
|
} while(!is_found_valid_v);
|
|
|
|
//Calculate the leakage current of the bottom transistor (first not in triode region)
|
|
double vgs = vs[0] - v[0];
|
|
double vds = v[1] - v[0];
|
|
double leakage_current_factor = vgs/s1 + (vds - vdd_)/s2;
|
|
//TODO - Check if the leakage current calculate for other transistors is identical
|
|
|
|
return leakage_current_factor;
|
|
}
|
|
//-------------------------------------------------------------------------
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Wire Related Functions
|
|
//-------------------------------------------------------------------------
|
|
bool TechModel::isWireLayerExist(const String& layer_name_) const
|
|
{
|
|
std::set<String>::const_iterator it;
|
|
it = m_available_wire_layers_->find(layer_name_);
|
|
return (it != m_available_wire_layers_->end());
|
|
}
|
|
|
|
const std::set<String>* TechModel::getAvailableWireLayers() const
|
|
{
|
|
return m_available_wire_layers_;
|
|
}
|
|
|
|
double TechModel::calculateWireCapacitance(const String& layer_name_, double width_, double spacing_, double length_) const
|
|
{
|
|
// Get technology parameter
|
|
double min_width = get("Wire->" + layer_name_ + "->MinWidth").toDouble();
|
|
double min_spacing = get("Wire->" + layer_name_ + "->MinSpacing").toDouble();
|
|
double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness").toDouble();
|
|
double dielec_thickness = get("Wire->" + layer_name_ + "->DielectricThickness").toDouble();
|
|
double dielec_const = get("Wire->" + layer_name_ + "->DielectricConstant").toDouble();
|
|
|
|
ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
|
|
ASSERT(spacing_ >= min_spacing, "[Error] Wire spacing must be >= " + (String) min_spacing + "!");
|
|
ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");
|
|
|
|
double A, B, C;
|
|
// Calculate ground capacitance
|
|
A = width_ / dielec_thickness;
|
|
B = 2.04*std::pow((spacing_ / (spacing_ + 0.54 * dielec_thickness)), 1.77);
|
|
C = std::pow((metal_thickness / (metal_thickness + 4.53 * dielec_thickness)), 0.07);
|
|
double unit_gnd_cap = dielec_const * 8.85e-12 * (A + B * C);
|
|
|
|
A = 1.14 * (metal_thickness / spacing_) * std::exp(-4.0 * spacing_ / (spacing_ + 8.01 * dielec_thickness));
|
|
B = 2.37 * std::pow((width_ / (width_ + 0.31 * spacing_)), 0.28);
|
|
C = std::pow((dielec_thickness / (dielec_thickness + 8.96 * spacing_)), 0.76) *
|
|
std::exp(-2.0 * spacing_ / (spacing_ + 6.0 * dielec_thickness));
|
|
double unit_coupling_cap = dielec_const * 8.85e-12 * (A + B * C);
|
|
|
|
double total_cap = 2 * (unit_gnd_cap + unit_coupling_cap) * length_;
|
|
return total_cap;
|
|
}
|
|
|
|
double TechModel::calculateWireResistance(const String& layer_name_, double width_, double length_) const
|
|
{
|
|
// Get technology parameter
|
|
double min_width = get("Wire->" + layer_name_ + "->MinWidth");
|
|
//double barrier_thickness = get("Wire->" + layer_name_ + "->BarrierThickness");
|
|
double resistivity = get("Wire->" + layer_name_ + "->Resistivity");
|
|
double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness");
|
|
|
|
ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
|
|
ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");
|
|
|
|
// Calculate Rho
|
|
// double rho = 2.202e-8 + (1.030e-15 / (width_ - 2.0 * barrier_thickness));
|
|
|
|
double unit_res = resistivity / (width_ * metal_thickness);
|
|
//double unit_res = rho / ((width_ - 2.0 * barrier_thickness) * (metal_thickness - barrier_thickness));
|
|
|
|
double total_res = unit_res * length_;
|
|
return total_res;
|
|
}
|
|
//-------------------------------------------------------------------------
|
|
|
|
TechModel::TechModel(const TechModel& tech_model_)
|
|
: m_std_cell_lib_(tech_model_.m_std_cell_lib_),
|
|
params(tech_model_.params)
|
|
{}
|
|
} // namespace DSENT
|