origen_std_lib 0.7.0 → 0.8.0

data/stdlib/v93k/origen/Debug/test_methods/subdir.mk

@@ -0,0 +1,36 @@
+################################################################################
+# Automatically-generated file. Do not edit!
+################################################################################
+
+# Add inputs and outputs from these tool invocations to the build variables 
+CPP_SRCS += \
+../test_methods/ApplyBin.cpp \
+../test_methods/DCMeasurement.cpp \
+../test_methods/FrequencyMeasurement.cpp \
+../test_methods/FunctionalTest.cpp \
+../test_methods/RecordBin.cpp 
+
+OBJS += \
+./test_methods/ApplyBin.o \
+./test_methods/DCMeasurement.o \
+./test_methods/FrequencyMeasurement.o \
+./test_methods/FunctionalTest.o \
+./test_methods/RecordBin.o 
+
+CPP_DEPS += \
+./test_methods/ApplyBin.d \
+./test_methods/DCMeasurement.d \
+./test_methods/FrequencyMeasurement.d \
+./test_methods/FunctionalTest.d \
+./test_methods/RecordBin.d 
+
+
+# Each subdirectory must supply rules for building sources it contributes
+test_methods/%.o: ../test_methods/%.cpp
+	@echo 'Building file: $<'
+	@echo 'Invoking: GCC C++ Compiler'
+	g++ -D_TM_CDIR='"/home/nxa21353/devices/jn518x_test_program.1.0.0.pre16/origen_std_lib/v93k/src/origen"' -I/opt/hp93000/soc/prod_com/include -I"/home/nxa21353/devices/jn518x_test_program.1.0.0.pre16/origen_std_lib/v93k/src/origen" -I/opt/hp93000/soc/prod_com/include/MAPI -I/opt/hp93000/soc/testmethod/include -I/opt/hp93000/soc/com/include -I/opt/hp93000/soc/pws/lib -I/opt/hp93000/soc/segments/tml/include -I/opt/hp93000/soc/segments/tml/include/ext_include -I/opt/hp93000/soc/prod_com/rdi/include -O0 -g3 -Wall -c -fmessage-length=0 -fpic -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o "$@" "$<"
+	@echo 'Finished building: $<'
+	@echo ' '
+
+

data/stdlib/v93k/origen/origen.cpp

@@ -0,0 +1,22 @@
+/** @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];
+}
+
+}

data/stdlib/v93k/origen/origen.hpp

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

data/stdlib/v93k/origen/origen/helpers.hpp

@@ -0,0 +1,44 @@
+#ifndef ORIGEN_HELPERS_INCLUDED
+#define ORIGEN_HELPERS_INCLUDED
+
+#include "mapi.hpp"
+#include "rdi.hpp"
+#include <string>
+
+using namespace std;
+
+namespace Origen {
+
+string extractPinsFromGroup(const string&);
+void synchronize(double = 1);
+double calculateFrequency(const ARRAY_I&, double);
+double calculatePeriod(const ARRAY_I&, double);
+void overlaySubroutine(string, string, uint64_t, int);
+void reverseOverlaySubroutine(string, string, uint64_t, int);
+int numberOfOnes(uint32_t);
+int64_t toInt (string, int = 0);
+uint64_t toUInt (string, int = 0);
+vector<string> split(const string&, char);
+void split(const string&, char, vector<string>&);
+string toHex (const uint64_t&);
+string toStr (const uint64_t&);
+void initializeSites();
+void logParametricTest(string, int, double, LIMIT, string);
+void logFunctionalTest(string, int, bool, string);
+bool isPass(double, LIMIT);
+string loStr(LIMIT);
+string hiStr(LIMIT);
+string upcase(string);
+string lpad(string, int, char);
+string rpad(string, int, char);
+bool isEven(uint64_t);
+bool isOdd(uint64_t);
+LIMIT noLimits();
+uint64_t flip(uint64_t, int);
+string ltrim(string, const char * remove_chars = " \n\t\r\f\v");
+string rtrim(string, const char * remove_chars = " \n\t\r\f\v");
+string trim(string, const char * remove_chars = " \n\t\r\f\v");
+
+}
+
+#endif

data/stdlib/v93k/origen/origen/helpers/console.cpp

@@ -0,0 +1,105 @@
+/** @file */
+#include "../helpers.hpp"
+#include <cerrno>
+#include <stdlib.h>
+#include "../../origen.hpp"
+
+using namespace std;
+
+namespace Origen {
+
+/// Prints the result of a parametric test to the console
+void logParametricTest(string name, int site, double result, LIMIT limits, string pin) {
+
+    cout << site << " ";
+    if (isPass(result, limits))
+        cout << "     ";
+    else
+        cout << "FAIL ";
+    cout << left << setw(65) << setfill(' ') << name << "  ";
+    cout << left << setw(20) << setfill(' ') << loStr(limits) << "  ";
+    cout << left << setw(20) << setfill(' ') << result;
+    cout << left << setw(20) << setfill(' ') << hiStr(limits);
+    cout << pin << endl;
+
+}
+
+/// Returns a LIMIT object with no limits enabled
+LIMIT noLimits() {
+	return LIMIT(TM::NA, 0, TM::NA, 0);
+}
+
+/// Prints the result of a functional test to the console
+void logFunctionalTest(string name, int site, bool passed, string pattern) {
+    cout << site << " ";
+    if (passed)
+        cout << "     ";
+    else
+        cout << "FAIL ";
+    cout << left << setw(65) << setfill(' ') << name << "  ";
+    cout << pattern << endl;
+}
+
+/// Converts the low limit in the given LIMIT object into a string, where an empty string will be returned if the limit is not enabled
+string loStr(LIMIT limits) {
+    double lo = 0.0;
+    double * plo = &lo;
+    TM::COMPARE clo;
+
+    clo = limits.getLow(plo);
+
+    if (clo == TM::NA) {
+        return "";
+    } else {
+        stringstream val;
+        val << lo;
+        return val.str();
+    }
+}
+
+/// Converts the high limit in the given LIMIT object into a string, where an empty string will be returned if the limit is not enabled
+string hiStr(LIMIT limits) {
+    double hi = 0.0;
+    double * phi = &hi;
+    TM::COMPARE chi;
+
+    chi = limits.getHigh(phi);
+
+    if (chi == TM::NA) {
+        return "";
+    } else {
+        stringstream val;
+        val << hi;
+        return val.str();
+    }
+}
+/// Returns true if the result is within the given limits
+bool isPass(double val, LIMIT limits) {
+    double lo = 0.0;
+    double hi = 0.0;
+    double * plo = &lo;
+    double * phi = &hi;
+    TM::COMPARE clo, chi;
+    bool result;
+
+    clo = limits.getLow(plo);
+    chi = limits.getHigh(phi);
+
+    result = true;
+
+    if (clo != TM::NA) {
+        if (clo == TM::GE && val < lo)
+            result = false;
+        if (clo == TM::GT && val <= lo)
+            result = false;
+    }
+    if (chi != TM::NA) {
+        if (chi == TM::LE && val > hi)
+            result = false;
+        if (chi == TM::LT && val >= hi)
+            result = false;
+    }
+    return result;
+}
+
+}

data/stdlib/v93k/origen/origen/helpers/misc.cpp

@@ -0,0 +1,305 @@
+/** @file */ 
+#include "../helpers.hpp"
+#include <cerrno>
+#include <stdlib.h>
+#include "../../origen.hpp"
+
+using namespace std;
+
+namespace Origen {
+
+
+uint64_t flip(uint64_t input, int size) {
+	uint64_t output = 0;
+	for (int i = 0; i < size; i++) {
+		output <<= 1;
+		output |= input & 1;
+		input >>= 1;
+	}
+	return output;
+}
+
+
+/// Split the given string by the given delimiter and return the results in a vector of strings
+///
+///   split("AB1234-24", '-')   // => ["AB1234", "24"]
+vector<string> split(const string &str, char delim) {
+    vector<string> elems;
+    split(str, delim, elems);
+    return elems;
+}
+
+/// This version places the result in the supplied vector rather than returning a new one
+void split(const string &str, char delim, vector<string> &elems) {
+    stringstream ss;
+    ss.str(str);
+    string item;
+    while (getline(ss, item, delim)) {
+        elems.push_back(item);
+    }
+}
+
+///
+string ltrim(string str, const char * remove_chars /* = " \n\t\r\f\v" */) {
+	str.erase(0, str.find_first_not_of(remove_chars));
+	return str;
+}
+
+
+string rtrim(string str, const char * remove_chars /* = " \n\t\r\f\v" */) {
+	str.erase(str.find_last_not_of(remove_chars)+1);
+	return str;
+}
+
+
+string trim(string str, const char * remove_chars /* = " \n\t\r\f\v" */) {
+	str = rtrim(str, remove_chars);
+	str = ltrim(str, remove_chars);
+	return str;
+}
+
+
+/// Convert the given string to a 64-bit integer. Works for both decimal and hex strings as
+/// shown in the examples below.
+///
+/// If the string is not successfully converted the site in focus will be binned out.
+///
+///   toInt("0xFF")         // => 255
+///   toInt("FF", 16)       // => 255 (must declare base 16 if no leading 0x)
+///   toInt("255")          // => 255
+int64_t toInt (string str, int base)
+{
+	str = trim(str);        // Remove any whitespace
+	str = ltrim(str, "0");  // Remove any leading 0's
+	if (str == "") {
+		return 0;
+	}
+    char *end;
+    char *cstr = const_cast<char*>(str.c_str());
+    long long int l;
+    errno = 0;
+    l = strtoll(cstr, &end, base);
+    if ((errno == ERANGE && l == LLONG_MAX) || l > LLONG_MAX) {
+        cout << "ERROR: String conversion overflowed a 64-bit integer - " << str << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    if ((errno == ERANGE && l == LLONG_MIN) || l < LLONG_MIN) {
+        cout << "ERROR: String conversion underflowed a 64-bit integer - " << str << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    if (*cstr == '\0' || *end != '\0') {
+        cout << "ERROR: String is not convertible to a 64-bit integer - " << str << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    return (int64_t) l;
+}
+
+/// See toInt, but returns an unsigned 64-bit integer
+uint64_t toUInt (string str, int base)
+{
+	str = trim(str);        // Remove any whitespace
+	str = ltrim(str, "0");  // Remove any leading 0's
+	if (str == "") {
+		return 0;
+	}
+
+    char *end;
+    char *cstr = const_cast<char*>(str.c_str());
+    unsigned long long int l;
+    errno = 0;
+    l = strtoull(cstr, &end, base);
+    if (errno == ERANGE && l == ULLONG_MAX) {
+        cout << "ERROR: String conversion was out of the range of a UInt64 - " << str << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    if (*cstr == '\0' || *end != '\0') {
+        cout << "ERROR: String is not convertible to a UInt64 - " << str << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+    return (uint64_t) l;
+}
+
+/// Convert the given number to a hex string
+///
+///   toHex(255);    // => "ff"
+string toHex (const uint64_t &val)
+{
+    stringstream stream;
+    stream << hex << val;
+    return stream.str();
+}
+
+/// Convert the given number to a string
+///
+///   toStr(255);    // => "255"
+string toStr (const uint64_t &val)
+{
+    stringstream stream;
+    stream << val;
+    return stream.str();
+}
+
+/// Uppercase the given string
+///
+///   upcase("ff");  // => "FF"
+string upcase(string base) {
+	transform(base.begin(), base.end(), base.begin(), ::toupper);
+	return base;
+}
+
+/// Extend the string to the given size, padding with the given character on the left
+///
+///   lpad("FF", 4, '0');  // => "00FF"
+string lpad(string base, int length, char fill) {
+	stringstream padded;
+	padded << right << setw(length) << setfill(fill) << base;
+	return padded.str();
+}
+
+/// Extend the string to the given size, padding with the given character on the right
+///
+///   rpad("FF", 4, ' ');  // => "FF  "
+string rpad(string base, int length, char fill) {
+	stringstream padded;
+	padded << left << setw(length) << setfill(fill) << base;
+	return padded.str();
+}
+
+/// Returns true if the given number is even
+bool isEven(uint64_t number) {
+	return number % 2 == 0;
+}
+
+/// Returns true if the given number is odd
+bool isOdd(uint64_t number) {
+	return number % 2 != 0;
+}
+
+/// Overlays the given data on the given pin, starting from the first vector of the given pattern
+void overlaySubroutine(string subroutinePattern, string pin, uint64_t data, int size) {
+    string p = extractPinsFromGroup(pin);
+    string pat = subroutinePattern;
+	VEC_LABEL_EDIT ov(pat, p);
+
+	// Need to use a vector here so the size can be determined at runtime
+	vector<VECTOR_DATA> vecData(size);
+
+	for(int i = 0; i < size; i++) {
+		int val = (data & (1 << i)) >> i;
+		VECTOR_DATA v = {i, val};
+		vecData[i] = v;
+	}
+
+	// However the downloadUserVectors function only accepts an array, so use this trick
+	// to create an array instance that points to the vector data
+	VECTOR_DATA * vecDataArray = &vecData[0];
+
+	ov.downloadUserVectors(vecDataArray, size);
+}
+
+/// Same as overlaySubroutine but the data is applied in reverse order
+void reverseOverlaySubroutine(string subroutinePattern, string pin, uint64_t data, int size) {
+    string p = extractPinsFromGroup(pin);
+    string pat = subroutinePattern;
+	VEC_LABEL_EDIT ov(pat, p);
+
+	// Need to use a vector here so the size can be determined at runtime
+	vector<VECTOR_DATA> vecData(size);
+
+	for(int i = 0; i < size; i++) {
+	    int j = size - 1 - i;
+		int val = (data & (1 << j)) >> j;
+		VECTOR_DATA v = {i, val};
+		vecData[i] = v;
+	}
+
+	// However the downloadUserVectors function only accepts an array, so use this trick
+	// to create an array instance that points to the vector data
+	VECTOR_DATA * vecDataArray = &vecData[0];
+
+	ov.downloadUserVectors(vecDataArray, size);
+}
+
+/// Returns the number of 1's (bits that are set) in the given 32-bit number
+int numberOfOnes(uint32_t i)
+{
+     i = i - ((i >> 1) & 0x55555555);
+     i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
+     return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
+}
+
+
+double calculateFrequency(const ARRAY_I &captureData, double periodInNs) {
+    int	iFreqCount;
+    double dFreq_MHz;
+
+    iFreqCount=0;
+    for(int j=0; j<captureData.size()-1; j++)
+    {
+        if((captureData[j+1] - captureData[j]) == 1){
+            iFreqCount++;
+        }
+    }
+    dFreq_MHz = iFreqCount / ((periodInNs / 1000) * captureData.size());
+    return dFreq_MHz * 1000000;
+}
+
+double calculatePeriod(const ARRAY_I &captureData, double periodInNs) {
+    return 1 / calculateFrequency(captureData, periodInNs);
+}
+
+/// Call to wait for all SMC threads to complete, supply the max amount of seconds to wait
+void synchronize(double timeout)
+{
+    bool ok;
+    int site = CURRENT_SITE_NUMBER();
+
+    if (timeout) {
+        ok = SMC_SYNCHRONIZE(timeout s);
+    } else {
+        ok = SMC_SYNCHRONIZE();
+    }
+
+    if (! ok) {
+        cout << "ERROR: All SMC threads not complete after " << timeout << " second(s) on site " << site << endl;
+        ERROR_EXIT(TM::EXIT_FLOW);
+    }
+}
+
+/// Supply a pin alias name and get the name of the physical pin returned
+string extractPinsFromGroup(const string& groupname)
+{
+    string pinlist;
+
+    try{
+        pinlist = PinUtility.createPinListFromPinNames(PinUtility.getDigitalPinNamesFromPinList(groupname, TM::ALL_DIGITAL,true,true,PIN_UTILITY::DEFINITION_ORDER));
+    } catch(...) {
+        cout << "ERROR: Pingroup " << groupname << " not found." << endl;
+        ERROR_EXIT(TM::ABORT_FLOW);
+    }
+
+    return pinlist;
+}
+
+// Initializes the site objects that are used to store the ECID, this should be called at
+// the start of the test flow if using the Origen.site API
+void initializeSites() {
+    INT num_of_sites;
+    ARRAY_I sites;
+
+    ON_FIRST_INVOCATION_BEGIN();
+
+        num_of_sites = GET_CONFIGURED_SITES(sites);
+
+        // Leave an empty space at 0, easier then to fetch by site number (which start at 1)
+        Origen::Sites.resize(num_of_sites + 1, Origen::Site(0));
+
+    ON_FIRST_INVOCATION_END();
+
+    // Instantiate a new site object and save it in the global site array
+    Origen::Site site(CURRENT_SITE_NUMBER());
+
+    Origen::Sites[CURRENT_SITE_NUMBER()] = site;
+}
+
+}