#include "acl/acl.h"
#include "acl/DataTypes/aclIndex.h"
#include "acl/DataTypes/aclConstant.h"
#include "acl/DataTypes/aclVariable.h"
#include "acl/DataTypes/aclVariableReference.h"
#include "acl/DataTypes/aclPrivateVariable.h"
#include "acl/DataTypes/aclArray.h"
#include "acl/DataTypes/aclLocalArray.h"
#include "acl/DataTypes/aclSubvector.h"
#include "acl/Operators/aclElementFor.h"
#include "acl/Operators/aclElementIfElse.h"
#include "acl/Operators/aclElementParser.h"
#include "acl/Kernels/aclKernel.h"
#include "aslUtilities.h"
#include <math.h>
#include <initializer_list>
using namespace std;
{
cout <<
"Test of If-Else..." <<
flush;
using namespace elementOperators;
shared_ptr<Variable<cl_int> > a(new Variable<cl_int> (15));
Element c0(
new Constant<cl_int> (15));
Element c1(
new Constant<cl_int> (3));
Element vec(
new Array<cl_float> (11));
vector<cl_float> input(11, 2);
vector<cl_float> output(11, 0);
vector<cl_float> expected({8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8});
shared_ptr<ElementIfElse> ifElse_TestIf(
new ElementIfElse(
isEqual(a, c0)));
shared_ptr<ElementIfElse> ifElse_TestElse(
new ElementIfElse(
isEqual(a, c1)));
Kernel k;
k.addExpression(ifElse_TestIf);
k.addExpression(ifElse_TestElse);
k.setup();
k.compute();
bool status(output == expected);
return status;
}
{
cout <<
"Test of Parser..." <<
flush;
using namespace elementOperators;
shared_ptr<Variable<cl_int> > a(new Variable<cl_int> (15));
Element c0(
new Constant<cl_int> (15));
Element c1(
new Constant<cl_int> (3));
Element vec(
new Array<cl_float> (11));
vector<cl_float> input(11, 2);
vector<cl_float> output(11, 0);
vector<cl_float> expected({35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35});
string statement("a + c0 + c1 + vec");
shared_ptr<ElementParser> parser(new ElementParser());
parser->addElementNamePair(a, "a");
parser->addElementNamePair(c0, "c0");
parser->addElementNamePair(c1, "c1");
parser->addElementNamePair(vec, "vec");
parser->setStatement(statement);
Kernel k;
k.setup();
k.compute();
bool status(output == expected);
return status;
}
{
cout <<
"Test of Atomic Sum..." <<
flush;
using namespace elementOperators;
Element c(
new Constant<cl_int> (6));
Element vec(
new Array<cl_int> (11));
vector<cl_int> input(11, 2);
vector<cl_int> output(11, 0);
vector<cl_int> expected({8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8});
k.setup();
k.compute();
bool status(output == expected);
return status;
}
{
bool allTestsPassed(true);
return allTestsPassed ? EXIT_SUCCESS : EXIT_FAILURE;
}
std::vector< std::string > extensions
Element operatorAssignment(Element e1, Element e2)
Element atomic_add(Element e1, Element e2)
Element isEqual(Element e1, Element e2)
void errorMessage(cl_int status, const char *errorMessage)
Prints errorMessage and exits depending on the status.
const KernelConfiguration KERNEL_BASIC
Advanced Computational Language.
void copy(MemBlock &source, T *destination)
std::shared_ptr< ElementBase > Element
const acl::KernelConfiguration & kConf(acl::KERNEL_BASIC)