std::string result = "";

// Using a for loop to read the next non empty line

for (std::string line; std::getline(file, line);) {

result += line;

if (result != "") break;

}

// If no file has been found, throw an exception

if (result == "") {

throw std::runtime_error("Non empty lines not found in the file");

}

return result;

af::Backend backend = af::getActiveBackend();

switch (backend) {

case AF_BACKEND_CPU:

return lower ? std::string("cpu") : std::string("CPU");

case AF_BACKEND_CUDA:

return lower ? std::string("cuda") : std::string("CUDA");

case AF_BACKEND_OPENCL:

return lower ? std::string("opencl") : std::string("OpenCL");

case AF_BACKEND_ONEAPI:

return lower ? std::string("oneapi") : std::string("oneAPI");

default: return lower ? std::string("unknown") : std::string("Unknown");

}

std::string testname =

::testing::UnitTest::GetInstance()->current_test_info()->name();

return testname;

const af::array &a, const af::array &b,

float maxAbsDiff) {

af::dtype aType = a.type();

af::dtype bType = b.type();

if (aType != bType)

return ::testing::AssertionFailure()

<< "TYPE MISMATCH: \n"

<< " Actual: " << bName << "(" << b.type() << ")\n"

<< "Expected: " << aName << "(" << a.type() << ")";

af::dtype arrDtype = aType;

if (a.dims() != b.dims())

return ::testing::AssertionFailure()

<< "SIZE MISMATCH: \n"

<< " Actual: " << bName << "([" << b.dims() << "])\n"

<< "Expected: " << aName << "([" << a.dims() << "])";

switch (arrDtype) {

case f32:

return elemWiseEq<float>(aName, bName, a, b, maxAbsDiff);

break;

case c32:

return elemWiseEq<af::cfloat>(aName, bName, a, b, maxAbsDiff);

break;

case f64:

return elemWiseEq<double>(aName, bName, a, b, maxAbsDiff);

break;

case c64:

return elemWiseEq<af::cdouble>(aName, bName, a, b, maxAbsDiff);

break;

case b8: return elemWiseEq<char>(aName, bName, a, b, maxAbsDiff); break;

case s32: return elemWiseEq<int>(aName, bName, a, b, maxAbsDiff); break;

case u32:

return elemWiseEq<uint>(aName, bName, a, b, maxAbsDiff);

break;

case s8:

return elemWiseEq<schar>(aName, bName, a, b, maxAbsDiff);

break;

case u8:

return elemWiseEq<uchar>(aName, bName, a, b, maxAbsDiff);

break;

case s64:

return elemWiseEq<long long>(aName, bName, a, b, maxAbsDiff);

break;

case u64:

return elemWiseEq<unsigned long long>(aName, bName, a, b,

maxAbsDiff);

break;

case s16:

return elemWiseEq<short>(aName, bName, a, b, maxAbsDiff);

break;

case u16:

return elemWiseEq<unsigned short>(aName, bName, a, b, maxAbsDiff);

break;

case f16:

return elemWiseEq<half_float::half>(aName, bName, a, b, maxAbsDiff);

break;

default:

return ::testing::AssertionFailure()

<< "INVALID TYPE, see enum numbers: " << bName << "("

<< b.type() << ") and " << aName << "(" << a.type() << ")";

}

return ::testing::AssertionSuccess();

const af::array &a, const af::array &b,

float maxAbsDiff) {

std::vector<T> avec(a.elements());

a.host(avec.data());

std::vector<T> bvec(b.elements());

b.host(bvec.data());

double NRMSD = computeArraysRMSD(a.elements(), avec.data(), bvec.data());

if (NRMSD < maxAbsDiff) {

return ::testing::AssertionSuccess();

} else {

std::string test_name =

::testing::UnitTest::GetInstance()->current_test_info()->name();

std::string valid_path =

std::string(TEST_RESULT_IMAGE_DIR) + test_name + "ValidImage.png";

std::string result_path =

std::string(TEST_RESULT_IMAGE_DIR) + test_name + "ResultImage.png";

std::string diff_path =

std::string(TEST_RESULT_IMAGE_DIR) + test_name + "DiffImage.png";

// af::array img = af::join(1, a, b);

// af::Window win;

// while (!win.close()) { win.image(img); }

af::saveImage(valid_path.c_str(), a.as(f32));

af::saveImage(result_path.c_str(), b.as(f32));

af::saveImage(diff_path.c_str(), abs(a.as(f32) - b.as(f32)));

std::cout << "<DartMeasurementFile type=\"image/png\" "

"name=\"ValidImage\">"

<< valid_path << "</DartMeasurementFile>\n";

std::cout

<< "<DartMeasurementFile type=\"image/png\" name=\"TestImage\">"

<< result_path << "</DartMeasurementFile>\n";

std::cout << "<DartMeasurementFile "

<< "type=\"image/png\" name=\"DifferenceImage2\">"

<< diff_path << "</DartMeasurementFile>\n";

return ::testing::AssertionFailure()

<< "RMSD Error(" << NRMSD << ") exceeds threshold(" << maxAbsDiff

<< "): " << bName << "(" << b.type() << ") and " << aName << "("

<< a.type() << ")";

}

const af::array &a, const af::array &b,

float maxAbsDiff) {

af::dtype aType = a.type();

af::dtype bType = b.type();

if (aType != bType)

return ::testing::AssertionFailure()

<< "TYPE MISMATCH: \n"

<< " Actual: " << bName << "(" << b.type() << ")\n"

<< "Expected: " << aName << "(" << a.type() << ")";

af::dtype arrDtype = aType;

if (a.dims() != b.dims())

return ::testing::AssertionFailure()

<< "SIZE MISMATCH: \n"

<< " Actual: " << bName << "([" << b.dims() << "])\n"

<< "Expected: " << aName << "([" << a.dims() << "])";

switch (arrDtype) {

case s8: return imageEq<signed char>(aName, bName, a, b, maxAbsDiff);

case u8: return imageEq<unsigned char>(aName, bName, a, b, maxAbsDiff);

case b8: return imageEq<char>(aName, bName, a, b, maxAbsDiff);

case s32: return imageEq<int>(aName, bName, a, b, maxAbsDiff);

case u32: return imageEq<unsigned int>(aName, bName, a, b, maxAbsDiff);

case f32: return imageEq<float>(aName, bName, a, b, maxAbsDiff);

case f64: return imageEq<double>(aName, bName, a, b, maxAbsDiff);

case s16: return imageEq<short>(aName, bName, a, b, maxAbsDiff);

case u16:

return imageEq<unsigned short>(aName, bName, a, b, maxAbsDiff);

case u64:

return imageEq<unsigned long long>(aName, bName, a, b, maxAbsDiff);

case s64: return imageEq<long long>(aName, bName, a, b, maxAbsDiff);

default: throw(AF_ERR_NOT_SUPPORTED);

}

return ::testing::AssertionSuccess();

half_float::half h = half_float::half(in);

af_half out;

memcpy(&out, &h, sizeof(af_half));

return out;

std::vector<std::vector<inType>> &testInputs,

std::vector<std::vector<outType>> &testOutputs) {

using std::vector;

std::ifstream testFile(FileName.c_str());

if (testFile.good()) {

unsigned inputCount;

testFile >> inputCount;

inputDims.resize(inputCount);

for (unsigned i = 0; i < inputCount; i++) { testFile >> inputDims[i]; }

unsigned testCount;

testFile >> testCount;

testOutputs.resize(testCount);

vector<unsigned> testSizes(testCount);

for (unsigned i = 0; i < testCount; i++) { testFile >> testSizes[i]; }

testInputs.resize(inputCount, vector<inType>(0));

for (unsigned k = 0; k < inputCount; k++) {

dim_t nElems = inputDims[k].elements();

testInputs[k].resize(nElems);

FileElementType tmp;

for (unsigned i = 0; i < nElems; i++) {

testFile >> tmp;

testInputs[k][i] = convert<inType, FileElementType>(tmp);

}

}

testOutputs.resize(testCount, vector<outType>(0));

for (unsigned i = 0; i < testCount; i++) {

testOutputs[i].resize(testSizes[i]);

FileElementType tmp;

for (unsigned j = 0; j < testSizes[i]; j++) {

testFile >> tmp;

testOutputs[i][j] = convert<outType, FileElementType>(tmp);

}

}

} else {

FAIL() << "TEST FILE NOT FOUND";

}

bool isTypeDouble = (ty == f64) || (ty == c64);

int dev = af::getDevice();

bool isDoubleSupported = af::isDoubleAvailable(dev);

return ((isTypeDouble && !isDoubleSupported) ? true : false);

bool isTypeHalf = (ty == f16);

int dev = af::getDevice();

bool isHalfSupported = af::isHalfAvailable(dev);

return ((isTypeHalf && !isHalfSupported) ? true : false);

half_float::half in_;

// casting to void* to avoid class-memaccess warnings on windows

memcpy(static_cast<void *>(&in_), &in, sizeof(af_half));

half_float::half out_ = abs(in_);

af_half out;

memcpy(&out, &out_, sizeof(af_half));

return out;

af::dim4 coords;

coords[3] = idx / (strides[3]);

coords[2] = idx / (strides[2]) % dims[2];

coords[1] = idx / (strides[1]) % dims[1];

coords[0] = idx % dims[0];

return coords;

af::dim4 dims = arr.dims();

af::dim4 st = af::getStrides(arr);

return unravelIdx(idx, dims, st);

af::dim4 out(1, 1, 1, 1);

dim_t *out_dims = out.get();

const dim_t *parent_dims = parentDim.get();

for (dim_t i = 1; i < 4; i++) {

out_dims[i] = out_dims[i - 1] * parent_dims[i - 1];

}

return out;

std::ostringstream os;

os << "(" << coords[0];

if (dims[1] > 1 || dims[2] > 1 || dims[3] > 1) { os << ", " << coords[1]; }

if (dims[2] > 1 || dims[3] > 1) { os << ", " << coords[2]; }

if (dims[3] > 1) { os << ", " << coords[3]; }

os << ")";

return os.str();

const unsigned ndims, const dim_t *const dims,

const af_dtype ty) {

metadata->init(val, ndims, dims, ty);

const dim_t *const dims, const af_dtype ty) {

const dim_t pad_size = 2;

// The large array is padded on both sides of each dimension

// Padding is only applied if the dimension is used, i.e. if dims[i] > 1

dim_t full_arr_dims[4] = {dims[0], dims[1], dims[2], dims[3]};

for (uint i = 0; i < ndims; ++i) {

full_arr_dims[i] = dims[i] + 2 * pad_size;

}

// Calculate index of sub-array. These will be used also by

// testWriteToOutputArray so that the gold sub array will be placed in

// the same location. Currently, this location is the center of the

// large array

af_seq subarr_idxs[4] = {af_span, af_span, af_span, af_span};

for (uint i = 0; i < ndims; ++i) {

af_seq idx = {pad_size, pad_size + dims[i] - 1.0, 1.0};

subarr_idxs[i] = idx;

}

metadata->init(ndims, full_arr_dims, ty, &subarr_idxs[0]);

const unsigned ndims, const dim_t *const dims,

const af_dtype ty) {

const dim_t pad_size = 2;

// The large array is padded on both sides of each dimension

// Padding is only applied if the dimension is used, i.e. if dims[i] > 1

dim_t full_arr_dims[4] = {dims[0], dims[1], dims[2], dims[3]};

for (uint i = 0; i < ndims; ++i) {

full_arr_dims[i] = dims[i] + 2 * pad_size;

}

// Calculate index of sub-array. These will be used also by

// testWriteToOutputArray so that the gold sub array will be placed in

// the same location. Currently, this location is the center of the

// large array

af_seq subarr_idxs[4] = {af_span, af_span, af_span, af_span};

for (uint i = 0; i < ndims; ++i) {

af_seq idx = {pad_size, pad_size + dims[i] - 1.0, 1.0};

subarr_idxs[i] = idx;

}

metadata->init(val, ndims, full_arr_dims, ty, &subarr_idxs[0]);

const dim_t *const dims, const af_dtype ty) {

// The rest of this function assumes that dims has 4 elements. Just in

// case dims has < 4 elements, use another dims array that is filled

// with 1s

dim_t all_dims[4] = {1, 1, 1, 1};

for (uint i = 0; i < ndims; ++i) { all_dims[i] = dims[i]; }

// This reorder combination will not move data around, but will simply

// call modDims and modStrides (see src/api/c/reorder.cpp).

// The output will be checked if it is still correct even with the

// modified dims and strides "hack" with no data movement

uint reorder_idxs[4] = {0, 2, 1, 3};

// Shape the output array such that the reordered output array will have

// the correct dimensions that the test asks for (i.e. must match dims

// arg)

dim_t init_dims[4] = {all_dims[0], all_dims[1], all_dims[2], all_dims[3]};

for (uint i = 0; i < 4; ++i) { init_dims[i] = all_dims[reorder_idxs[i]]; }

metadata->init(4, init_dims, ty);

af_array reordered = 0;

ASSERT_SUCCESS(af_reorder(&reordered, metadata->getOutput(),

reorder_idxs[0], reorder_idxs[1], reorder_idxs[2],

reorder_idxs[3]));

metadata->setOutput(reordered);

const unsigned ndims, const dim_t *const dims,

const af_dtype ty) {

// The rest of this function assumes that dims has 4 elements. Just in

// case dims has < 4 elements, use another dims array that is filled

// with 1s

dim_t all_dims[4] = {1, 1, 1, 1};

for (uint i = 0; i < ndims; ++i) { all_dims[i] = dims[i]; }

// This reorder combination will not move data around, but will simply

// call modDims and modStrides (see src/api/c/reorder.cpp).

// The output will be checked if it is still correct even with the

// modified dims and strides "hack" with no data movement

uint reorder_idxs[4] = {0, 2, 1, 3};

// Shape the output array such that the reordered output array will have

// the correct dimensions that the test asks for (i.e. must match dims

// arg)

dim_t init_dims[4] = {all_dims[0], all_dims[1], all_dims[2], all_dims[3]};

for (uint i = 0; i < 4; ++i) { init_dims[i] = all_dims[reorder_idxs[i]]; }

metadata->init(val, 4, init_dims, ty);

af_array reordered = 0;

ASSERT_SUCCESS(af_reorder(&reordered, metadata->getOutput(),

reorder_idxs[0], reorder_idxs[1], reorder_idxs[2],

reorder_idxs[3]));

metadata->setOutput(reordered);

const dim_t *const dims, const af_dtype ty,

TestOutputArrayInfo *metadata) {

switch (metadata->getOutputArrayType()) {

case FULL_ARRAY: genRegularArray(metadata, ndims, dims, ty); break;

case SUB_ARRAY: genSubArray(metadata, ndims, dims, ty); break;

case REORDERED_ARRAY:

genReorderedArray(metadata, ndims, dims, ty);

break;

default: break;

}

*out_ptr = metadata->getOutput();

const dim_t *const dims, const af_dtype ty,

TestOutputArrayInfo *metadata) {

switch (metadata->getOutputArrayType()) {

case FULL_ARRAY: genRegularArray(metadata, val, ndims, dims, ty); break;

case SUB_ARRAY: genSubArray(metadata, val, ndims, dims, ty); break;

case REORDERED_ARRAY:

genReorderedArray(metadata, val, ndims, dims, ty);

break;

default: break;

}

*out_ptr = metadata->getOutput();

std::string gold_name, std::string result_name, const af_array gold,

const af_array out, TestOutputArrayInfo *metadata) {

// In the case of NULL_ARRAY, the output array starts out as null.

// After the af_* function is called, it shouldn't be null anymore

if (metadata->getOutputArrayType() == NULL_ARRAY) {

if (out == 0) {

return ::testing::AssertionFailure()

<< "Output af_array " << result_name << " is null";

}

metadata->setOutput(out);

}

// For every other case, must check if the af_array generated by

// genTestOutputArray was used by the af_* function as its output array

else {

if (metadata->getOutput() != out) {

return ::testing::AssertionFailure()

<< "af_array POINTER MISMATCH:\n"

<< " Actual: " << out << "\n"

<< "Expected: " << metadata->getOutput();

}

}

if (metadata->getOutputArrayType() == SUB_ARRAY) {

// There are two full arrays. One will be injected with the gold

// subarray, the other should have already been injected with the

// af_* function's output. Then we compare the two full arrays

af_array gold_full_array = metadata->getFullOutputCopy();

af_assign_seq(&gold_full_array, gold_full_array,

metadata->getSubArrayNumDims(),

metadata->getSubArrayIdxs(), gold);

return assertArrayEq(gold_name, result_name,

metadata->getFullOutputCopy(),

metadata->getFullOutput());

} else {

return assertArrayEq(gold_name, result_name, gold, out);

}

std::string metadataName,

const af_array a, const af_array b,

TestOutputArrayInfo *metadata) {

UNUSED(metadataName);

return testWriteToOutputArray(aName, bName, a, b, metadata);

const af_array a, const af_array b) {

af_array aa = 0, bb = 0;

af_retain_array(&aa, a);

af_retain_array(&bb, b);

af::array aaa(aa);

af::array bbb(bb);

return assertArrayEq(aName, bName, aaa, bbb, 0.0f);

std::string maxAbsDiffName,

const af::array &a,

const af::array &b,

float maxAbsDiff) {

UNUSED(maxAbsDiffName);

return assertArrayEq(aName, bName, a, b, maxAbsDiff);

std::string maxAbsDiffName,

const af_array &a, const af_array &b,

float maxAbsDiff) {

UNUSED(maxAbsDiffName);

af_array aa = 0, bb = 0;

af_retain_array(&aa, a);

af_retain_array(&bb, b);

af::array aaa(aa);

af::array bbb(bb);

return assertImageEq(aName, bName, aaa, bbb, maxAbsDiff);

std::string maxAbsDiffName,

const af::array &a,

const af::array &b,

float maxAbsDiff) {

UNUSED(maxAbsDiffName);

return assertImageEq(aName, bName, a, b, maxAbsDiff);

std::string maxAbsDiffName,

const af_array a, const af_array b,

float maxAbsDiff) {

af_array aa = 0, bb = 0;

af_retain_array(&aa, a);

af_retain_array(&bb, b);

af::array aaa(aa);

af::array bbb(bb);

return assertArrayNear(aName, bName, maxAbsDiffName, aaa, bbb, maxAbsDiff);

const size_t step_bytes = 1024;

size_t alloc_bytes, alloc_buffers;

size_t lock_bytes, lock_buffers;

af::deviceGC();

af::deviceMemInfo(&alloc_bytes, &alloc_buffers, &lock_bytes, &lock_buffers);

ASSERT_EQ(0u, alloc_buffers);

ASSERT_EQ(0u, lock_buffers);

ASSERT_EQ(0u, alloc_bytes);

ASSERT_EQ(0u, lock_bytes);

af::setMemStepSize(step_bytes);

ASSERT_EQ(af::getMemStepSize(), step_bytes);

std::vector<af::dim4> &inputDims,

std::vector<std::vector<inType>> &testInputs,

std::vector<std::vector<outType>> &testOutputs) {

using std::vector;

std::ifstream testFile(FileName.c_str());

if (testFile.good()) {

unsigned inputCount;

testFile >> inputCount;

for (unsigned i = 0; i < inputCount; i++) {

af::dim4 temp(1);

testFile >> temp;

inputDims.push_back(temp);

}

unsigned testCount;

testFile >> testCount;

testOutputs.resize(testCount);

vector<unsigned> testSizes(testCount);

for (unsigned i = 0; i < testCount; i++) { testFile >> testSizes[i]; }

testInputs.resize(inputCount, vector<inType>(0));

for (unsigned k = 0; k < inputCount; k++) {

dim_t nElems = inputDims[k].elements();

testInputs[k].resize(nElems);

inType tmp;

for (unsigned i = 0; i < nElems; i++) {

testFile >> tmp;

testInputs[k][i] = tmp;

}

}

testOutputs.resize(testCount, vector<outType>(0));

for (unsigned i = 0; i < testCount; i++) {

testOutputs[i].resize(testSizes[i]);

outType tmp;

for (unsigned j = 0; j < testSizes[i]; j++) {

testFile >> tmp;

testOutputs[i][j] = tmp;

}

}

} else {

FAIL() << "TEST FILE NOT FOUND";

}

std::vector<af::dim4> &pInputDims,

std::vector<std::string> &pTestInputs,

std::vector<std::vector<outType>> &pTestOutputs) {

using std::vector;

std::ifstream testFile(pFileName.c_str());

if (testFile.good()) {

unsigned inputCount;

testFile >> inputCount;

for (unsigned i = 0; i < inputCount; i++) {

af::dim4 temp(1);

testFile >> temp;

pInputDims.push_back(temp);

}

unsigned testCount;

testFile >> testCount;

pTestOutputs.resize(testCount);

vector<unsigned> testSizes(testCount);

for (unsigned i = 0; i < testCount; i++) { testFile >> testSizes[i]; }

pTestInputs.resize(inputCount, "");

for (unsigned k = 0; k < inputCount; k++) {

pTestInputs[k] = readNextNonEmptyLine(testFile);

}

pTestOutputs.resize(testCount, vector<outType>(0));

for (unsigned i = 0; i < testCount; i++) {

pTestOutputs[i].resize(testSizes[i]);

outType tmp;

for (unsigned j = 0; j < testSizes[i]; j++) {

testFile >> tmp;

pTestOutputs[i][j] = tmp;

}

}

} else {

FAIL() << "TEST FILE NOT FOUND";

}

std::vector<af::dim4> &pInputDims,

std::vector<std::string> &pTestInputs,

std::vector<dim_t> &pTestOutSizes,

std::vector<std::string> &pTestOutputs) {

using std::vector;

std::ifstream testFile(pFileName.c_str());

if (testFile.good()) {

unsigned inputCount;

testFile >> inputCount;

for (unsigned i = 0; i < inputCount; i++) {

af::dim4 temp(1);

testFile >> temp;

pInputDims.push_back(temp);

}

unsigned testCount;

testFile >> testCount;

pTestOutputs.resize(testCount);

pTestOutSizes.resize(testCount);

for (unsigned i = 0; i < testCount; i++) {

testFile >> pTestOutSizes[i];

}