Initial commit

Author: aroelke

Makefile

@@ -0,0 +1,33 @@
+TARGET=oldspot
+
+SRCDIR=src
+SRC=$(wildcard $(SRCDIR)/*.cc)
+INCDIR=src
+OBJDIR=obj
+OBJ=$(SRC:$(SRCDIR)/%.cc=$(OBJDIR)/%.o)
+
+OPT=-O3
+INCLUDE=-I$(INCDIR)
+CXXFLAGS += -std=c++11 -Wall $(INCLUDE) $(OPT)
+LIBS=-lm -lpugixml
+LFLAGS += $(LIBS) $(OPT)
+
+.PHONY: $(TARGET) debug clean
+
+default: $(TARGET)
+
+$(TARGET): $(OBJ)
+	$(CXX) $^ -o $@ $(LFLAGS)
+
+$(OBJDIR)/%.o: $(SRCDIR)/%.cc
+	@mkdir -p $(OBJDIR)
+	$(CXX) -c $< -o $@ $(CXXFLAGS)
+
+debug: CXXFLAGS += -g
+debug: LFLAGS += -g
+debug: OPT=-O0
+debug: $(TARGET)
+
+clean:
+	rm -rf $(OBJDIR)
+	rm -rf $(TARGET)

example/activity.trace

@@ -0,0 +1,2 @@
+time,one
+1,0.75

example/config.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" ?>
+
+<group name="system" failures="0">
+    <unit type="unit" name="one">
+        <default vdd="1" />
+        <default temperature="300" />
+        <default frequency="2000" />
+        <default peak_power="0.1" />
+    </unit>
+</group>

example/frequency.trace

@@ -0,0 +1,2 @@
+time,one
+1,1000

example/power.trace

@@ -0,0 +1,2 @@
+time,one
+1,1.0

example/temperature.trace

@@ -0,0 +1,2 @@
+time,one
+1,350

example/voltage.trace

@@ -0,0 +1,2 @@
+time,two
+1,1

src/failure.cc

@@ -0,0 +1,62 @@
+#include "failure.hh"
+
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include "reliability.hh"
+
+using namespace std;
+
+double FailureMechanism::timeToFailure(const DataPoint& data, double fail) const
+{
+    return timeToFailure(data.vdd, data.temperature, data.activity, data.frequency, fail);
+}
+
+double NBTI::degradation(double t, double vdd, double dVth, double temperature, double duty_cycle) const
+{
+    duty_cycle = pow(duty_cycle/(1 + sqrt((1 - duty_cycle)/2)), 1.0/6.0);
+    double V = vdd - Vt0 - dVth;
+    if (V < 0)
+    {
+        cerr << "warning: subthreshold VDD " << vdd << " not supported" << endl;
+        cerr << "         operating at threshold instead" << endl;
+        V = 0;
+    }
+    double E_AIT = 2.0/3.0*(E_Akf - E_Akr) + E_ADH2/6;
+    double dN_IT = A*pow(V, Gamma_IT)*exp(-E_AIT/(k_B*temperature))*pow(t, 1.0/6.0);
+    double dN_HT = B*pow(V, Gamma_HT)*exp(-E_AHT/(k_B*temperature));
+    double n = eta*pow(V, -Gamma_OT/beta_OT)*exp(E_AOT/(k_B*temperature*beta_OT));
+    double dN_OT = C*(1 - exp(-pow(t/n, beta_OT)));
+    return duty_cycle*q/Cox*(dN_IT + dN_HT + dN_OT);
+}
+
+double NBTI::timeToFailure(double vdd, double temperature, double duty_cycle, double frequency, double fail) const
+{
+    if (isnan(fail))
+        fail = fail_default;
+
+    // Create a linear approximation of dVth(t)
+    double dVth_fail = (vdd - Vt0) - (vdd - Vt0)/pow(1 + fail, 1/alpha); // [ExtraTime]
+    cout << "Fail at " << dVth_fail << endl;
+    double dVth = 0, dVth_prev = 0;
+    double t = 0;
+    for (; dVth < dVth_fail; t += dt)
+    {
+        dVth_prev = dVth;
+        dVth = degradation(t, vdd, dVth, temperature, duty_cycle);
+        cout << t << '\t' << dVth << endl;
+    }
+    t -= dt;
+
+    if (dVth == 0)
+        return 0;
+    else // Linearly interpolate to find time at which dVth == dVth_fail (MTTF)
+        return (t - dt) + dt*(dVth_fail - dVth_prev)/(dVth - dVth_prev);
+}
+
+shared_ptr<ReliabilityDistribution> NBTI::distribution(const vector<MTTFSegment>& mttfs) const
+{
+    return make_shared<WeibullDistribution>(beta, mttfs);
+}

src/failure.hh

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "reliability.hh"
+#include "trace.hh"
+
+class FailureMechanism
+{
+  public:
+    const std::string name;
+
+    FailureMechanism(const std::string& _n) : name(_n) {}
+    virtual double timeToFailure(double vdd, double temperature,  double duty_cycle, double frequency, double fail) const = 0;
+    double timeToFailure(const DataPoint& data, double fail=std::numeric_limits<double>::signaling_NaN()) const;
+    virtual std::shared_ptr<ReliabilityDistribution> distribution(const std::vector<MTTFSegment>&) const = 0;
+};
+
+class NBTI : public FailureMechanism
+{
+  private:
+    const double q = 1.60217662e-19;    // C
+    const double k_B = 8.6173303e-5;    // eV/K
+
+    // Device parameters
+    const double Vt0 = 0.49158;         // V, taken from PTM [1] at 45nm
+    const double Cox = 5.934e-6;        // F
+    const double alpha = 1.3;           // alpha power law [2]
+
+    // Low-level parameters (chosen from device D4 [3])
+    const double A = 9e11;
+    const double B = 8.5e11;
+    const double C = 1e16;
+    const double Gamma_IT = 2.2;
+    const double Gamma_HT = 2.2;
+    const double Gamma_OT = 9;
+    const double E_Akf = 0.175;         // eV
+    const double E_Akr = 0.2;           // eV
+    const double E_ADH2 = 0.58;         // eV
+    const double E_AHT = 0.03;          // eV
+    const double E_AOT = 0.15;          // eV
+    const double eta = 5e12;
+    const double beta_OT = 0.36;
+
+    // High-level parameters
+    const double beta = 2;              // Weibull shape parameter [4]
+    const double fail_default = 0.01;   // Relative delay change [5]
+
+    const double dt = 3600;             // seconds
+
+  public:
+    NBTI() : FailureMechanism("NBTI") {}
+    static const std::shared_ptr<FailureMechanism> model() { static NBTI nbti; return std::make_shared<NBTI>(nbti); }
+    double degradation(double t, double vdd, double dVth, double temperature, double duty_cycle) const;
+    double timeToFailure(double vdd, double temperature, double duty_cycle, double frequency, double fail=std::numeric_limits<double>::signaling_NaN()) const override;
+    std::shared_ptr<ReliabilityDistribution> distribution(const std::vector<MTTFSegment>& mttfs) const override;
+};
+
+/*
+ * [1] PTM
+ * 
+ * [2] K. Joshi, S. Mukhopadhyay, N. Goel, and S. Mahapatra, “A consistent
+ *     physical framework for N and P BTI in HKMG MOSFETs,” in Reliability
+ *     Physics Symposium (IRPS), 2012 IEEE International, 2012, p. 5A.3.1-5A.3.10.
+ * 
+ * [3]
+ * 
+ * [4] "Failure Mechanisms and Models for Semiconductor Devices,"" JEDEC Solid
+ *     State Technology Institution, JEP122H, Oct. 2011.
+ * 
+ * [5] F. Oboril and M. B. Tahoori, “ExtraTime: Modeling and analysis of
+ *     wearout due to transistor aging at microarchitecture-level,” in
+ *     IEEE/IFIP International Conference on Dependable Systems and Networks
+ *     (DSN 2012), 2012, pp. 1–12.
+ */

src/main.cc

@@ -0,0 +1,75 @@
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <numeric>
+#include <pugixml.hpp>
+#include <string>
+#include <tclap/CmdLine.h>
+#include <utility>
+#include <vector>
+
+#include "failure.hh"
+#include "trace.hh"
+#include "unit.hh"
+
+using namespace std;
+
+int main(int argc, char* argv[])
+{
+    using namespace pugi;
+    using namespace TCLAP;
+
+    try
+    {
+        CmdLine cmd("Compute the reliability distribution of a chip", ' ', "0.1");
+        ValueArg<char> delimiter("", "trace-delimiter", "One-character delimiter for data in input trace files (default: ,)", false, ',', "delim", cmd);
+        ValueArg<string> ptrace("p", "power", "File containing power traces for all units (W)", false, "", "filename", cmd);
+        ValueArg<string> ftrace("f", "frequency", "File containing frequency traces for all units (MHz)", false, "", "filename", cmd);
+        ValueArg<string> ttrace("T", "temperature", "File containing temperature traces for all units (K)", false, "", "filename", cmd);
+        ValueArg<string> vtrace("v", "vdd", "File containing voltage traces for all units (V)", false, "", "filename", cmd);
+        ValueArg<string> atrace("a", "activity", "File containing activity traces for all units", false, "", "filename", cmd);
+        ValueArg<string> config("c", "chip-config", "File containing chip configuration", true, "", "filename", cmd);
+        cmd.parse(argc, argv);
+
+        xml_document doc;
+        xml_parse_result result = doc.load_file(config.getValue().c_str());
+        if (!result)
+        {
+            cerr << config.getValue() << ": " << result.description()
+                 << " at offset " << result.offset << endl;
+            return 1;
+        }
+
+        vector<shared_ptr<Unit>> units;
+        Group root(doc, units);
+
+        trace_t activity, voltage, temperature, frequency, power;
+        if (!atrace.getValue().empty())
+            activity = parseTrace(atrace.getValue(), delimiter.getValue());
+        if (!vtrace.getValue().empty())
+            voltage = parseTrace(vtrace.getValue(), delimiter.getValue());
+        if (!ttrace.getValue().empty())
+            temperature = parseTrace(ttrace.getValue(), delimiter.getValue());
+        if (!ftrace.getValue().empty())
+            frequency = parseTrace(ftrace.getValue(), delimiter.getValue());
+        if (!ptrace.getValue().empty())
+            power = parseTrace(ptrace.getValue(), delimiter.getValue());
+        unordered_set<string> names(units.size());
+        for (const shared_ptr<Unit>& unit: units)
+            names.insert(unit->name);
+        map<string, vector<DataPoint>> traces = collectTraces(names, activity, voltage, temperature, frequency, power);
+
+        vector<shared_ptr<FailureMechanism>> mechanisms = {NBTI::model()};
+        for (const shared_ptr<Unit>& unit: units)
+            unit->computeReliability(mechanisms, traces[unit->name]);
+        // Compute reliabilities
+        // Monte Carlo sim to get overall failure distribution
+    }
+    catch (ArgException& e)
+    {
+        cerr << "error: " << e.error() << " for arg " << e.argId() << endl;
+        return 1;
+    }
+    return 0;
+}