origen_std_lib 0.10.1 → 0.13.1

data/src/advantest/smt7/origen/origen/test_method/functional_test.cpp

@@ -0,0 +1,168 @@
+#include "functional_test.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+// Defaults
+FunctionalTest::FunctionalTest() {
+  pin("");
+  port("");
+  capture(0);
+  processResults(1);
+  bitPerWord(1);
+  pattern("");
+  testName("");
+}
+
+FunctionalTest::~FunctionalTest() {}
+
+/// The functional test method can optionally capture data by supplying the
+/// number of vectors to capture
+FunctionalTest& FunctionalTest::capture(int v) {
+  _capture = v;
+  return *this;
+}
+/// If data capture is requested, supply the pin to capture data from
+FunctionalTest& FunctionalTest::pin(string v) {
+  _pin = v;
+  return *this;
+}
+/// Optionally supply the name of the test port that should be used to execute
+/// the pattern
+FunctionalTest& FunctionalTest::port(string v) {
+  _port = v;
+  return *this;
+}
+/// Serial capture data will be grouped into words, specify how many bits per
+/// word in the serial stream (default 1)
+FunctionalTest& FunctionalTest::bitPerWord(int v) {
+  _bitPerWord = v;
+  return *this;
+}
+/// When set to 0 the results of the test will not be judged or logged
+FunctionalTest& FunctionalTest::processResults(int v) {
+  _processResults = v;
+  return *this;
+}
+/// Override the pattern argument from the test suite
+FunctionalTest& FunctionalTest::pattern(string v) {
+  _pattern = v;
+  return *this;
+}
+/// Override the test name argument from the test suite, this can be useful if
+/// the main test item to be logged is
+/// a captured value and the pattern execution is to be logged separately. The
+/// override is only valid for one call to execute()
+/// and then it will be removed.
+FunctionalTest& FunctionalTest::testName(string v) {
+  _testNameOverride = v;
+  return *this;
+}
+
+// All test methods must implement this function
+FunctionalTest& FunctionalTest::getThis() { return *this; }
+
+void FunctionalTest::_setup() { results.resize(numberOfPhysicalSites + 1); }
+
+void FunctionalTest::_execute() {
+  int site;
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  if (_pattern.empty()) {
+    label = Primary.getLabel();
+  } else {
+    label = _pattern;
+  }
+
+  if (_capture) {
+    pinName = extractPinsFromGroup(_pin);
+  }
+
+  RDI_BEGIN();
+
+  if (_capture) {
+    if (_port.empty()) {
+      SMART_RDI::DIG_CAP& prdi = rdi.digCap(suiteName)
+                                     .label(label)
+                                     .pin(pinName)
+                                     .bitPerWord(_bitPerWord)
+                                     .samples(_capture);
+      filterRDI(prdi);
+      prdi.execute();
+
+    } else {
+      SMART_RDI::DIG_CAP& prdi = rdi.port(_port)
+                                     .digCap(suiteName)
+                                     .vecVarOnly()
+                                     .pin(pinName)
+                                     .bitPerWord(_bitPerWord)
+                                     .samples(_capture);
+      filterRDI(prdi);
+      prdi.execute();
+      rdi.port(_port).func().burst(label).execute();
+    }
+
+  } else {
+    if (_port.empty()) {
+      SMART_RDI::FUNC& prdi = rdi.func(suiteName).label(label);
+      filterRDI(prdi);
+      prdi.execute();
+    } else {
+      SMART_RDI::FUNC& prdi = rdi.port(_port).func(suiteName).burst(label);
+      filterRDI(prdi);
+      prdi.execute();
+    }
+  }
+
+  RDI_END();
+
+  FOR_EACH_SITE_BEGIN();
+  site = CURRENT_SITE_NUMBER();
+  if (_capture) {
+    results[site] = rdi.site(site).getBurstPassFail();
+    //        	cout << "PRE " << site << ": " << results[site] << endl;
+
+  } else {
+    results[site] = rdi.site(site).id(suiteName).getPassFail();
+    //            cout << "PRE " << site << ": " << results[site] << endl;
+  }
+  FOR_EACH_SITE_END();
+
+  ON_FIRST_INVOCATION_END();
+}
+
+/// Returns the captured data for the site currently in focus
+ARRAY_I FunctionalTest::capturedData() {
+  return rdi.id(suiteName).getVector(pinName);
+}
+
+/// Returns the captured data for the given site number
+ARRAY_I FunctionalTest::capturedData(int site) {
+  return rdi.site(site).id(suiteName).getVector(pinName);
+}
+
+void FunctionalTest::serialProcessing(int site) {
+  if (_processResults) {
+    if (_testNameOverride != "") {
+      judgeAndDatalog(_testNameOverride,
+                      invertFunctionalResultIfRequired(results[site]));
+    } else {
+      judgeAndDatalog(invertFunctionalResultIfRequired(results[site]));
+    }
+  }
+  _testNameOverride = "";
+}
+
+void FunctionalTest::SMC_backgroundProcessing() {
+  for (int i = 0; i < activeSites.size(); i++) {
+    int site = activeSites[i];
+    process(site);
+    if (_processResults) {
+      SMC_TEST(site, "", suiteName, LIMIT(TM::GE, 1, TM::LE, 1),
+               results[activeSites[i]]);
+    }
+  }
+}
+}
+}

data/src/advantest/smt7/origen/origen/test_method/functional_test.hpp

@@ -0,0 +1,53 @@
+#ifndef ORIGEN_TEST_METHOD_FUNCTIONAL_TEST_INCLUDED
+#define ORIGEN_TEST_METHOD_FUNCTIONAL_TEST_INCLUDED
+
+#include "base.hpp"
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class FunctionalTest : public Base {
+  void serialProcessing(int site);
+
+  string _pin;
+  string _port;
+  int _capture;
+  int _bitPerWord;
+  int _processResults;
+  string _pattern;
+  string _testNameOverride;
+
+ public:
+  FunctionalTest();
+  virtual ~FunctionalTest();
+  void SMC_backgroundProcessing();
+
+  FunctionalTest& capture(int v);
+  FunctionalTest& pin(string v);
+  FunctionalTest& port(string v);
+  FunctionalTest& bitPerWord(int v);
+  FunctionalTest& processResults(int v);
+  FunctionalTest& pattern(string v);
+  FunctionalTest& testName(string v);
+
+  string testName() { return Base::testName(); }
+
+ protected:
+  typedef FunctionalTest super;
+  FunctionalTest& getThis();
+  ARRAY_I capturedData();
+  ARRAY_I capturedData(int);
+  void _setup();
+  void _execute();
+
+  string label;
+  vector<int> results;
+  string pinName;
+};
+}
+}
+#endif

data/{stdlib/v93k → src/advantest/smt7}/origen/origen/test_method.hpp

@@ -9,9 +9,7 @@
 using namespace std;
 
 namespace Origen {
-namespace TestMethod {
-
-}
+namespace TestMethod {}
 }
 
 #endif

data/src/advantest/smt7/origen/origen/utils/version.cpp

@@ -0,0 +1,72 @@
+#include "version.hpp"
+using namespace std;
+
+#include <sstream>
+
+namespace Origen {
+namespace Utils {
+
+Version::Version(string ver) {
+  vector<int> v = parse(ver);
+  _major = v[0];
+  _minor = v[1];
+  _tiny = v[2];
+}
+
+int Version::major() { return _major; }
+int Version::minor() { return _minor; }
+int Version::tiny() { return _tiny; }
+
+string Version::str() {
+  ostringstream str;
+  str << _major;
+  str << ".";
+  str << _minor;
+  str << ".";
+  str << _tiny;
+  return str.str();
+}
+
+bool Version::operator==(string rhs) {
+  vector<int> v = parse(rhs);
+  return _major == v[0] && _minor == v[1] && _tiny == v[2];
+}
+
+bool Version::operator!=(string rhs) {
+  vector<int> v = parse(rhs);
+  return _major != v[0] || _minor != v[1] || _tiny != v[2];
+}
+
+bool Version::operator<(string rhs) {
+  vector<int> v = parse(rhs);
+  return _major < v[0] || (_major == v[0] && _minor < v[1]) ||
+         (_major == v[0] && _minor == v[1] && _tiny < v[2]);
+}
+
+bool Version::operator<=(string rhs) {
+  return operator==(rhs) || operator<(rhs);
+}
+
+bool Version::operator>(string rhs) {
+  vector<int> v = parse(rhs);
+  return _major > v[0] || (_major == v[0] && _minor > v[1]) ||
+         (_major == v[0] && _minor == v[1] && _tiny > v[2]);
+}
+
+bool Version::operator>=(string rhs) {
+  return operator==(rhs) || operator>(rhs);
+}
+
+vector<int> Version::parse(string ver) {
+  vector<int> v(3);
+
+  istringstream parser(ver);
+  parser >> v[0];
+  for (int i = 1; i < 3; i++) {
+    parser.get();  // Skip dot
+    parser >> v[i];
+  }
+  return v;
+}
+}
+}

data/{stdlib/v93k → src/advantest/smt7}/origen/origen/utils/version.hpp

@@ -3,7 +3,8 @@
 
 // GCC adds these macros by default, which clobbers our functions
 // of the same name
-#if (defined(__GNUC__) || defined(__GNUG__)) && !(defined(__clang__) || defined(__INTEL_COMPILER))
+#if (defined(__GNUC__) || defined(__GNUG__)) && \
+    !(defined(__clang__) || defined(__INTEL_COMPILER))
 // Not exactly sure the version that this becomes a problem, but for
 // now this fixes the build on the V93K production system
 #if (__GNUC_MINOR__ > 1)
@@ -37,27 +38,25 @@ namespace Utils {
 //     // Do something
 //   }
 class Version {
-
-private:
-    vector<int> parse(string ver);
-    int _major;
-    int _minor;
-    int _tiny;
-
-public:
-    int major();
-    int minor();
-    int tiny();
-    Version(string ver);
-    bool operator==(string rhs);
-    bool operator!=(string rhs);
-    bool operator<(string rhs);
-    bool operator<=(string rhs);
-    bool operator>(string rhs);
-    bool operator>=(string rhs);
-    string str();
+ private:
+  vector<int> parse(string ver);
+  int _major;
+  int _minor;
+  int _tiny;
+
+ public:
+  int major();
+  int minor();
+  int tiny();
+  Version(string ver);
+  bool operator==(string rhs);
+  bool operator!=(string rhs);
+  bool operator<(string rhs);
+  bool operator<=(string rhs);
+  bool operator>(string rhs);
+  bool operator>=(string rhs);
+  string str();
 };
-
 }
 }
 

data/{stdlib/v93k → src/advantest/smt7}/origen/origen/utils.hpp

@@ -4,9 +4,7 @@
 #include "utils/version.hpp"
 
 namespace Origen {
-namespace Utils {
-
-}
+namespace Utils {}
 }
 
 #endif

data/src/advantest/smt7/origen/origen.cpp

@@ -0,0 +1,18 @@
+/** @file */
+#include "origen.hpp"
+
+namespace Origen {
+
+Utils::Version version() {
+  Utils::Version v(ORIGEN_VERSION);
+  return v;
+}
+
+vector<Site> Sites;
+
+Site& site() { return Sites[CURRENT_SITE_NUMBER()]; }
+
+Site& site(int site) { return Sites[site]; }
+
+bool invertFunctionalResults = false;
+}

data/{stdlib/v93k → src/advantest/smt7}/origen/origen.hpp

@@ -1,15 +1,15 @@
 #ifndef ORIGEN_HPP_INCLUDED
 #define ORIGEN_HPP_INCLUDED
 
-#define ORIGEN_VERSION "0.10.1"
+#define ORIGEN_VERSION "0.13.1"
 
 #ifndef debugger
 #define debugger __asm__("int $3");
 #endif
 
-#include "origen/utils.hpp"
 #include "origen/helpers.hpp"
 #include "origen/site.hpp"
+#include "origen/utils.hpp"
 
 namespace Origen {
 
@@ -17,6 +17,6 @@ extern vector<Site> Sites;
 Utils::Version version();
 Site& site();
 Site& site(int site);
-
+extern bool invertFunctionalResults;
 }
 #endif

data/src/advantest/smt7/origen/test_methods/ApplyBin.cpp

@@ -0,0 +1,37 @@
+#include "testmethod.hpp"
+
+// for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "origen.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class OrigenApplyBin : public testmethod::TestMethod {
+ protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize() {
+    // Add your initialization code here
+    // Note: Test Method API should not be used in this method!
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run() {
+    if (Origen::site().bin() || Origen::site().softbin()) {
+      stringstream softbin;
+      softbin << Origen::site().softbin();
+      SET_MULTIBIN(softbin.str(), Origen::site().bin());
+      TESTSET().judgeAndLog_FunctionalTest(false);
+    }
+  }
+};
+REGISTER_TESTMETHOD("ApplyBin", OrigenApplyBin);

data/src/advantest/smt7/origen/test_methods/DCMeasurement.cpp

@@ -0,0 +1,90 @@
+#include "origen/test_method/dc_measurement.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class OrigenDCMeasurement : public Origen::TestMethod::DCMeasurement {
+ protected:
+  int mApplyShutdown;
+  string mShutdownPattern;
+  string mMeasure;
+  double mSettlingTime;
+  string mPin;
+  string mPort;
+  double mForceValue;
+  double mIRange;
+  int mCheckShutdown;
+  int mBadc;
+
+ protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void init() {
+    // Add your initialization code here
+    // Note: Test Method API should not be used in this method!
+    addParameter("applyShutdown", "int", &mApplyShutdown,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setDefault("1")
+        .setComment("Apply a shutdown pattern after taking the measurement");
+    addParameter("shutdownPattern", "string", &mShutdownPattern,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setComment(
+            "The name of the shutdown pattern, by default it will be the main "
+            "pattern name appended with '_part1'");
+    addParameter("checkShutdown", "int", &mCheckShutdown,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setDefault("1")
+        .setComment("Check that the shutdown pattern passed (and fail if not)");
+    addParameter("measure", "string", &mMeasure, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("VOLT")
+        .setComment("Measure 'CURR' or 'VOLT' (the default)");
+    addParameter("settlingTime", "double", &mSettlingTime,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setDefault("0")
+        .setComment(
+            "Time to wait between running the pattern and taking the "
+            "measurement, expressed in ms");
+    addParameter("pin", "PinString", &mPin, testmethod::TM_PARAMETER_INPUT)
+        .setComment("Pin to be measured");
+    addParameter("port", "string", &mPort, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("")
+        .setComment("Port the pattern is to be executed on");
+    addParameter("forceValue", "double", &mForceValue,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setDefault("0")
+        .setComment("Value to be forced on the pin during the measurement");
+    addParameter("iRange", "double", &mIRange, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("0")
+        .setComment(
+            "The current range to apply to the measurement (in A), will be "
+            "calculated if not supplied (set to 0)");
+    addParameter("badc", "int", &mBadc, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("0")
+        .setComment(
+            "Perform the measurement using the Board ADC (rather than the "
+            "PPMU)");
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void body() {
+    origen.applyShutdown(mApplyShutdown)
+        .forceValue(mForceValue)
+        .shutdownPattern(mShutdownPattern)
+        .checkShutdown(mCheckShutdown)
+        .measure(mMeasure)
+        .settlingTime(mSettlingTime)
+        .pin(mPin)
+        .port(mPort)
+        .iRange(mIRange)
+        .badc(mBadc)
+        .execute();
+  }
+};
+REGISTER_TESTMETHOD("DCMeasurement", OrigenDCMeasurement);

data/src/advantest/smt7/origen/test_methods/FrequencyMeasurement.cpp

@@ -0,0 +1,50 @@
+#include "origen/test_method/frequency_measurement.hpp"
+
+class OrigenFrequencyMeasurement
+    : public Origen::TestMethod::FrequencyMeasurement {
+ protected:
+  int mPeriodBased;
+  string mPin;
+  string mPort;
+  int mSamples;
+  int mPeriodInNs;
+
+ protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void init() {
+    addParameter("periodBased", "int", &mPeriodBased,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setDefault("0")
+        .setComment(
+            "Set to 1 if the limits are expressed as a period instead of a "
+            "frequency (the default)");
+    addParameter("pin", "PinString", &mPin, testmethod::TM_PARAMETER_INPUT)
+        .setComment("Pin to be measured");
+    addParameter("port", "string", &mPort, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("")
+        .setComment("Port the pattern is to be executed on");
+    addParameter("samples", "int", &mSamples, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("2000")
+        .setComment(
+            "The number of captures made by the pattern, defaults to 2000");
+    addParameter("periodInNs", "int", &mPeriodInNs,
+                 testmethod::TM_PARAMETER_INPUT)
+        .setComment("The period of the capture vectors");
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void body() {
+    origen.periodBased(mPeriodBased)
+        .pin(mPin)
+        .port(mPort)
+        .samples(mSamples)
+        .periodInNs(mPeriodInNs)
+        .execute();
+  }
+};
+REGISTER_TESTMETHOD("FrequencyMeasurement", OrigenFrequencyMeasurement);

data/src/advantest/smt7/origen/test_methods/FunctionalTest.cpp

@@ -0,0 +1,24 @@
+#include "origen/test_method/functional_test.hpp"
+
+class OrigenFunctionalTest : public Origen::TestMethod::FunctionalTest {
+ protected:
+  string mPort;
+
+ protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void init() {
+    // NOTE: The capture arguments are not listed here since it makes no sense
+    // to use them without
+    //       corresponding functions to handle the captured data
+
+    addParameter("port", "string", &mPort, testmethod::TM_PARAMETER_INPUT)
+        .setDefault("")
+        .setComment("Port the pattern is to be executed on");
+  }
+
+  virtual void body() { origen.port(mPort).execute(); }
+};
+REGISTER_TESTMETHOD("FunctionalTest", OrigenFunctionalTest);

data/src/advantest/smt7/origen/test_methods/RecordBin.cpp

@@ -0,0 +1,39 @@
+#include "testmethod.hpp"
+
+// for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "origen.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class OrigenRecordBin : public testmethod::TestMethod {
+ protected:
+  int mBin;
+  int mSoftbin;
+
+ protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize() {
+    // Add your initialization code here
+    // Note: Test Method API should not be used in this method!
+    addParameter("bin", "int", &mBin, testmethod::TM_PARAMETER_INPUT);
+    addParameter("softbin", "int", &mSoftbin, testmethod::TM_PARAMETER_INPUT);
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run() {
+    Origen::site().bin(mBin);
+    Origen::site().softbin(mSoftbin);
+  }
+};
+REGISTER_TESTMETHOD("RecordBin", OrigenRecordBin);