path: root/ext/dsent/tech/TechModel.cc

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