Skip to content

S
swiftshader
Commit 89a7c2bd by Matt Wala
Options

Factor out common vector crosstesting code.

Add vectors.h and vector.def to hold vector type declarations and useful vector utilities. Change the existing tests to use this new header where applicable (arith, vector_ops). BUG=none R=jvoung@chromium.org, stichnot@chromium.org Review URL: https://codereview.chromium.org/407543003
parent 957c50d9
Showing with 270 additions and 133 deletions
crosstest/test_arith.h
//===- subzero/crosstest/test_arith.h - Test prototypes ---------*- C++ -*-===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the function prototypes used for crosstesting arithmetic
// operations.
//
//===----------------------------------------------------------------------===//
#include <stdint.h>
#include "test_arith.def"
// Vector types
typedef int32_t v4si32 __attribute__((vector_size(16)));
typedef uint32_t v4ui32 __attribute__((vector_size(16)));
typedef int16_t v8si16 __attribute__((vector_size(16)));
typedef uint16_t v8ui16 __attribute__((vector_size(16)));
typedef int8_t v16si8 __attribute__((vector_size(16)));
typedef uint8_t v16ui8 __attribute__((vector_size(16)));
typedef float v4f32 __attribute__((vector_size(16)));
#include "vectors.h"
#define X(inst, op, isdiv) \
bool test##inst(bool a, bool b); \
......
crosstest/test_arith_main.cpp
//===- subzero/crosstest/test_arith_main.cpp - Driver for tests -----------===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Driver for crosstesting arithmetic operations
//
//===----------------------------------------------------------------------===//
/* crosstest.py --test=test_arith.cpp --test=test_arith_frem.ll \
--test=test_arith_sqrt.ll --driver=test_arith_main.cpp \
--prefix=Subzero_ --output=test_arith */
......@@ -123,40 +136,15 @@ void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
}
}
// Vectors are deterministically constructed by selecting elements from
// a pool of scalar values based on a pseudorandom sequence. Testing
// all possible combinations of scalar values from the value table is
// not tractable.
// TODO: Replace with a portable PRNG from C++11.
class PRNG {
public:
PRNG(uint32_t Seed = 1) : State(Seed) {}
uint32_t operator()() {
// Lewis, Goodman, and Miller (1969)
State = (16807 * State) % 2147483647;
return State;
}
private:
uint32_t State;
};
const static size_t MaxTestsPerFunc = 100000;
template <typename Type, typename ElementType, typename CastType>
void outputVector(const Type Vect) {
const static size_t NumElementsInType = sizeof(Type) / sizeof(ElementType);
for (size_t i = 0; i < NumElementsInType; ++i) {
if (i > 0)
std::cout << ", ";
std::cout << (CastType) Vect[i];
}
}
template <typename TypeUnsigned, typename TypeSigned,
typename ElementTypeUnsigned, typename ElementTypeSigned>
template <typename TypeUnsignedLabel, typename TypeSignedLabel>
void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
typedef typename Vectors<TypeUnsignedLabel>::Ty TypeUnsigned;
typedef typename Vectors<TypeSignedLabel>::Ty TypeSigned;
typedef typename Vectors<TypeUnsignedLabel>::ElementTy ElementTypeUnsigned;
typedef typename Vectors<TypeSignedLabel>::ElementTy ElementTypeSigned;
typedef TypeUnsigned (*FuncTypeUnsigned)(TypeUnsigned, TypeUnsigned);
typedef TypeSigned (*FuncTypeSigned)(TypeSigned, TypeSigned);
volatile unsigned Values[] = INT_VALUE_ARRAY;
......@@ -185,8 +173,7 @@ void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
#undef X
};
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
const static size_t NumElementsInType =
sizeof(TypeUnsigned) / sizeof(ElementTypeUnsigned);
const static size_t NumElementsInType = Vectors<TypeUnsigned>::NumElements;
for (size_t f = 0; f < NumFuncs; ++f) {
PRNG Index;
for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
......@@ -209,16 +196,14 @@ void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
++Passes;
} else {
++Failures;
std::cout << "test" << Funcs[f].Name << "v" << NumElementsInType << "i"
<< (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "(";
outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(Value1);
std::cout << ", ";
outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(Value2);
std::cout << "): sz=";
outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(ResultSz);
std::cout << " llc=";
outputVector<TypeUnsigned, ElementTypeUnsigned, unsigned>(ResultLlc);
std::cout << std::endl;
<< (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "("
<< vectAsString<TypeUnsignedLabel>(Value1) << ","
<< vectAsString<TypeUnsignedLabel>(Value2)
<< "): sz=" << vectAsString<TypeUnsignedLabel>(ResultSz)
<< " llc=" << vectAsString<TypeUnsignedLabel>(ResultLlc)
<< std::endl;
}
}
}
......@@ -322,16 +307,11 @@ void testsVecFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
++Passes;
} else {
++Failures;
std::cout << std::fixed << "test" << Funcs[f].Name << "v4f32"
<< "(";
outputVector<v4f32, float, float>(Value1);
std::cout << ", ";
outputVector<v4f32, float, float>(Value2);
std::cout << "): sz=";
outputVector<v4f32, float, float>(ResultSz);
std::cout << " llc=";
outputVector<v4f32, float, float>(ResultLlc);
std::cout << std::endl;
std::cout << "test" << Funcs[f].Name << "v4f32"
<< "(" << vectAsString<v4f32>(Value1) << ","
<< vectAsString<v4f32>(Value2)
<< "): sz=" << vectAsString<v4f32>(ResultSz) << " llc"
<< vectAsString<v4f32>(ResultLlc) << std::endl;
}
}
}
......@@ -346,9 +326,9 @@ int main(int argc, char **argv) {
testsInt<uint16_t, int16_t>(TotalTests, Passes, Failures);
testsInt<uint32_t, int32_t>(TotalTests, Passes, Failures);
testsInt<uint64_t, int64_t>(TotalTests, Passes, Failures);
testsVecInt<v4ui32, v4si32, uint32_t, int32_t>(TotalTests, Passes, Failures);
testsVecInt<v8ui16, v8si16, uint16_t, int16_t>(TotalTests, Passes, Failures);
testsVecInt<v16ui8, v16si8, uint8_t, int8_t>(TotalTests, Passes, Failures);
testsVecInt<v4ui32, v4si32>(TotalTests, Passes, Failures);
testsVecInt<v8ui16, v8si16>(TotalTests, Passes, Failures);
testsVecInt<v16ui8, v16si8>(TotalTests, Passes, Failures);
testsFp<float>(TotalTests, Passes, Failures);
testsFp<double>(TotalTests, Passes, Failures);
testsVecFp(TotalTests, Passes, Failures);
......
crosstest/test_vector_ops.h 0 → 100644
//===- subzero/crosstest/test_vector_ops.h - Test prototypes ----*- C++ -*-===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the function prototypes for crosstesting insertelement
// and extractelement operations.
//
//===----------------------------------------------------------------------===//
#ifndef TEST_VECTOR_OPS_H
#define TEST_VECTOR_OPS_H
#include "vectors.h"
// The VectorOps<> class acts like Vectors<> but also has insertelement,
// Subzero_insertelement, extractelement, and Subzero_extractelement
// fields.
template <typename T> struct VectorOps;
#define FIELD(TYNAME, FIELDNAME) VectorOps<TYNAME>::FIELDNAME
#define TY(TYNAME) FIELD(TYNAME, Ty)
#define CASTTY(TYNAME) FIELD(TYNAME, CastTy)
#define DECLARE_VECTOR_OPS(NAME) \
template <> struct VectorOps<NAME> : public Vectors<NAME> { \
static Ty (*insertelement)(Ty, CastTy, int32_t); \
static CastTy (*extractelement)(Ty, int32_t); \
static Ty (*Subzero_insertelement)(Ty, CastTy, int32_t); \
static CastTy (*Subzero_extractelement)(Ty, int32_t); \
}; \
extern "C" { \
TY(NAME) insertelement_##NAME(TY(NAME), CASTTY(NAME), int32_t); \
TY(NAME) Subzero_insertelement_##NAME(TY(NAME), CASTTY(NAME), int32_t); \
CASTTY(NAME) extractelement_##NAME(TY(NAME), int32_t); \
CASTTY(NAME) Subzero_extractelement_##NAME(TY(NAME), int32_t); \
} \
TY(NAME) (*FIELD(NAME, insertelement))(TY(NAME), CASTTY(NAME), int32_t) = \
&insertelement_##NAME; \
TY(NAME) (*FIELD(NAME, Subzero_insertelement))( \
TY(NAME), CASTTY(NAME), int32_t) = &Subzero_insertelement_##NAME; \
CASTTY(NAME) (*FIELD(NAME, extractelement))(TY(NAME), int32_t) = \
&extractelement_##NAME; \
CASTTY(NAME) (*FIELD(NAME, Subzero_extractelement))(TY(NAME), int32_t) = \
&Subzero_extractelement_##NAME;
#define X(ty, eltty, castty) DECLARE_VECTOR_OPS(ty)
VECTOR_TYPE_TABLE
#undef X
#define X(ty, eltty, numelements) DECLARE_VECTOR_OPS(ty)
I1_VECTOR_TYPE_TABLE
#undef X
#endif // TEST_VECTOR_OPS_H
crosstest/test_vector_ops_main.cpp
//===- subzero/crosstest/test_vector_ops_main.cpp - Driver for tests ------===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Driver for crosstesting insertelement and extractelement operations
//
//===----------------------------------------------------------------------===//
/* crosstest.py --test=test_vector_ops.ll --driver=test_vector_ops_main.cpp \
--prefix=Subzero_ --output=test_vector_ops */
#include <stdint.h>
#include <cstring>
#include <sstream>
#include <iostream>
#include <limits>
#include <utility>
#include <vector>
#include <stdlib.h>
#include "test_vector_ops.def"
// typedefs of native C++ SIMD vector types
#define X(ty, elty, castty) typedef elty ty __attribute__((vector_size(16)));
VECTOR_TYPE_TABLE
#undef X
// i1 vector types are not native C++ SIMD vector types. Instead, they
// are expanded by the test code into native 128 bit SIMD vector types
// with the appropriate number of elements. Representing the types in
// VectorOps<> requires a unique name for each type which this
// declaration provides.
#define X(ty, expandedty, num_elements) \
class ty;
I1_VECTOR_TYPE_TABLE
#undef X
template <typename T> struct VectorOps;
#define DECLARE_VECTOR_OPS(TYNAME, TY, ELTY, CASTTY, NUM_ELEMENTS) \
template <> struct VectorOps<TYNAME> { \
typedef TY Ty; \
typedef ELTY ElementTy; \
typedef CASTTY CastTy; \
static TY (*insertelement)(TY, CASTTY, int32_t); \
static TY (*Subzero_insertelement)(TY, CASTTY, int32_t); \
static CASTTY (*extractelement)(TY, int32_t); \
static CASTTY (*Subzero_extractelement)(TY, int32_t); \
static size_t NumElements; \
static const char *TypeName; \
}; \
extern "C" TY insertelement_##TYNAME(TY, CASTTY, int32_t); \
extern "C" TY Subzero_insertelement_##TYNAME(TY, CASTTY, int32_t); \
extern "C" CASTTY extractelement_##TYNAME(TY, int32_t); \
extern "C" CASTTY Subzero_extractelement_##TYNAME(TY, int32_t); \
size_t VectorOps<TYNAME>::NumElements = NUM_ELEMENTS; \
TY (*VectorOps<TYNAME>::insertelement)(TY, CASTTY, int32_t) = \
&insertelement_##TYNAME; \
TY (*VectorOps<TYNAME>::Subzero_insertelement)(TY, CASTTY, int32_t) = \
&Subzero_insertelement_##TYNAME; \
CASTTY (*VectorOps<TYNAME>::extractelement)(TY, int32_t) = \
&extractelement_##TYNAME; \
CASTTY (*VectorOps<TYNAME>::Subzero_extractelement)(TY, int32_t) = \
&Subzero_extractelement_##TYNAME; \
const char *VectorOps<TYNAME>::TypeName = #TYNAME;
#define X(ty, elty, castty) \
DECLARE_VECTOR_OPS(ty, ty, elty, castty, (sizeof(ty) / sizeof(elty)))
VECTOR_TYPE_TABLE
#undef X
#define X(ty, expandedty, num_elements) \
DECLARE_VECTOR_OPS(ty, expandedty, bool, int64_t, num_elements)
I1_VECTOR_TYPE_TABLE
#undef X
template <typename T>
std::string vectAsString(const typename VectorOps<T>::Ty Vect) {
std::ostringstream OS;
for (size_t I = 0; I < VectorOps<T>::NumElements; ++I) {
if (I > 0)
OS << " ";
OS << (typename VectorOps<T>::CastTy)Vect[I];
}
return OS.str();
}
#include "test_vector_ops.h"
// Return a set of test vectors for the given vector type. Due to lack
// of an aligned allocator in C++, the returned value is allocated with
// posix_memalign() and should be freed with free().
template <typename T>
typename VectorOps<T>::Ty *getTestVectors(size_t &NumTestVectors) {
typedef typename VectorOps<T>::Ty Ty;
......
crosstest/vectors.def 0 → 100644
//===- subzero/crosstest/vectors.def - macros for tests -------*- C++ -*---===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines macros for crosstesting vectors.
//
//===----------------------------------------------------------------------===//
#ifndef VECTORS_DEF
#define VECTORS_DEF
#define VECTOR_TYPE_TABLE \
/* typename, element type, cast type */ \
X(v16si8, int8_t, int64_t) \
X(v16ui8, uint8_t, int64_t) \
X(v8si16, int16_t, int64_t) \
X(v8ui16, uint16_t, int64_t) \
X(v4si32, int32_t, int64_t) \
X(v4ui32, uint32_t, int64_t) \
X(v4f32, float, float)
// define X(ty, eltty, castty)
#define I1_VECTOR_TYPE_TABLE \
/* typename, expanded type, # elements */ \
X(v4i1, v4si32, 4) \
X(v8i1, v8si16, 8) \
X(v16i1, v16si8, 16)
// define X(ty, eltty, numelements)
#endif // VECTORS_DEF
crosstest/vectors.h 0 → 100644
//===- subzero/crosstest/vectors.h - Common SIMD vector utilies -*- C++ -*-===//
//
// The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides declarations for PNaCl portable SIMD vector types. In
// addition, this file provides utilies that may be useful for crosstesting
// vector code.
//
//===----------------------------------------------------------------------===//
#ifndef VECTORS_H
#define VECTORS_H
#include <stdint.h>
#include <string>
#include <sstream>
#include "vectors.def"
// PNaCl portable vector types
// Types declared: v4si32, v4ui32, v8si16, v8ui16, v16si8, v16ui8, v4f32
#define X(ty, eltty, castty) typedef eltty ty __attribute__((vector_size(16)));
VECTOR_TYPE_TABLE
#undef X
// i1 vector types are not native C++ SIMD vector types. Instead, for
// testing, they are expanded by the test code into native 128 bit
// SIMD vector types with the appropriate number of elements.
// Representing the types in Vectors<> requires a unique label for each
// type which this declaration provides.
// Types declared: v4i1, v8i1, v16i1
#define X(ty, expandedty, numelements) class ty;
I1_VECTOR_TYPE_TABLE
#undef X
namespace {
template <typename T> struct Vectors;
// Vectors<T> provides information about a vector type with label T:
// * Vectors<T>::Ty is the C++ vector type
// * Vectors<T>::ElementTy is the C++ element type
// * Vectors<T>::CastTy is a type that is safe to cast elements to and from
// and is used for getting the representation of elements in ostreams
// * Vectors<T>::NumElements is the number of elements
// * Vectors<T>::TypeName is a string that names the type
#define DECLARE_VECTOR_TYPE(LABEL, TY, ELTTY, CASTTY, NUM_ELEMENTS) \
template <> struct Vectors<LABEL> { \
typedef TY Ty; \
typedef ELTTY ElementTy; \
typedef CASTTY CastTy; \
static const size_t NumElements; \
static const char *const TypeName; \
}; \
const size_t Vectors<LABEL>::NumElements = NUM_ELEMENTS; \
const char *const Vectors<LABEL>::TypeName = #LABEL;
#define X(ty, eltty, castty) \
DECLARE_VECTOR_TYPE(ty, ty, eltty, castty, (sizeof(ty) / sizeof(eltty)))
VECTOR_TYPE_TABLE
#undef X
#define X(ty, expandedty, numelements) \
DECLARE_VECTOR_TYPE(ty, expandedty, bool, int64_t, numelements)
I1_VECTOR_TYPE_TABLE
#undef X
#undef DECLARE_VECTOR_TYPE
// Return a string representation of the vector.
template <typename T>
std::string vectAsString(const typename Vectors<T>::Ty Vect) {
std::ostringstream OS;
for (size_t i = 0; i < Vectors<T>::NumElements; ++i) {
if (i > 0)
OS << " ";
OS << (typename Vectors<T>::CastTy)Vect[i];
}
return OS.str();
}
// In some crosstests, test vectors are deterministically constructed by
// selecting elements from a pool of scalar values based on a
// pseudorandom sequence. Testing all possible combinations of scalar
// values from the value pool is often not tractable.
//
// TODO: Replace with a portable PRNG from C++11.
class PRNG {
public:
PRNG(uint32_t Seed = 1) : State(Seed) {}
uint32_t operator()() {
// Lewis, Goodman, and Miller (1969)
State = (16807 * State) % 2147483647;
return State;
}
private:
uint32_t State;
};
} // end anonymous namespace
#endif // VECTORS_H
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment