origen_std_lib 0.10.1 → 0.11.0

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

@@ -0,0 +1,13 @@
+#include "empty.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+Empty::Empty() {}
+
+Empty::~Empty() {}
+
+// All test methods must implement this function
+Empty& Empty::getThis() { return *this; }
+}
+}

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

@@ -0,0 +1,24 @@
+#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 Empty : public Base {
+ public:
+  Empty();
+  virtual ~Empty();
+
+ protected:
+  typedef Empty super;
+  Empty& getThis();
+};
+}
+}
+#endif

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

@@ -0,0 +1,133 @@
+#include "frequency_measurement.hpp"
+
+namespace Origen {
+namespace TestMethod {
+
+// Defaults
+FrequencyMeasurement::FrequencyMeasurement() {
+  samples(2000);
+  processResults(1);
+  port("");
+}
+FrequencyMeasurement::~FrequencyMeasurement() {}
+
+/// By default the limits are assumed to be expressed as a frequency, set this
+/// to 1 if they refer to a target period
+FrequencyMeasurement& FrequencyMeasurement::periodBased(int v) {
+  _periodBased = v;
+  return *this;
+}
+/// REQUIRED: The name of the pin being measured
+FrequencyMeasurement& FrequencyMeasurement::pin(string v) {
+  _pin = v;
+  return *this;
+}
+/// Optionally supply the name of the test port that should be used to execute
+/// the pattern
+FrequencyMeasurement& FrequencyMeasurement::port(string v) {
+  _port = v;
+  return *this;
+}
+/// The number of samples captured by the pattern, the default is 2000
+FrequencyMeasurement& FrequencyMeasurement::samples(int v) {
+  _samples = v;
+  return *this;
+}
+/// REQUIRED: Supply the period of the captured vectors in nanoseconds
+FrequencyMeasurement& FrequencyMeasurement::periodInNs(int v) {
+  _periodInNs = v;
+  return *this;
+}
+/// When set to 0 the results of the test will not be judged or logged
+FrequencyMeasurement& FrequencyMeasurement::processResults(int v) {
+  _processResults = v;
+  return *this;
+}
+
+// All test methods must implement these functions
+FrequencyMeasurement& FrequencyMeasurement::getThis() { return *this; }
+
+void FrequencyMeasurement::_setup() {
+  funcResults.resize(numberOfPhysicalSites + 1);
+  label = Primary.getLabel();
+  pin(extractPinsFromGroup(_pin));
+}
+
+void FrequencyMeasurement::_execute() {
+  int site;
+
+  ON_FIRST_INVOCATION_BEGIN();
+
+  RDI_BEGIN();
+
+  if (_port.empty()) {
+    SMART_RDI::DIG_CAP& prdi =
+        rdi.digCap(suiteName).label(label).pin(_pin).bitPerWord(1).samples(
+            _samples);
+
+    filterRDI(prdi);
+    prdi.execute();
+
+  } else {
+    SMART_RDI::DIG_CAP& prdi = rdi.port(_port)
+                                   .digCap(suiteName)
+                                   .vecVarOnly()
+                                   .pin(_pin)
+                                   .bitPerWord(1)
+                                   .samples(_samples);
+
+    filterRDI(prdi);
+    prdi.execute();
+    rdi.port(_port).func().burst(label).execute();
+  }
+
+  RDI_END();
+
+  FOR_EACH_SITE_BEGIN();
+  site = CURRENT_SITE_NUMBER();
+  funcResults[site] = rdi.getBurstPassFail();
+  FOR_EACH_SITE_END();
+
+  ON_FIRST_INVOCATION_END();
+}
+
+void FrequencyMeasurement::serialProcessing(int site) {
+  if (_processResults) {
+    double result;
+    ARRAY_I captureData = rdi.site(site).id(suiteName).getVector();
+
+    if (_periodBased) {
+      result = calculatePeriod(captureData, _periodInNs);
+    } else {
+      result = calculateFrequency(captureData, _periodInNs);
+    }
+
+    judgeAndDatalog(testName() + "_FUNC",
+                    invertFunctionalResultIfRequired(funcResults[site]));
+
+    judgeAndDatalog(filterResult(result));
+  }
+}
+
+void FrequencyMeasurement::SMC_backgroundProcessing() {
+  double result;
+
+  for (int i = 0; i < activeSites.size(); i++) {
+    int site = activeSites[i];
+    process(site);
+    if (_processResults) {
+      ARRAY_I captureData = rdi.site(site).id(suiteName).getVector();
+      if (_periodBased) {
+        result = calculatePeriod(captureData, _periodInNs);
+      } else {
+        result = calculateFrequency(captureData, _periodInNs);
+      }
+      SMC_TEST(site, "", suiteName, LIMIT(TM::GE, 1, TM::LE, 1),
+               funcResults[site]);
+      SMC_TEST(site, _pin, suiteName, testLimits().TEST_API_LIMIT,
+               filterResult(result));
+    }
+  }
+}
+}
+}

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

@@ -0,0 +1,46 @@
+#ifndef ORIGEN_TEST_METHOD_FREQUENCY_MEASUREMENT_INCLUDED
+#define ORIGEN_TEST_METHOD_FREQUENCY_MEASUREMENT_INCLUDED
+
+#include "base.hpp"
+#include "mapi.hpp"
+#include "rdi.hpp"
+
+using namespace std;
+
+namespace Origen {
+namespace TestMethod {
+
+class FrequencyMeasurement : public Base {
+  void serialProcessing(int site);
+
+  int _periodBased;
+  string _pin;
+  string _port;
+  int _samples;
+  int _periodInNs;
+  int _processResults;
+
+ public:
+  FrequencyMeasurement();
+  virtual ~FrequencyMeasurement();
+  void SMC_backgroundProcessing();
+
+  FrequencyMeasurement& periodBased(int v);
+  FrequencyMeasurement& pin(string v);
+  FrequencyMeasurement& port(string v);
+  FrequencyMeasurement& samples(int v);
+  FrequencyMeasurement& periodInNs(int v);
+  FrequencyMeasurement& processResults(int v);
+
+ protected:
+  typedef FrequencyMeasurement super;
+  FrequencyMeasurement& getThis();
+  void _setup();
+  void _execute();
+
+  string label;
+  vector<int> funcResults;
+};
+}
+}
+#endif

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/utils.hpp

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