/* * Advanced Simulation Library * * Copyright 2015 Avtech Scientific * * * This file is part of Advanced Simulation Library (ASL). * * ASL is free software: you can redistribute it and/or modify it * under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, version 3 of the License. * * ASL is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with ASL. If not, see . * */ /** \example testKernel.cc */ #include "acl/acl.h" #include "acl/DataTypes/aclIndex.h" #include "acl/DataTypes/aclGroupID.h" #include "acl/DataTypes/aclConstant.h" #include "acl/DataTypes/aclVariable.h" #include "acl/DataTypes/aclVariableReference.h" #include "acl/DataTypes/aclPrivateVariable.h" #include "acl/DataTypes/aclPrivateArray.h" #include "acl/DataTypes/aclArray.h" #include "acl/DataTypes/aclSubvector.h" #include "acl/DataTypes/aclLocalArray.h" #include "acl/Operators/aclElementFor.h" #include "acl/Operators/aclElementIfElse.h" #include "acl/Operators/aclElementExcerpt.h" #include "acl/Kernels/aclKernel.h" #include "aslUtilities.h" #include #include #include using namespace acl; using namespace std; bool testCopy() { cout << "Test of \"copy\" function..." << flush; Element vec0(new Array (10)); vector input(10, 3); vector output(10, 1); copy(input, vec0); copy(vec0, output); bool status(output[3] == 3); errorMessage(status); return status; } bool testKernel() { cout << "Test of Kernel with double..." << flush; Element vec0(new Array(10)); Element vec1(new Array(10)); Element vec2(new Array(10)); Element c(new Constant(2.)); Element ind(new Index()); Kernel k; { using namespace elementOperators; k.addExpression(operatorAssignment(vec2, c )); k.addExpression(operatorAssignment(vec0, c + powI(vec2, 3))); k.addExpression(operatorAssignment(vec1, ind)); } k.setup(); k.compute(); vector output0(10), output1(10); copy(vec0, output0); copy(vec1, output1); bool status(output0[9]<10.1 && output1[2]>2-1e-4 && output1[3]<3+1e-4); errorMessage(status); return status; } bool testKernelSIMD() { cout << "Test of KernelSIMD..." << flush; Element vec0(new Array(11)); Element vec1(new Array(11)); vector input0(11, 3); vector input1(11, 5); vector output(11, 0); vector expected({8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}); copy(input0, vec0); copy(input1, vec1); Kernel k(KERNEL_SIMD); { using namespace elementOperators; k.addExpression(operatorAssignmentSafe(vec1, vec0 + vec1)); } k.setup(); k.compute(); copy(vec1, output); bool status(output == expected); errorMessage(status); return status; } bool testKernelSIMDUA() { cout << "Test of KernelSIMDUA..." << flush; Element vec0(new Array (11)); Element vec1(new Array (11)); vector input0(11, 3); vector input1(11, 5); vector output(11, 0); vector expected({8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}); copy(input0, vec0); copy(input1, vec1); KernelConfiguration kConf(KERNEL_SIMDUA); // kConf.extensions.push_back("cl_amd_printf"); Kernel k(kConf); { using namespace elementOperators; k.addExpression(operatorAssignmentSafe(vec1, vec0 + vec1)); // k.addExpression(printfFunction("\"index: %d\\n\", index")); } k.setup(); k.compute(); copy(vec1, output); bool status(output == expected); errorMessage(status); return status; } bool testPrivateVariable() { cout << "Test of kernel with PrivateVariable..." << flush; Element vec0(new Array(10)); Element vec1(new Array(10)); Element loc(new PrivateVariable()); vector input1(10, 3); vector input2(10, 5); vector output(10, 1); copy(input1, vec0); copy(input2, vec1); Kernel k; { using namespace elementOperators; k.addExpression(operatorAssignment(loc, vec0 + vec1)); k.addExpression(operatorAssignment(vec1, vec0 - vec1)); k.addExpression(operatorAssignment(vec0, loc)); } k.setup(); k.compute(); copy(vec0, output); bool status(output[2] ==8.); errorMessage(status); return status; } bool testPrivateArray() { cout << "Test of kernel with PrivateArray..." << flush; vector inputGaIn({0, 4, 5}); vector inputGaOut(3, 0); vector inputPa({-9, 2, 0, 15, 1, 3}); vector output(3); vector expected({-9, 1, 3}); Element gaIn(new Array(3)); Element gaOut(new Array(3)); Element pa(new PrivateArray(inputPa)); shared_ptr ex(new ElementExcerpt(pa, gaIn)); copy(inputGaIn, gaIn); Kernel k; { using namespace elementOperators; k.addExpression(operatorAssignment(gaOut, ex)); } k.setup(); k.compute(); copy(gaOut, output); bool status(output == expected); errorMessage(status); return status; } bool testVariable() { cout << "Test of Variable functionality..." << flush; Element vec0(new Array (10)); shared_ptr > a(new Variable (1.)); vector output(10, 1); Kernel k; k.addExpression(elementOperators::operatorAssignment(vec0, a)); k.setup(); k.compute(); a->setValue(10.); k.compute(); copy(vec0, output); bool status(output[2] ==10.); errorMessage(status); return status; } bool testVariableReference() { cout << "Test of VariableReference functionality..." << flush; Element vec0(new Array (10)); float v(1.); Element a(new VariableReference (v)); vector output(10, 1); Kernel k; k.addExpression(elementOperators::operatorAssignment(vec0, a)); k.setup(); k.compute(); v=10.; k.compute(); copy(vec0, output); bool status(output[2] ==10.); errorMessage(status); return status; } bool testSelect() { cout << "Test of select function..." << flush; Element vec0(new Array (10)); Element c0(new Constant (2.1)); vector input(10, 3.); vector output(10, 1.); copy(input,vec0); Kernel k; { using namespace elementOperators; k.addExpression(operatorAssignment(vec0, select(vec0-c0, vec0*vec0, convert(TYPE_SELECT[TYPE_DOUBLE], vec0 > c0, false)))); } k.setup(); k.compute(); copy(vec0, output); bool status(output[2] ==9.); errorMessage(status); return status; } bool testSubvector() { cout << "Test of Subvector..." << flush; cl_float init[] = {16, 2, 77, 29, 23, 16, 2, 77, 29, 23}; shared_ptr > vec0(new Array(10)); vector input(init, init + sizeof(init) / sizeof(cl_float) ); vector output(2); copy(input, vec0); Element subvec0(new Subvector (vec0, 2, 0)); copy(subvec0, output); bool status(output[0]==16); errorMessage(status); return status; } bool testSwapBuffers() { cout << "Test of Swap functionality..." << flush; shared_ptr > vec0(new Array(10)); shared_ptr > vec1(new Array(10)); vector input0(10, 1); vector input1(10, 2); vector output(10, 10); copy(input0, vec0); copy(input1, vec1); swapBuffers(*vec1,*vec0); copy(vec0, output); bool status(output[3] == 2); errorMessage(status); return status; } bool testLocalArray() { cout << "Test of LocalArray and syncCopy with barrier()..." << flush; KernelConfiguration kConf(KERNEL_BASIC); kConf.local = true; unsigned int groupsNumber = 5; unsigned int groupSize = 2; Element vec0(new Array(groupSize * groupsNumber)); Element vec1(new Array(groupSize * groupsNumber)); Element loc0(new LocalArray(groupSize)); Element loc1(new LocalArray(groupSize)); Element groupID(new GroupID()); Element cGroupSize(new Constant(groupSize)); Element c0(new Constant(0)); vector input0(groupSize * groupsNumber, 3); vector input1(groupSize * groupsNumber, 5); vector output(groupSize * groupsNumber, 0); vector expected({2, 2, 2, 2, 2, 2, 2, 2, 2, 2}); copy(input0, vec0); copy(input1, vec1); Kernel k(kConf); k.setGroupsNumber(groupsNumber); { using namespace elementOperators; k.addExpression(syncCopy(vec0, loc0, cGroupSize * groupID, c0, cGroupSize)); k.addExpression(syncCopy(vec1, loc1, cGroupSize * groupID, c0, cGroupSize)); k.addExpression(barrier()); k.addExpression(operatorAssignment(loc1, loc1 - loc0)); k.addExpression(barrier("CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE")); k.addExpression(syncCopy(loc1, vec1, c0, cGroupSize * groupID, cGroupSize)); } k.setup(); k.compute(); copy(vec1, output); bool status(output == expected); errorMessage(status); return status; } int main() { bool allTestsPassed(true); allTestsPassed &= testCopy(); allTestsPassed &= testKernel(); allTestsPassed &= testKernelSIMD(); allTestsPassed &= testKernelSIMDUA(); allTestsPassed &= testPrivateVariable(); allTestsPassed &= testPrivateArray(); allTestsPassed &= testVariable(); allTestsPassed &= testVariableReference(); allTestsPassed &= testSelect(); allTestsPassed &= testSwapBuffers(); allTestsPassed &= testLocalArray(); allTestsPassed &= testSubvector(); return allTestsPassed ? EXIT_SUCCESS : EXIT_FAILURE; }