mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 06:09:01 +00:00
Initial open source release of OpenCL 2.2 CTS.
This commit is contained in:
Kedar Patil
20
test_conformance/non_uniform_work_group/CMakeLists.txt
Normal file
20
test_conformance/non_uniform_work_group/CMakeLists.txt
Normal file
@@ -0,0 +1,20 @@
|
||||
set(MODULE_NAME NON_UNIFORM_WORK_GROUP)
|
||||
|
||||
set(${MODULE_NAME}_SOURCES
|
||||
main.cpp
|
||||
test_advanced_2d.cpp
|
||||
test_advanced_3d.cpp
|
||||
test_advanced_other.cpp
|
||||
test_basic.cpp
|
||||
TestNonUniformWorkGroup.cpp
|
||||
tools.cpp
|
||||
../../test_common/harness/testHarness.c
|
||||
../../test_common/harness/errorHelpers.c
|
||||
../../test_common/harness/kernelHelpers.c
|
||||
../../test_common/harness/msvc9.c
|
||||
../../test_common/harness/parseParameters.cpp
|
||||
)
|
||||
|
||||
include(../CMakeCommon.txt)
|
||||
|
||||
# end of file #
|
||||
46
test_conformance/non_uniform_work_group/Makefile
Normal file
46
test_conformance/non_uniform_work_group/Makefile
Normal file
@@ -0,0 +1,46 @@
|
||||
ifdef BUILD_WITH_ATF
|
||||
ATF = -framework ATF
|
||||
USE_ATF = -DUSE_ATF
|
||||
endif
|
||||
|
||||
SRCS = main.c \
|
||||
test_basic.cpp \
|
||||
test_advanced_2d.cpp \
|
||||
test_advanced_3d.cpp \
|
||||
test_advanced_other.cpp \
|
||||
TestNonUniformWorkGroup.cpp \
|
||||
tools.cpp \
|
||||
../../test_common/harness/errorHelpers.c \
|
||||
../../test_common/harness/threadTesting.c \
|
||||
../../test_common/harness/testHarness.c \
|
||||
../../test_common/harness/kernelHelpers.c \
|
||||
../../test_common/harness/typeWrappers.cpp \
|
||||
|
||||
DEFINES = DONT_TEST_GARBAGE_POINTERS
|
||||
|
||||
SOURCES = $(abspath $(SRCS))
|
||||
LIBPATH += -L/System/Library/Frameworks/OpenCL.framework/Libraries
|
||||
LIBPATH += -L.
|
||||
HEADERS =
|
||||
TARGET = test_non_uniform_workgroup
|
||||
INCLUDE =
|
||||
COMPILERFLAGS = -c -Wall -g -Wshorten-64-to-32
|
||||
CC = c++
|
||||
CFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
|
||||
CXXFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
|
||||
LIBRARIES = -framework OpenCL -framework OpenGL -framework GLUT -framework AppKit ${ATF}
|
||||
|
||||
OBJECTS := ${SOURCES:.c=.o}
|
||||
OBJECTS := ${OBJECTS:.cpp=.o}
|
||||
|
||||
TARGETOBJECT =
|
||||
all: $(TARGET)
|
||||
|
||||
$(TARGET): $(OBJECTS)
|
||||
$(CC) $(RC_CFLAGS) $(OBJECTS) -o $@ $(LIBPATH) $(LIBRARIES)
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET) $(OBJECTS)
|
||||
|
||||
.DEFAULT:
|
||||
@echo The target \"$@\" does not exist in Makefile.
|
||||
@@ -0,0 +1,751 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
#include <vector>
|
||||
#include <sstream>
|
||||
#define NL "\n"
|
||||
|
||||
size_t TestNonUniformWorkGroup::_maxLocalWorkgroupSize = 0;
|
||||
bool TestNonUniformWorkGroup::_strictMode = false;
|
||||
|
||||
// Main Kernel source code
|
||||
static const char *KERNEL_FUNCTION =
|
||||
NL "#define MAX_DIMS 3"
|
||||
NL "typedef struct _DataContainerAttrib"
|
||||
NL "{"
|
||||
NL " unsigned long get_global_size[MAX_DIMS];"
|
||||
NL " unsigned long get_global_offset[MAX_DIMS];"
|
||||
NL " unsigned long get_local_size[MAX_DIMS];"
|
||||
NL " unsigned long get_enqueued_local_size[MAX_DIMS];"
|
||||
NL " unsigned long get_global_id[MAX_DIMS];"
|
||||
NL " unsigned long get_local_id[MAX_DIMS];"
|
||||
NL " unsigned long get_group_id[MAX_DIMS];"
|
||||
NL " unsigned long get_num_groups[MAX_DIMS];"
|
||||
NL " unsigned long get_work_dim;"
|
||||
NL " unsigned short test_local_barrier_result_bool;"
|
||||
NL " unsigned short test_global_barrier_result_bool;"
|
||||
NL " unsigned short test_local_atomic_result_value;"
|
||||
NL "}DataContainerAttrib;"
|
||||
|
||||
NL "enum Error{"
|
||||
NL " ERR_GLOBAL_SIZE=0,"
|
||||
NL " ERR_GLOBAL_WORK_OFFSET,"
|
||||
NL " ERR_LOCAL_SIZE,"
|
||||
NL " ERR_GLOBAL_ID,"
|
||||
NL " ERR_LOCAL_ID,"
|
||||
NL " ERR_ENQUEUED_LOCAL_SIZE,"
|
||||
NL " ERR_NUM_GROUPS,"
|
||||
NL " ERR_GROUP_ID,"
|
||||
NL " ERR_WORK_DIM,"
|
||||
NL " ERR_GLOBAL_BARRIER,"
|
||||
NL " ERR_LOCAL_BARRIER,"
|
||||
NL " ERR_GLOBAL_ATOMIC,"
|
||||
NL " ERR_LOCAL_ATOMIC,"
|
||||
NL " ERR_STRICT_MODE,"
|
||||
NL " ERR_BUILD_STATUS,"
|
||||
NL " ERR_UNKNOWN,"
|
||||
NL " ERR_DIFFERENT,"
|
||||
NL " _LAST_ELEM"
|
||||
NL "};"
|
||||
|
||||
NL "uint getGlobalIndex (uint gid2, uint gid1, uint gid0) {"
|
||||
NL " return gid2*get_global_size(0)*get_global_size(1) + gid1*get_global_size(0) + gid0;"
|
||||
NL "}"
|
||||
|
||||
NL "int getRegionIndex () {"
|
||||
NL " uint gid0 = get_global_id(0) - get_global_offset(0);"
|
||||
NL " uint gid1 = get_global_id(1) - get_global_offset(1);"
|
||||
NL " uint gid2 = get_global_id(2) - get_global_offset(2);"
|
||||
NL " if (gid0 == 0 && gid1 == 0 && gid2 == 0) {"
|
||||
NL " return 0;"
|
||||
NL " } else if (gid0 == get_global_size(0) - 1 && gid1 == 0 && gid2 == 0) {"
|
||||
NL " return 1;"
|
||||
NL " } else if (gid0 == 0 && gid1 == get_global_size(1) - 1 && gid2 == 0) {"
|
||||
NL " return 2;"
|
||||
NL " } else if (gid0 == get_global_size(0) - 1 && gid1 == get_global_size(1) - 1 && gid2 == 0) {"
|
||||
NL " return 3;"
|
||||
NL " } else if (gid0 == 0 && gid1 == 0 && gid2 == get_global_size(2) - 1) {"
|
||||
NL " return 4;"
|
||||
NL " } else if (gid0 == get_global_size(0) - 1 && gid1 == 0 && gid2 == get_global_size(2) - 1) {"
|
||||
NL " return 5;"
|
||||
NL " } else if (gid0 == 0 && gid1 == get_global_size(1) - 1 && gid2 == get_global_size(2) - 1) {"
|
||||
NL " return 6;"
|
||||
NL " } else if (gid0 == get_global_size(0) - 1 && gid1 == get_global_size(1) - 1 && gid2 == get_global_size(2) - 1) {"
|
||||
NL " return 7;"
|
||||
NL " }"
|
||||
NL " return -1;"
|
||||
NL "}"
|
||||
|
||||
NL "void getLocalSize(__global DataContainerAttrib *results) {"
|
||||
NL " for (unsigned short i = 0; i < MAX_DIMS; i++) {"
|
||||
NL " results->get_local_size[i] = get_local_size(i);"
|
||||
NL " }"
|
||||
NL "}"
|
||||
|
||||
NL "#ifdef TESTBASIC"
|
||||
// values set by this function will be checked on the host side
|
||||
NL "void testBasicHost(__global DataContainerAttrib *results) {"
|
||||
NL " for (unsigned short i = 0; i < MAX_DIMS; i++) {"
|
||||
NL " results->get_global_size[i] = get_global_size(i);"
|
||||
NL " results->get_global_offset[i] = get_global_offset(i);"
|
||||
NL " results->get_enqueued_local_size[i] = get_enqueued_local_size(i);"
|
||||
NL " results->get_global_id[i] = get_global_id(i);"
|
||||
NL " results->get_local_id[i] = get_local_id(i);"
|
||||
NL " results->get_group_id[i] = get_group_id(i);"
|
||||
NL " results->get_num_groups[i] = get_num_groups(i);"
|
||||
NL " }"
|
||||
NL " results->get_work_dim = get_work_dim();"
|
||||
NL "}"
|
||||
// values set by this function are checked on the kernel side
|
||||
NL "void testBasicKernel(__global unsigned int *errorCounterBuffer, __local DataContainerAttrib *resultsForThread0) {"
|
||||
NL " uint lid0 = get_local_id(0);"
|
||||
NL " uint lid1 = get_local_id(1);"
|
||||
NL " uint lid2 = get_local_id(2);"
|
||||
NL " if (lid0 == 0 && lid1 == 0 && lid2 == 0) {"
|
||||
NL " for (unsigned short i = 0; i < MAX_DIMS; i++) {"
|
||||
NL " resultsForThread0->get_global_size[i] = get_global_size(i);"
|
||||
NL " resultsForThread0->get_global_offset[i] = get_global_offset(i);"
|
||||
NL " resultsForThread0->get_enqueued_local_size[i] = get_enqueued_local_size(i);"
|
||||
NL " resultsForThread0->get_group_id[i] = get_group_id(i);"
|
||||
NL " resultsForThread0->get_num_groups[i] = get_num_groups(i);"
|
||||
NL " }"
|
||||
NL " resultsForThread0->get_work_dim = get_work_dim();"
|
||||
NL " }"
|
||||
NL " barrier(CLK_LOCAL_MEM_FENCE);"
|
||||
// verifies built in functions on the kernel side
|
||||
NL " if (lid0 != 0 || lid1 != 0 || lid2 != 0) {"
|
||||
NL " for (unsigned short i = 0; i < MAX_DIMS; i++) {"
|
||||
NL " if (resultsForThread0->get_global_size[i] != get_global_size(i)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_GLOBAL_SIZE]);"
|
||||
NL " }"
|
||||
NL " if (resultsForThread0->get_global_offset[i] != get_global_offset(i)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_GLOBAL_WORK_OFFSET]);"
|
||||
NL " }"
|
||||
NL " if (resultsForThread0->get_enqueued_local_size[i] != get_enqueued_local_size(i)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_ENQUEUED_LOCAL_SIZE]);"
|
||||
NL " }"
|
||||
NL " if (resultsForThread0->get_group_id[i] != get_group_id(i)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_GROUP_ID]);"
|
||||
NL " }"
|
||||
NL " if (resultsForThread0->get_num_groups[i] != get_num_groups(i)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_NUM_GROUPS]);"
|
||||
NL " }"
|
||||
NL " }"
|
||||
NL " if (resultsForThread0->get_work_dim != get_work_dim()) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_WORK_DIM]);"
|
||||
NL " }"
|
||||
NL " }"
|
||||
NL "}"
|
||||
NL "#endif"
|
||||
|
||||
NL "#ifdef TESTBARRIERS"
|
||||
NL "void testBarriers(__global unsigned int *errorCounterBuffer, __local unsigned int *testLocalBuffer, __global unsigned int *testGlobalBuffer) {"
|
||||
NL " uint gid0 = get_global_id(0);"
|
||||
NL " uint gid1 = get_global_id(1);"
|
||||
NL " uint gid2 = get_global_id(2);"
|
||||
NL " uint lid0 = get_local_id(0);"
|
||||
NL " uint lid1 = get_local_id(1);"
|
||||
NL " uint lid2 = get_local_id(2);"
|
||||
NL
|
||||
NL " uint globalIndex = getGlobalIndex(gid2-get_global_offset(2), gid1-get_global_offset(1), gid0-get_global_offset(0));"
|
||||
NL " uint localIndex = lid2*get_local_size(0)*get_local_size(1) + lid1*get_local_size(0) + lid0;"
|
||||
NL " testLocalBuffer[localIndex] = 0;"
|
||||
NL " testGlobalBuffer[globalIndex] = 0;"
|
||||
NL " uint maxLocalIndex = get_local_size(0)*get_local_size(1)*get_local_size(2)-1;"
|
||||
NL " uint nextLocalIndex = (localIndex>=maxLocalIndex)?0:(localIndex+1);"
|
||||
NL " uint next_lid0 = (lid0+1>=get_local_size(0))?0:lid0+1;"
|
||||
NL " uint next_lid1 = (lid1+1>=get_local_size(1))?0:lid1+1;"
|
||||
NL " uint next_lid2 = (lid2+1>=get_local_size(2))?0:lid2+1;"
|
||||
NL " uint nextGlobalIndexInLocalWorkGroup = getGlobalIndex (get_group_id(2)*get_enqueued_local_size(2)+next_lid2, get_group_id(1)*get_enqueued_local_size(1)+next_lid1, get_group_id(0)*get_enqueued_local_size(0)+next_lid0);"
|
||||
// testing local barriers
|
||||
NL " testLocalBuffer[localIndex] = localIndex;"
|
||||
NL " barrier(CLK_LOCAL_MEM_FENCE);"
|
||||
NL " uint temp = testLocalBuffer[nextLocalIndex];"
|
||||
NL " if (temp != nextLocalIndex) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_LOCAL_BARRIER]);"
|
||||
NL " }"
|
||||
// testing global barriers
|
||||
NL " testGlobalBuffer[globalIndex] = globalIndex;"
|
||||
NL " barrier(CLK_GLOBAL_MEM_FENCE);"
|
||||
NL " uint temp2 = testGlobalBuffer[nextGlobalIndexInLocalWorkGroup];"
|
||||
NL " if (temp2 != nextGlobalIndexInLocalWorkGroup) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_GLOBAL_BARRIER]);"
|
||||
NL " }"
|
||||
NL "}"
|
||||
NL "#endif"
|
||||
|
||||
NL "#ifdef TESTATOMICS"
|
||||
NL "void testAtomics(__global unsigned int *globalAtomicTestVariable, __local unsigned int *localAtomicTestVariable) {"
|
||||
NL " uint gid0 = get_global_id(0);"
|
||||
NL " uint gid1 = get_global_id(1);"
|
||||
NL " uint gid2 = get_global_id(2);"
|
||||
NL
|
||||
NL " uint globalIndex = getGlobalIndex(gid2-get_global_offset(2), gid1-get_global_offset(1), gid0-get_global_offset(0));"
|
||||
// testing atomic function on local memory
|
||||
NL " atomic_inc(localAtomicTestVariable);"
|
||||
NL " barrier(CLK_LOCAL_MEM_FENCE);"
|
||||
// testing atomic function on global memory
|
||||
NL " atomic_inc(globalAtomicTestVariable);"
|
||||
NL "}"
|
||||
NL "#endif"
|
||||
|
||||
NL "#ifdef RWGSX"
|
||||
NL "#ifdef RWGSY"
|
||||
NL "#ifdef RWGSZ"
|
||||
NL "__attribute__((reqd_work_group_size(RWGSX, RWGSY, RWGSZ)))"
|
||||
NL "#endif"
|
||||
NL "#endif"
|
||||
NL "#endif"
|
||||
NL "__kernel void testKernel(__global DataContainerAttrib *results, __local unsigned int *testLocalBuffer,"
|
||||
NL " __global unsigned int *testGlobalBuffer, __global unsigned int *globalAtomicTestVariable, __global unsigned int *errorCounterBuffer) {"
|
||||
NL " uint gid0 = get_global_id(0);"
|
||||
NL " uint gid1 = get_global_id(1);"
|
||||
NL " uint gid2 = get_global_id(2);"
|
||||
NL
|
||||
NL " uint globalIndex = getGlobalIndex(gid2-get_global_offset(2), gid1-get_global_offset(1), gid0-get_global_offset(0));"
|
||||
NL " int regionIndex = getRegionIndex();"
|
||||
NL " if (regionIndex >= 0) {"
|
||||
NL " getLocalSize(&results[regionIndex]);"
|
||||
NL " }"
|
||||
NL "#ifdef TESTBASIC"
|
||||
NL " if (regionIndex >= 0) {"
|
||||
NL " testBasicHost(&results[regionIndex]);"
|
||||
NL " }"
|
||||
NL " __local DataContainerAttrib resultsForThread0;"
|
||||
NL " testBasicKernel(errorCounterBuffer, &resultsForThread0);"
|
||||
NL "#endif"
|
||||
NL "#ifdef TESTBARRIERS"
|
||||
NL " testBarriers(errorCounterBuffer, testLocalBuffer, testGlobalBuffer);"
|
||||
NL "#endif"
|
||||
NL "#ifdef TESTATOMICS"
|
||||
NL " __local unsigned int localAtomicTestVariable;"
|
||||
NL " localAtomicTestVariable = 0;"
|
||||
NL " barrier(CLK_LOCAL_MEM_FENCE);"
|
||||
NL " testAtomics(globalAtomicTestVariable, &localAtomicTestVariable);"
|
||||
NL " barrier(CLK_LOCAL_MEM_FENCE);"
|
||||
NL " if (localAtomicTestVariable != get_local_size(0) * get_local_size(1) * get_local_size(2)) {"
|
||||
NL " atomic_inc(&errorCounterBuffer[ERR_LOCAL_ATOMIC]);"
|
||||
NL " }"
|
||||
NL "#endif"
|
||||
NL "}"
|
||||
NL ;
|
||||
|
||||
TestNonUniformWorkGroup::TestNonUniformWorkGroup (const cl_device_id &device, const cl_context &context,
|
||||
const cl_command_queue &queue, const cl_uint dims, const size_t *globalSize, const size_t *localSize, const size_t *buffersSize,
|
||||
const size_t *globalWorkOffset, const size_t *reqdWorkGroupSize)
|
||||
: _device(device), _context(context), _queue(queue), _dims (dims) {
|
||||
|
||||
if (globalSize == NULL || dims < 1 || dims > 3) {
|
||||
//throw std::invalid_argument("globalSize is NULL value.");
|
||||
// This is method of informing that parameters are wrong.
|
||||
// It would be checked by prepareDevice() function.
|
||||
// This is used because of lack of exception support.
|
||||
_globalSize[0] = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
cl_uint i;
|
||||
_globalWorkOffset_IsNull = true;
|
||||
_localSize_IsNull = true;
|
||||
|
||||
setGlobalWorkgroupSize(globalSize);
|
||||
setLocalWorkgroupSize(globalSize,localSize);
|
||||
for (i = _dims; i < MAX_DIMS; i++) {
|
||||
_globalSize[i] = 1;
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_DIMS; i++) {
|
||||
_globalWorkOffset[i] = 0;
|
||||
}
|
||||
|
||||
if (globalWorkOffset) {
|
||||
_globalWorkOffset_IsNull = false;
|
||||
for (i = 0; i < _dims; i++) {
|
||||
_globalWorkOffset[i] = globalWorkOffset[i];
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MAX_DIMS; i++) {
|
||||
_enqueuedLocalSize[i] = 1;
|
||||
}
|
||||
|
||||
if (localSize) {
|
||||
_localSize_IsNull = false;
|
||||
for (i = 0; i < _dims; i++) {
|
||||
_enqueuedLocalSize[i] = _localSize[i];
|
||||
}
|
||||
}
|
||||
|
||||
if (reqdWorkGroupSize) {
|
||||
for (i = 0; i < _dims; i++) {
|
||||
_reqdWorkGroupSize[i] = reqdWorkGroupSize[i];
|
||||
}
|
||||
for (i = _dims; i < MAX_DIMS; i++) {
|
||||
_reqdWorkGroupSize[i] = 1;
|
||||
}
|
||||
} else {
|
||||
_reqdWorkGroupSize[0] = 0;
|
||||
_reqdWorkGroupSize[1] = 0;
|
||||
_reqdWorkGroupSize[2] = 0;
|
||||
}
|
||||
|
||||
_testRange = Range::ALL;
|
||||
|
||||
_numOfGlobalWorkItems = _globalSize[0]*_globalSize[1]*_globalSize[2];
|
||||
|
||||
DataContainerAttrib temp = {{0, 0, 0}};
|
||||
|
||||
// array with results from each region
|
||||
_resultsRegionArray.resize(NUMBER_OF_REGIONS, temp);
|
||||
_referenceRegionArray.resize(NUMBER_OF_REGIONS, temp);
|
||||
|
||||
}
|
||||
|
||||
TestNonUniformWorkGroup::~TestNonUniformWorkGroup () {
|
||||
if (_err.checkError()) {
|
||||
_err.showStats();
|
||||
}
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::setLocalWorkgroupSize (const size_t *globalSize, const size_t *localSize)
|
||||
{
|
||||
cl_uint i;
|
||||
// Enforce localSize should not exceed globalSize
|
||||
if (localSize) {
|
||||
for (i = 0; i < _dims; i++) {
|
||||
if ((globalSize[i] < localSize[i])) {
|
||||
_localSize[i] = globalSize[i];
|
||||
}else{
|
||||
_localSize[i] = localSize[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::setGlobalWorkgroupSize (const size_t *globalSize)
|
||||
{
|
||||
cl_uint i;
|
||||
for (i = 0; i < _dims; i++) {
|
||||
_globalSize[i] = globalSize[i];
|
||||
}
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::verifyData (DataContainerAttrib * reference, DataContainerAttrib * results, short regionNumber) {
|
||||
|
||||
std::ostringstream tmp;
|
||||
std::string errorLocation;
|
||||
|
||||
if (_testRange & Range::BASIC) {
|
||||
for (unsigned short i = 0; i < MAX_DIMS; i++) {
|
||||
tmp.str("");
|
||||
tmp.clear();
|
||||
tmp << "region number: " << regionNumber << " for dim: " << i;
|
||||
errorLocation = tmp.str();
|
||||
|
||||
if (results->get_global_size[i] != reference->get_global_size[i]) {
|
||||
_err.show(Error::ERR_GLOBAL_SIZE, errorLocation, results->get_global_size[i], reference->get_global_size[i]);
|
||||
}
|
||||
|
||||
if (results->get_global_offset[i] != reference->get_global_offset[i]) {
|
||||
_err.show(Error::ERR_GLOBAL_WORK_OFFSET, errorLocation, results->get_global_offset[i], reference->get_global_offset[i]);
|
||||
}
|
||||
|
||||
if (results->get_local_size[i] != reference->get_local_size[i] || results->get_local_size[i] > _maxWorkItemSizes[i]) {
|
||||
_err.show(Error::ERR_LOCAL_SIZE, errorLocation, results->get_local_size[i], reference->get_local_size[i]);
|
||||
}
|
||||
|
||||
if (results->get_enqueued_local_size[i] != reference->get_enqueued_local_size[i] || results->get_enqueued_local_size[i] > _maxWorkItemSizes[i]) {
|
||||
_err.show(Error::ERR_ENQUEUED_LOCAL_SIZE, errorLocation, results->get_enqueued_local_size[i], reference->get_enqueued_local_size[i]);
|
||||
}
|
||||
|
||||
if (results->get_num_groups[i] != reference->get_num_groups[i]) {
|
||||
_err.show(Error::ERR_NUM_GROUPS, errorLocation, results->get_num_groups[i], reference->get_num_groups[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tmp.str("");
|
||||
tmp.clear();
|
||||
tmp << "region number: " << regionNumber;
|
||||
errorLocation = tmp.str();
|
||||
if (_testRange & Range::BASIC) {
|
||||
if (results->get_work_dim != reference->get_work_dim) {
|
||||
_err.show(Error::ERR_WORK_DIM, errorLocation, results->get_work_dim, reference->get_work_dim);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::calculateExpectedValues () {
|
||||
size_t nonRemainderGlobalSize[MAX_DIMS];
|
||||
size_t numberOfPossibleRegions[MAX_DIMS];
|
||||
|
||||
nonRemainderGlobalSize[0] = _globalSize[0] - (_globalSize[0] % _enqueuedLocalSize[0]);
|
||||
nonRemainderGlobalSize[1] = _globalSize[1] - (_globalSize[1] % _enqueuedLocalSize[1]);
|
||||
nonRemainderGlobalSize[2] = _globalSize[2] - (_globalSize[2] % _enqueuedLocalSize[2]);
|
||||
|
||||
numberOfPossibleRegions[0] = (_globalSize[0]>1)?2:1;
|
||||
numberOfPossibleRegions[1] = (_globalSize[1]>1)?2:1;
|
||||
numberOfPossibleRegions[2] = (_globalSize[2]>1)?2:1;
|
||||
|
||||
for (cl_ushort i = 0; i < NUMBER_OF_REGIONS; ++i) {
|
||||
|
||||
if (i & 0x01 && numberOfPossibleRegions[0] == 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i & 0x02 && numberOfPossibleRegions[1] == 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i & 0x04 && numberOfPossibleRegions[2] == 1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (cl_ushort dim = 0; dim < MAX_DIMS; ++dim) {
|
||||
_referenceRegionArray[i].get_global_size[dim] = static_cast<unsigned long>(_globalSize[dim]);
|
||||
_referenceRegionArray[i].get_global_offset[dim] = static_cast<unsigned long>(_globalWorkOffset[dim]);
|
||||
_referenceRegionArray[i].get_enqueued_local_size[dim] = static_cast<unsigned long>(_enqueuedLocalSize[dim]);
|
||||
_referenceRegionArray[i].get_local_size[dim] = static_cast<unsigned long>(_enqueuedLocalSize[dim]);
|
||||
_referenceRegionArray[i].get_num_groups[dim] = static_cast<unsigned long>(ceil(static_cast<float>(_globalSize[dim]) / _enqueuedLocalSize[dim]));
|
||||
}
|
||||
_referenceRegionArray[i].get_work_dim = _dims;
|
||||
|
||||
if (i & 0x01) {
|
||||
_referenceRegionArray[i].get_local_size[0] = static_cast<unsigned long>((_globalSize[0] - 1) % _enqueuedLocalSize[0] + 1);
|
||||
}
|
||||
|
||||
if (i & 0x02) {
|
||||
_referenceRegionArray[i].get_local_size[1] = static_cast<unsigned long>((_globalSize[1] - 1) % _enqueuedLocalSize[1] + 1);
|
||||
}
|
||||
|
||||
if (i & 0x04) {
|
||||
_referenceRegionArray[i].get_local_size[2] = static_cast<unsigned long>((_globalSize[2] - 1) % _enqueuedLocalSize[2] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t TestNonUniformWorkGroup::getMaxLocalWorkgroupSize (const cl_device_id &device) {
|
||||
int err;
|
||||
|
||||
if (TestNonUniformWorkGroup::_maxLocalWorkgroupSize == 0) {
|
||||
err = clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE,
|
||||
sizeof(TestNonUniformWorkGroup::_maxLocalWorkgroupSize), &TestNonUniformWorkGroup::_maxLocalWorkgroupSize, NULL);
|
||||
}
|
||||
|
||||
return TestNonUniformWorkGroup::_maxLocalWorkgroupSize;
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::enableStrictMode(bool state) {
|
||||
TestNonUniformWorkGroup::_strictMode = state;
|
||||
}
|
||||
|
||||
int TestNonUniformWorkGroup::prepareDevice () {
|
||||
int err;
|
||||
cl_uint device_max_dimensions;
|
||||
|
||||
if (_globalSize[0] == 0)
|
||||
{
|
||||
log_error("Some arguments passed into constructor were wrong.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(_localSize_IsNull == false)
|
||||
calculateExpectedValues();
|
||||
|
||||
err = clGetDeviceInfo(_device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
|
||||
sizeof(device_max_dimensions), &device_max_dimensions, NULL);
|
||||
test_error(err, "clGetDeviceInfo failed");
|
||||
|
||||
err = clGetDeviceInfo(_device, CL_DEVICE_MAX_WORK_ITEM_SIZES,
|
||||
sizeof(_maxWorkItemSizes), _maxWorkItemSizes, NULL);
|
||||
|
||||
test_error(err, "clGetDeviceInfo failed");
|
||||
|
||||
std::string buildOptions = BUILD_CL_STD_2_0;
|
||||
if(_reqdWorkGroupSize[0] != 0 && _reqdWorkGroupSize[1] != 0 && _reqdWorkGroupSize[2] != 0) {
|
||||
std::ostringstream tmp(" ");
|
||||
tmp << " -D RWGSX=" << _reqdWorkGroupSize[0]
|
||||
<< " -D RWGSY=" << _reqdWorkGroupSize[1]
|
||||
<< " -D RWGSZ=" << _reqdWorkGroupSize[2] << " ";
|
||||
buildOptions += tmp.str();
|
||||
}
|
||||
|
||||
if (_testRange & Range::BASIC)
|
||||
buildOptions += " -D TESTBASIC";
|
||||
if (_testRange & Range::ATOMICS)
|
||||
buildOptions += " -D TESTATOMICS";
|
||||
if (_testRange & Range::BARRIERS)
|
||||
buildOptions += " -D TESTBARRIERS";
|
||||
|
||||
err = create_single_kernel_helper_with_build_options (_context, &_program, &_testKernel, 1,
|
||||
&KERNEL_FUNCTION, "testKernel", buildOptions.c_str());
|
||||
if (err)
|
||||
{
|
||||
log_error("Error %d in line: %d of file %s\n", err, __LINE__, __FILE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int TestNonUniformWorkGroup::verifyResults () {
|
||||
if (_localSize_IsNull) {
|
||||
// for global work groups where local work group size is not defined (set to NULL in clEnqueueNDRangeKernel)
|
||||
// we need to check what optimal size was chosen by device
|
||||
// we assumed that local size value for work item 0 is right for the rest work items
|
||||
_enqueuedLocalSize[0] = static_cast<size_t>(_resultsRegionArray[0].get_local_size[0]);
|
||||
_enqueuedLocalSize[1] = static_cast<size_t>(_resultsRegionArray[0].get_local_size[1]);
|
||||
_enqueuedLocalSize[2] = static_cast<size_t>(_resultsRegionArray[0].get_local_size[2]);
|
||||
calculateExpectedValues();
|
||||
|
||||
// strict mode verification
|
||||
if(_strictMode) {
|
||||
size_t localWorkGroupSize = _enqueuedLocalSize[0]*_enqueuedLocalSize[1]*_enqueuedLocalSize[2];
|
||||
if (localWorkGroupSize != TestNonUniformWorkGroup::getMaxLocalWorkgroupSize(_device))
|
||||
_err.show(Error::ERR_STRICT_MODE, "",localWorkGroupSize, TestNonUniformWorkGroup::getMaxLocalWorkgroupSize(_device));
|
||||
}
|
||||
|
||||
log_info ("Local work group size calculated by driver: %s\n", showArray(_enqueuedLocalSize, _dims).c_str());
|
||||
}
|
||||
|
||||
for (cl_ushort i = 0; i < NUMBER_OF_REGIONS; ++i) {
|
||||
verifyData(&_referenceRegionArray[i], &_resultsRegionArray[i], i);
|
||||
}
|
||||
|
||||
if (_testRange & Range::ATOMICS) {
|
||||
if (_globalAtomicTestValue != _numOfGlobalWorkItems) {
|
||||
_err.show(Error::ERR_GLOBAL_ATOMIC);
|
||||
}
|
||||
}
|
||||
|
||||
if (_err.checkError())
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::string showArray (const size_t *arr, cl_uint dims) {
|
||||
std::ostringstream tmpStringStream ("");
|
||||
|
||||
tmpStringStream << "{";
|
||||
for (cl_uint i=0; i < dims; i++) {
|
||||
tmpStringStream << arr[i];
|
||||
if (i+1 < dims)
|
||||
tmpStringStream << ", ";
|
||||
}
|
||||
tmpStringStream << "}";
|
||||
|
||||
return tmpStringStream.str();
|
||||
}
|
||||
|
||||
void TestNonUniformWorkGroup::showTestInfo () {
|
||||
std::string tmpString;
|
||||
log_info ("T E S T P A R A M E T E R S :\n");
|
||||
log_info ("\tNumber of dimensions:\t%d\n", _dims);
|
||||
|
||||
tmpString = showArray(_globalSize, _dims);
|
||||
|
||||
log_info("\tGlobal work group size:\t%s\n", tmpString.c_str());
|
||||
|
||||
if (!_localSize_IsNull) {
|
||||
tmpString = showArray(_enqueuedLocalSize, _dims);
|
||||
} else {
|
||||
tmpString = "NULL";
|
||||
}
|
||||
log_info("\tLocal work group size:\t%s\n", tmpString.c_str());
|
||||
|
||||
if (!_globalWorkOffset_IsNull) {
|
||||
tmpString = showArray(_globalWorkOffset, _dims);
|
||||
} else {
|
||||
tmpString = "NULL";
|
||||
}
|
||||
log_info("\tGlobal work group offset:\t%s\n", tmpString.c_str());
|
||||
|
||||
if (_reqdWorkGroupSize[0] != 0 && _reqdWorkGroupSize[1] != 0 && _reqdWorkGroupSize[2] != 0) {
|
||||
tmpString = showArray(_reqdWorkGroupSize, _dims);
|
||||
} else {
|
||||
tmpString = "attribute disabled";
|
||||
}
|
||||
log_info ("\treqd_work_group_size attribute:\t%s\n", tmpString.c_str());
|
||||
|
||||
tmpString = "";
|
||||
if(_testRange & Range::BASIC)
|
||||
tmpString += "basic";
|
||||
if(_testRange & Range::ATOMICS) {
|
||||
if(tmpString != "") tmpString += ", ";
|
||||
tmpString += "atomics";
|
||||
}
|
||||
if(_testRange & Range::BARRIERS) {
|
||||
if(tmpString != "") tmpString += ", ";
|
||||
tmpString += "barriers";
|
||||
}
|
||||
log_info ("\tTest range:\t%s\n", tmpString.c_str());
|
||||
if(_strictMode) {
|
||||
log_info ("\tStrict mode:\tON\n");
|
||||
if (!_localSize_IsNull) {
|
||||
log_info ("\tATTENTION: strict mode applies only NULL local work group size\n");
|
||||
} else {
|
||||
log_info ("\t\tExpected value of local work group size is %ld.\n",
|
||||
TestNonUniformWorkGroup::getMaxLocalWorkgroupSize(_device));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
int TestNonUniformWorkGroup::runKernel () {
|
||||
int err;
|
||||
|
||||
// TEST INFO
|
||||
showTestInfo();
|
||||
|
||||
size_t localArraySize = (_localSize_IsNull)?TestNonUniformWorkGroup::getMaxLocalWorkgroupSize(_device):(_enqueuedLocalSize[0]*_enqueuedLocalSize[1]*_enqueuedLocalSize[2]);
|
||||
clMemWrapper resultsRegionArray = clCreateBuffer(_context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, _resultsRegionArray.size() * sizeof(DataContainerAttrib), &_resultsRegionArray.front(), &err);
|
||||
test_error(err, "clCreateBuffer failed");
|
||||
|
||||
size_t *localSizePtr = (_localSize_IsNull)?NULL:_enqueuedLocalSize;
|
||||
size_t *globalWorkOffsetPtr = (_globalWorkOffset_IsNull)?NULL:_globalWorkOffset;
|
||||
|
||||
err = clSetKernelArg(_testKernel, 0, sizeof(resultsRegionArray), &resultsRegionArray);
|
||||
test_error(err, "clSetKernelArg failed");
|
||||
|
||||
//creating local buffer
|
||||
err = clSetKernelArg(_testKernel, 1, localArraySize*sizeof(unsigned int), NULL);
|
||||
test_error(err, "clSetKernelArg failed");
|
||||
|
||||
clMemWrapper testGlobalArray = clCreateBuffer(_context, CL_MEM_READ_WRITE, _numOfGlobalWorkItems*sizeof(cl_uint), NULL, &err);
|
||||
test_error(err, "clCreateBuffer failed");
|
||||
|
||||
err = clSetKernelArg(_testKernel, 2, sizeof(testGlobalArray), &testGlobalArray);
|
||||
test_error(err, "clSetKernelArg failed");
|
||||
|
||||
_globalAtomicTestValue = 0;
|
||||
clMemWrapper globalAtomicTestVariable = clCreateBuffer(_context, (CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR), sizeof(_globalAtomicTestValue), &_globalAtomicTestValue, &err);
|
||||
test_error(err, "clCreateBuffer failed");
|
||||
|
||||
err = clSetKernelArg(_testKernel, 3, sizeof(globalAtomicTestVariable), &globalAtomicTestVariable);
|
||||
test_error(err, "clSetKernelArg failed");
|
||||
|
||||
clMemWrapper errorArray = clCreateBuffer(_context, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR, _err.errorArrayCounterSize(), _err.errorArrayCounter(), &err);
|
||||
test_error(err, "clCreateBuffer failed");
|
||||
|
||||
err = clSetKernelArg(_testKernel, 4, sizeof(errorArray), &errorArray);
|
||||
test_error(err, "clSetKernelArg failed");
|
||||
|
||||
err = clEnqueueNDRangeKernel(_queue, _testKernel, _dims, globalWorkOffsetPtr, _globalSize,
|
||||
localSizePtr, 0, NULL, NULL);
|
||||
test_error(err, "clEnqueueNDRangeKernel failed");
|
||||
|
||||
|
||||
err = clFinish(_queue);
|
||||
test_error(err, "clFinish failed");
|
||||
|
||||
err = clEnqueueReadBuffer(_queue, globalAtomicTestVariable, CL_TRUE, 0, sizeof(unsigned int), &_globalAtomicTestValue, 0, NULL, NULL);
|
||||
test_error(err, "clEnqueueReadBuffer failed");
|
||||
|
||||
if (_err.checkError()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// synchronization of main buffer
|
||||
err = clEnqueueReadBuffer(_queue, resultsRegionArray, CL_TRUE, 0, _resultsRegionArray.size() * sizeof(DataContainerAttrib), &_resultsRegionArray.front(), 0, NULL, NULL);
|
||||
test_error(err, "clEnqueueReadBuffer failed");
|
||||
|
||||
err = clEnqueueReadBuffer(_queue, errorArray, CL_TRUE, 0, _err.errorArrayCounterSize(), _err.errorArrayCounter(), 0, NULL, NULL);
|
||||
test_error(err, "clEnqueueReadBuffer failed");
|
||||
// Synchronization of errors occurred in kernel into general error stats
|
||||
_err.synchronizeStatsMap();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void SubTestExecutor::runTestNonUniformWorkGroup(const cl_uint dims, const size_t *globalSize,
|
||||
const size_t *localSize, int range) {
|
||||
runTestNonUniformWorkGroup (dims, globalSize, localSize, NULL, NULL, range);
|
||||
}
|
||||
|
||||
void SubTestExecutor::runTestNonUniformWorkGroup(const cl_uint dims, const size_t *globalSize,
|
||||
const size_t *localSize, const size_t *globalWorkOffset,
|
||||
const size_t *reqdWorkGroupSize, int range) {
|
||||
|
||||
|
||||
int err;
|
||||
++_overallCounter;
|
||||
TestNonUniformWorkGroup test (_device, _context, _queue, dims, globalSize, localSize,
|
||||
NULL, globalWorkOffset, reqdWorkGroupSize);
|
||||
|
||||
test.setTestRange(range);
|
||||
err = test.prepareDevice();
|
||||
if (err) {
|
||||
log_error ("Error: prepare device\n");
|
||||
++_failCounter;
|
||||
return;
|
||||
}
|
||||
|
||||
err = test.runKernel();
|
||||
if (err) {
|
||||
log_error ("Error: run kernel\n");
|
||||
++_failCounter;
|
||||
return;
|
||||
}
|
||||
|
||||
err = test.verifyResults();
|
||||
if (err) {
|
||||
log_error ("Error: verify results\n");
|
||||
++_failCounter;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
int SubTestExecutor::calculateWorkGroupSize(size_t &maxWgSize, int testRange) {
|
||||
int err;
|
||||
|
||||
clProgramWrapper program;
|
||||
clKernelWrapper testKernel;
|
||||
std::string buildOptions = BUILD_CL_STD_2_0;
|
||||
|
||||
if (testRange & Range::BASIC)
|
||||
buildOptions += " -D TESTBASIC";
|
||||
if (testRange & Range::ATOMICS)
|
||||
buildOptions += " -D TESTATOMICS";
|
||||
if (testRange & Range::BARRIERS)
|
||||
buildOptions += " -D TESTBARRIERS";
|
||||
|
||||
err = create_single_kernel_helper_with_build_options (_context, &program, &testKernel, 1,
|
||||
&KERNEL_FUNCTION, "testKernel", buildOptions.c_str());
|
||||
if (err)
|
||||
{
|
||||
log_error("Error %d in line: %d of file %s\n", err, __LINE__, __FILE__);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = clGetKernelWorkGroupInfo (testKernel, _device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxWgSize), &maxWgSize, NULL);
|
||||
test_error(err, "clGetKernelWorkGroupInfo failed");
|
||||
|
||||
TestNonUniformWorkGroup::setMaxLocalWorkgroupSize(maxWgSize);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int SubTestExecutor::status() {
|
||||
|
||||
if (_failCounter>0) {
|
||||
log_error ("%d subtest(s) (of %d) failed\n", _failCounter, _overallCounter);
|
||||
return -1;
|
||||
} else {
|
||||
log_info ("All %d subtest(s) passed\n", _overallCounter);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#ifndef _TESTNONUNIFORMWORKGROUP_H
|
||||
#define _TESTNONUNIFORMWORKGROUP_H
|
||||
|
||||
#include "procs.h"
|
||||
#include <vector>
|
||||
#include "tools.h"
|
||||
#include <algorithm>
|
||||
|
||||
#define MAX_SIZE_OF_ALLOCATED_MEMORY (400*1024*1024)
|
||||
|
||||
#define NUMBER_OF_REGIONS 8
|
||||
|
||||
#define BUILD_CL_STD_2_0 "-cl-std=CL2.0"
|
||||
|
||||
#define MAX_DIMS 3
|
||||
|
||||
// This structure reflects data received from kernel.
|
||||
typedef struct _DataContainerAttrib
|
||||
{
|
||||
cl_ulong get_global_size[MAX_DIMS];
|
||||
cl_ulong get_global_offset[MAX_DIMS];
|
||||
cl_ulong get_local_size[MAX_DIMS];
|
||||
cl_ulong get_enqueued_local_size[MAX_DIMS];
|
||||
cl_ulong get_global_id[MAX_DIMS];
|
||||
cl_ulong get_local_id[MAX_DIMS];
|
||||
cl_ulong get_group_id[MAX_DIMS];
|
||||
cl_ulong get_num_groups[MAX_DIMS];
|
||||
cl_ulong get_work_dim;
|
||||
cl_ushort test_local_barrier_result_bool;
|
||||
cl_ushort test_global_barrier_result_bool;
|
||||
cl_ushort test_local_atomic_result_value;
|
||||
}DataContainerAttrib;
|
||||
|
||||
// Describes range of testing.
|
||||
namespace Range {
|
||||
enum RangeEnum {
|
||||
BASIC = (1 << 0),
|
||||
BARRIERS = (1 << 1),
|
||||
ATOMICS = (1 << 2),
|
||||
|
||||
ALL = Range::BASIC | Range::BARRIERS | Range::ATOMICS
|
||||
};
|
||||
}
|
||||
|
||||
std::string showArray (const size_t *arr, cl_uint dims);
|
||||
|
||||
// Main class responsible for testing
|
||||
class TestNonUniformWorkGroup {
|
||||
public:
|
||||
|
||||
TestNonUniformWorkGroup (const cl_device_id &device, const cl_context &context,
|
||||
const cl_command_queue &queue, const cl_uint dims, const size_t *globalSize,
|
||||
const size_t *localSize, const size_t *buffersSize, const size_t *globalWorkOffset,
|
||||
const size_t *reqdWorkGroupSize=NULL);
|
||||
|
||||
~TestNonUniformWorkGroup ();
|
||||
|
||||
static size_t getMaxLocalWorkgroupSize (const cl_device_id &device);
|
||||
static void setMaxLocalWorkgroupSize (size_t workGroupSize) {
|
||||
TestNonUniformWorkGroup::_maxLocalWorkgroupSize = workGroupSize;
|
||||
}
|
||||
static void enableStrictMode (bool state);
|
||||
|
||||
void setTestRange (int range) {_testRange = range;}
|
||||
int prepareDevice ();
|
||||
int verifyResults ();
|
||||
int runKernel ();
|
||||
|
||||
private:
|
||||
size_t _globalSize[MAX_DIMS];
|
||||
size_t _localSize[MAX_DIMS];
|
||||
size_t _globalWorkOffset[MAX_DIMS];
|
||||
bool _globalWorkOffset_IsNull;
|
||||
size_t _enqueuedLocalSize[MAX_DIMS];
|
||||
bool _localSize_IsNull;
|
||||
size_t _reqdWorkGroupSize[MAX_DIMS];
|
||||
static size_t _maxLocalWorkgroupSize;
|
||||
size_t _maxWorkItemSizes[MAX_DIMS];
|
||||
size_t _numOfGlobalWorkItems; // in global work group
|
||||
const cl_device_id _device;
|
||||
const cl_context _context;
|
||||
const cl_command_queue _queue;
|
||||
const cl_uint _dims;
|
||||
|
||||
int _testRange;
|
||||
|
||||
std::vector<DataContainerAttrib> _resultsRegionArray;
|
||||
std::vector<DataContainerAttrib> _referenceRegionArray;
|
||||
cl_uint _globalAtomicTestValue;
|
||||
|
||||
clProgramWrapper _program;
|
||||
clKernelWrapper _testKernel;
|
||||
|
||||
Error::ErrorClass _err;
|
||||
|
||||
TestNonUniformWorkGroup ();
|
||||
|
||||
static bool _strictMode;
|
||||
void setLocalWorkgroupSize (const size_t *globalSize, const size_t *localSize);
|
||||
void setGlobalWorkgroupSize (const size_t *globalSize);
|
||||
void verifyData (DataContainerAttrib * reference, DataContainerAttrib * results, short regionNumber);
|
||||
void calculateExpectedValues ();
|
||||
void showTestInfo ();
|
||||
};
|
||||
|
||||
// Class responsible for running subtest scenarios in test function
|
||||
class SubTestExecutor {
|
||||
public:
|
||||
SubTestExecutor(const cl_device_id &device, const cl_context &context, const cl_command_queue &queue)
|
||||
: _device (device), _context (context), _queue (queue), _failCounter (0), _overallCounter (0) {}
|
||||
|
||||
void runTestNonUniformWorkGroup (const cl_uint dims, const size_t *globalSize,
|
||||
const size_t *localSize, int range);
|
||||
|
||||
void runTestNonUniformWorkGroup (const cl_uint dims, const size_t *globalSize,
|
||||
const size_t *localSize, const size_t *globalWorkOffset,
|
||||
const size_t *reqdWorkGroupSize, int range);
|
||||
|
||||
int calculateWorkGroupSize(size_t &maxWgSize, int testRange);
|
||||
int status();
|
||||
|
||||
private:
|
||||
SubTestExecutor();
|
||||
const cl_device_id _device;
|
||||
const cl_context _context;
|
||||
const cl_command_queue _queue;
|
||||
unsigned int _failCounter;
|
||||
unsigned int _overallCounter;
|
||||
};
|
||||
|
||||
#endif // _TESTNONUNIFORMWORKGROUP_H
|
||||
88
test_conformance/non_uniform_work_group/main.cpp
Normal file
88
test_conformance/non_uniform_work_group/main.cpp
Normal file
@@ -0,0 +1,88 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "procs.h"
|
||||
#include "tools.h"
|
||||
#include "../../test_common/harness/testHarness.h"
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
|
||||
basefn basefn_list[] = {
|
||||
test_non_uniform_1d_basic,
|
||||
test_non_uniform_1d_atomics,
|
||||
test_non_uniform_1d_barriers,
|
||||
|
||||
test_non_uniform_2d_basic,
|
||||
test_non_uniform_2d_atomics,
|
||||
test_non_uniform_2d_barriers,
|
||||
|
||||
test_non_uniform_3d_basic,
|
||||
test_non_uniform_3d_atomics,
|
||||
test_non_uniform_3d_barriers,
|
||||
|
||||
test_non_uniform_other_basic,
|
||||
test_non_uniform_other_atomics,
|
||||
test_non_uniform_other_barriers
|
||||
};
|
||||
|
||||
const char *basefn_names[] = {
|
||||
"non_uniform_1d_basic",
|
||||
"non_uniform_1d_atomics",
|
||||
"non_uniform_1d_barriers",
|
||||
|
||||
"non_uniform_2d_basic",
|
||||
"non_uniform_2d_atomics",
|
||||
"non_uniform_2d_barriers",
|
||||
|
||||
"non_uniform_3d_basic",
|
||||
"non_uniform_3d_atomics",
|
||||
"non_uniform_3d_barriers",
|
||||
|
||||
"non_uniform_other_basic",
|
||||
"non_uniform_other_atomics",
|
||||
"non_uniform_other_barriers",
|
||||
};
|
||||
|
||||
ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
|
||||
|
||||
int num_fns = sizeof(basefn_names) / sizeof(char *);
|
||||
|
||||
int main(int argc, const char *argv[])
|
||||
{
|
||||
typedef std::vector<const char *> ArgsVector;
|
||||
ArgsVector programArgs;
|
||||
programArgs.assign(argv, argv+argc);
|
||||
|
||||
int numFns = num_fns;
|
||||
basefn *baseFnList = basefn_list;
|
||||
const char **baseFnNames = basefn_names;
|
||||
|
||||
for (ArgsVector::iterator it = programArgs.begin(); it!=programArgs.end();) {
|
||||
|
||||
if(*it == std::string("-strict")) {
|
||||
TestNonUniformWorkGroup::enableStrictMode(true);
|
||||
it=programArgs.erase(it);
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
PrimeNumbers::generatePrimeNumbers(100000);
|
||||
|
||||
return runTestHarness(static_cast<int>(programArgs.size()), &programArgs.front(), numFns, baseFnList, baseFnNames, false /* image support required */, false /* force no context creation */, 0 );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
32
test_conformance/non_uniform_work_group/procs.h
Normal file
32
test_conformance/non_uniform_work_group/procs.h
Normal file
@@ -0,0 +1,32 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "../../test_common/harness/typeWrappers.h"
|
||||
|
||||
extern int test_non_uniform_1d_basic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_1d_atomics(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_1d_barriers(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
|
||||
extern int test_non_uniform_2d_basic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_2d_atomics(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_2d_barriers(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
|
||||
extern int test_non_uniform_3d_basic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_3d_atomics(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_3d_barriers(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
|
||||
extern int test_non_uniform_other_basic(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_other_atomics(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
extern int test_non_uniform_other_barriers(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
|
||||
383
test_conformance/non_uniform_work_group/test_advanced_2d.cpp
Normal file
383
test_conformance/non_uniform_work_group/test_advanced_2d.cpp
Normal file
@@ -0,0 +1,383 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "procs.h"
|
||||
#include "tools.h"
|
||||
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
|
||||
int
|
||||
test_non_uniform_2d_basic(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BASIC);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_2d_max_wg_size_plus_1_basic
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize/2, 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 1759;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber};
|
||||
size_t localSize[] = {16, maxWgSize/16};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_basic_2
|
||||
{
|
||||
int primeNumber = 1327;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_combination_of_max_wg_size_basic
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize + 2, maxWgSize + 4};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_and_ls_null_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 1669;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_and_ls_null_basic
|
||||
{
|
||||
unsigned int primeNumber = 1249;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_four_prime_numbers_basic
|
||||
{
|
||||
unsigned int primeNumber = 1951;
|
||||
unsigned int primeNumber2 = 911;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_2d_atomics(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::ATOMICS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_2d_max_wg_size_plus_1_atomics
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize/2, 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 1759;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber};
|
||||
size_t localSize[] = {16, maxWgSize/16};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_atomics_2
|
||||
{
|
||||
int primeNumber = 1327;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_combination_of_max_wg_size_atomics
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize + 2, maxWgSize + 4};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_and_ls_null_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 1669;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_and_ls_null_atomics
|
||||
{
|
||||
unsigned int primeNumber = 1249;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_four_prime_numbers_atomics
|
||||
{
|
||||
unsigned int primeNumber = 1951;
|
||||
unsigned int primeNumber2 = 911;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_2d_barriers(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BARRIERS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_2d_max_wg_size_plus_1_barriers
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber, maxWgSize};
|
||||
size_t localSize[] = {maxWgSize/2, 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 1759;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber};
|
||||
size_t localSize[] = {16, maxWgSize/16};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_barriers_2
|
||||
{
|
||||
int primeNumber = 1327;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_combination_of_max_wg_size_barriers
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize + 2, maxWgSize + 4};
|
||||
size_t localSize[] = {maxWgSize/32, 32};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_two_prime_numbers_and_ls_null_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 1669;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_prime_number_and_ls_null_barriers
|
||||
{
|
||||
unsigned int primeNumber = 1249;
|
||||
size_t globalSize[] = {primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_four_prime_numbers_barriers
|
||||
{
|
||||
unsigned int primeNumber = 1951;
|
||||
unsigned int primeNumber2 = 911;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
size_t globalSize[] = {primeNumber, primeNumber2};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
410
test_conformance/non_uniform_work_group/test_advanced_3d.cpp
Normal file
410
test_conformance/non_uniform_work_group/test_advanced_3d.cpp
Normal file
@@ -0,0 +1,410 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "procs.h"
|
||||
#include "tools.h"
|
||||
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
|
||||
int
|
||||
test_non_uniform_3d_basic(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BASIC);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_3d_max_wg_size_plus_1_basic
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize/24, maxWgSize/24};
|
||||
size_t localSize[] = {maxWgSize, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {maxWgSize/25, primeNumber, maxWgSize/25};
|
||||
size_t localSize[] = {2, std::max<size_t>(maxWgSize/4,1), 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 13;
|
||||
size_t globalSize[] = {primeNumber2, maxWgSize/8, primeNumber};
|
||||
size_t localSize[] = {8, 4, std::max<size_t>(maxWgSize/32,1)};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_basic_2
|
||||
{
|
||||
int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t localSize[] = {8, std::max<size_t>(maxWgSize/32,1), 4};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_and_ls_null_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 23;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, maxWgSize/16};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_and_ls_null_basic
|
||||
{
|
||||
unsigned int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_three_prime_numbers_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 10711;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_four_prime_numbers_basic
|
||||
{
|
||||
unsigned int primeNumber = 541;
|
||||
unsigned int primeNumber2 = 251;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_basic
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4,primeNumber5,primeNumber6,maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_3d_atomics(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::ATOMICS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_3d_max_wg_size_plus_1_atomics
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize/24, maxWgSize/24};
|
||||
size_t localSize[] = {maxWgSize, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {maxWgSize/25, primeNumber, maxWgSize/25};
|
||||
size_t localSize[] = {2, std::max<size_t>(maxWgSize/4,1), 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 13;
|
||||
size_t globalSize[] = {primeNumber2, maxWgSize/8, primeNumber};
|
||||
size_t localSize[] = {8, 4, std::max<size_t>(maxWgSize/32,1)};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_atomics_2
|
||||
{
|
||||
int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t localSize[] = {8, std::max<size_t>(maxWgSize/32,1), 4};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_and_ls_null_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 23;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, maxWgSize/16};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_and_ls_null_atomics
|
||||
{
|
||||
unsigned int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_three_prime_numbers_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 10711;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_four_prime_numbers_atomics
|
||||
{
|
||||
unsigned int primeNumber = 541;
|
||||
unsigned int primeNumber2 = 251;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_atomics
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_3d_barriers(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BARRIERS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_3d_max_wg_size_plus_1_barriers
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1, maxWgSize/24, maxWgSize/24};
|
||||
size_t localSize[] = {maxWgSize, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {maxWgSize/25, primeNumber, maxWgSize/25};
|
||||
size_t localSize[] = {2, std::max<size_t>(maxWgSize/4,1), 2};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
int primeNumber2 = 13;
|
||||
size_t globalSize[] = {primeNumber2, maxWgSize/8, primeNumber};
|
||||
size_t localSize[] = {8, 4, std::max<size_t>(maxWgSize/32,1)};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_barriers_2
|
||||
{
|
||||
int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t localSize[] = {8, std::max<size_t>(maxWgSize/32,1), 4};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_two_prime_numbers_and_ls_null_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 23;
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, maxWgSize/16};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_prime_number_and_ls_null_barriers
|
||||
{
|
||||
unsigned int primeNumber = 113;
|
||||
size_t globalSize[] = {primeNumber, primeNumber, primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_three_prime_numbers_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 10711;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_four_prime_numbers_barriers
|
||||
{
|
||||
unsigned int primeNumber = 541;
|
||||
unsigned int primeNumber2 = 251;
|
||||
unsigned int primeNumber3 = 13;
|
||||
unsigned int primeNumber4 = 17;
|
||||
PrimeNumbers::Result2d fit2dResult;
|
||||
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit2dResult.Val1, fit2dResult.Val2, 1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_barriers
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4,primeNumber5,primeNumber6,maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
279
test_conformance/non_uniform_work_group/test_advanced_other.cpp
Normal file
279
test_conformance/non_uniform_work_group/test_advanced_other.cpp
Normal file
@@ -0,0 +1,279 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "procs.h"
|
||||
#include "tools.h"
|
||||
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
|
||||
int
|
||||
test_non_uniform_other_basic(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BASIC);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_offset_basic
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
size_t offset[] = {23};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_offset_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
size_t offset[] = {23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_offset_basic
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t offset[] = {11, 23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_rwgs_basic
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t reqdWorkGroupSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, NULL, reqdWorkGroupSize, Range::BASIC);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_other_atomics(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::ATOMICS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_offset_atomics
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
size_t offset[] = {23};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_offset_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
size_t offset[] = {23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_offset_atomics
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t offset[] = {11, 23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_rwgs_atomics
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t reqdWorkGroupSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, NULL, reqdWorkGroupSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_other_barriers(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BARRIERS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_offset_barriers
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
size_t offset[] = {23};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_2d_three_prime_numbers_offset_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize/2, maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
unsigned int primeNumber2 = 42967;
|
||||
unsigned int primeNumber3 = 13;
|
||||
size_t globalSize[] = {primeNumber2, primeNumber3};
|
||||
size_t localSize[] = {primeNumber, 1};
|
||||
size_t offset[] = {23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_offset_barriers
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t offset[] = {11, 23, 17};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_3d_six_prime_numbers_rwgs_barriers
|
||||
{
|
||||
unsigned int primeNumber = 373;
|
||||
unsigned int primeNumber2 = 13;
|
||||
unsigned int primeNumber3 = 279;
|
||||
unsigned int primeNumber4 = 3;
|
||||
unsigned int primeNumber5 = 5;
|
||||
unsigned int primeNumber6 = 7;
|
||||
PrimeNumbers::Result3d fit3dResult;
|
||||
|
||||
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber, primeNumber2, primeNumber3};
|
||||
|
||||
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
size_t reqdWorkGroupSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, NULL, reqdWorkGroupSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
398
test_conformance/non_uniform_work_group/test_basic.cpp
Normal file
398
test_conformance/non_uniform_work_group/test_basic.cpp
Normal file
@@ -0,0 +1,398 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "procs.h"
|
||||
#include "tools.h"
|
||||
|
||||
#include "TestNonUniformWorkGroup.h"
|
||||
|
||||
int
|
||||
test_non_uniform_1d_basic(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BASIC);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_1_basic
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_basic
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_basic
|
||||
{
|
||||
int primeNumber = 11;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_basic_2
|
||||
{
|
||||
int primeNumber = 53;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_2max_wg_size_minus_1_basic
|
||||
{
|
||||
size_t globalSize[] = {2*maxWgSize - 1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_basic_2
|
||||
{
|
||||
unsigned int primeNumber = 20101;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_basic_3
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_basic_4
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_basic_2
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_basic_3
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_basic
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_1d_atomics(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::ATOMICS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_1_atomics
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_atomics
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_atomics
|
||||
{
|
||||
int primeNumber = 11;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_atomics_2
|
||||
{
|
||||
int primeNumber = 53;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_2max_wg_size_minus_1_atomics
|
||||
{
|
||||
size_t globalSize[] = {2*maxWgSize - 1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_atomics_2
|
||||
{
|
||||
unsigned int primeNumber = 20101;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_atomics_3
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_atomics_4
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_atomics_2
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_atomics_3
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_atomics
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
|
||||
int
|
||||
test_non_uniform_1d_barriers(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
|
||||
{
|
||||
SubTestExecutor exec(device, context, queue);
|
||||
|
||||
size_t maxWgSize;
|
||||
int err;
|
||||
err = exec.calculateWorkGroupSize(maxWgSize, Range::BARRIERS);
|
||||
if (err) {
|
||||
log_error ("Cannot calculate work group size.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_1_barriers
|
||||
{
|
||||
size_t globalSize[] = {maxWgSize+1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_barriers
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_barriers
|
||||
{
|
||||
int primeNumber = 11;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_max_wg_size_plus_prime_number_barriers_2
|
||||
{
|
||||
int primeNumber = 53;
|
||||
size_t globalSize[] = {maxWgSize+primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_2max_wg_size_minus_1_barriers
|
||||
{
|
||||
size_t globalSize[] = {2*maxWgSize - 1};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_barriers_2
|
||||
{
|
||||
unsigned int primeNumber = 20101;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_barriers_3
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_barriers_4
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {maxWgSize};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_barriers_2
|
||||
{
|
||||
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
|
||||
if (primeNumber < 1) {
|
||||
log_error ("Cannot find proper prime number.");
|
||||
return -1;
|
||||
}
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_prime_number_and_ls_null_barriers_3
|
||||
{
|
||||
unsigned int primeNumber = 65521;
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t *localSize = NULL;
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
// non_uniform_1d_two_prime_numbers_barriers
|
||||
{
|
||||
unsigned int primeNumber = 42967;
|
||||
unsigned int primeNumber2 = 113;
|
||||
|
||||
PrimeNumbers::Result1d fit1dResult;
|
||||
|
||||
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize );
|
||||
|
||||
size_t globalSize[] = {primeNumber};
|
||||
size_t localSize[] = {fit1dResult.Val1};
|
||||
|
||||
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
|
||||
}
|
||||
|
||||
return exec.status();
|
||||
}
|
||||
274
test_conformance/non_uniform_work_group/tools.cpp
Normal file
274
test_conformance/non_uniform_work_group/tools.cpp
Normal file
@@ -0,0 +1,274 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include "tools.h"
|
||||
#include <sstream>
|
||||
#include "../../test_common/harness/errorHelpers.h"
|
||||
|
||||
PrimeNumbersCollection PrimeNumbers::primeNumbers;
|
||||
// Method generates prime numbers using Sieve of Eratosthenes algorithm
|
||||
void PrimeNumbers::generatePrimeNumbers (unsigned int maxValue) {
|
||||
|
||||
primeNumbers.clear();
|
||||
|
||||
for (unsigned int i=2; i < maxValue; i++)
|
||||
primeNumbers.push_back(i);
|
||||
|
||||
PrimeNumbersCollection::iterator it, it2;
|
||||
it = primeNumbers.begin();
|
||||
it2 = primeNumbers.begin();
|
||||
|
||||
unsigned int maxValueSqrt = (unsigned int)sqrt((double)maxValue);
|
||||
|
||||
for (; it != primeNumbers.end(); it++) {
|
||||
it2 = it;
|
||||
++it2;
|
||||
if(*it>maxValueSqrt)
|
||||
break;
|
||||
for (;it2 != primeNumbers.end();)
|
||||
if (*it2 % *it == 0)
|
||||
it2 = primeNumbers.erase(it2);
|
||||
else
|
||||
++it2;
|
||||
}
|
||||
}
|
||||
|
||||
// Returns prime number for specified range
|
||||
int PrimeNumbers::getPrimeNumberInRange (size_t lowerValue, size_t higherValue) {
|
||||
if(lowerValue >= higherValue)
|
||||
return -1;
|
||||
|
||||
if(primeNumbers.back() < lowerValue)
|
||||
return -2;
|
||||
|
||||
PrimeNumbersCollection::iterator it = primeNumbers.begin();
|
||||
|
||||
for (; it != primeNumbers.end(); ++it) {
|
||||
if (lowerValue<*it) {
|
||||
if(higherValue>*it)
|
||||
return *it;
|
||||
else
|
||||
return -3;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
int PrimeNumbers::getNextLowerPrimeNumber(size_t upperValue) {
|
||||
size_t retVal = 1;
|
||||
|
||||
PrimeNumbersCollection::iterator it = primeNumbers.begin();
|
||||
|
||||
for (; it != primeNumbers.end(); ++it) {
|
||||
if (upperValue > *it) {
|
||||
retVal = *it;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
PrimeNumbers::Result1d PrimeNumbers::fitMaxPrime1d(size_t val1, size_t maxVal){
|
||||
|
||||
PrimeNumbers::Result1d result;
|
||||
|
||||
if (maxVal == 1) {
|
||||
result.Val1 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
while(val1 > maxVal)
|
||||
{
|
||||
val1 = PrimeNumbers::getNextLowerPrimeNumber(val1);
|
||||
}
|
||||
|
||||
result.Val1 = val1;
|
||||
return result;
|
||||
}
|
||||
|
||||
PrimeNumbers::Result2d PrimeNumbers::fitMaxPrime2d(size_t val1, size_t val2, size_t productMax) {
|
||||
|
||||
PrimeNumbers::Result2d result;
|
||||
|
||||
if (productMax == 1) {
|
||||
result.Val1 = 1;
|
||||
result.Val2 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
while ((val2 * val1) > productMax) {
|
||||
if ((val2 > val1) && (val2 > 1)) {
|
||||
val2 = PrimeNumbers::getNextLowerPrimeNumber(val2);
|
||||
continue;
|
||||
}
|
||||
if (val1 > 1) {
|
||||
val1 = PrimeNumbers::getNextLowerPrimeNumber(val1);
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
result.Val1 = val1;
|
||||
result.Val2 = val2;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
PrimeNumbers::Result3d PrimeNumbers::fitMaxPrime3d(size_t val1, size_t val2, size_t val3, size_t productMax) {
|
||||
|
||||
Result3d result;
|
||||
|
||||
if (productMax == 1) {
|
||||
result.Val1 = 1;
|
||||
result.Val2 = 1;
|
||||
result.Val3 = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
while ((val3 * val2 * val1) > productMax) {
|
||||
if ((val3 > val2) && (val3 > val1) && (val3 > 1)) {
|
||||
val3 = PrimeNumbers::getNextLowerPrimeNumber(val3);
|
||||
continue;
|
||||
}
|
||||
if ((val2 > val1) && (val2 > 1)) {
|
||||
val2 = PrimeNumbers::getNextLowerPrimeNumber(val2);
|
||||
continue;
|
||||
}
|
||||
if (val1 > 1) {
|
||||
val1 = PrimeNumbers::getNextLowerPrimeNumber(val1);
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
result.Val1 = val1;
|
||||
result.Val2 = val2;
|
||||
result.Val3 = val3;
|
||||
return result;
|
||||
}
|
||||
|
||||
namespace Error {
|
||||
ErrorMap::value_type rawDataErrorString[] = {
|
||||
ErrorMap::value_type(ERR_GLOBAL_SIZE, "global size"),
|
||||
ErrorMap::value_type(ERR_GLOBAL_WORK_OFFSET, "global work offset"),
|
||||
ErrorMap::value_type(ERR_LOCAL_SIZE, "local size"),
|
||||
ErrorMap::value_type(ERR_GLOBAL_ID, "global id"),
|
||||
ErrorMap::value_type(ERR_LOCAL_ID, "local id"),
|
||||
ErrorMap::value_type(ERR_ENQUEUED_LOCAL_SIZE, "enqueued local size"),
|
||||
ErrorMap::value_type(ERR_LOCAL_SIZE, "local size"),
|
||||
ErrorMap::value_type(ERR_NUM_GROUPS, "num groups"),
|
||||
ErrorMap::value_type(ERR_GROUP_ID, "group id"),
|
||||
ErrorMap::value_type(ERR_WORK_DIM, "work dim"),
|
||||
ErrorMap::value_type(ERR_GLOBAL_BARRIER, "global barrier"),
|
||||
ErrorMap::value_type(ERR_LOCAL_BARRIER, "local barrier"),
|
||||
ErrorMap::value_type(ERR_GLOBAL_ATOMIC, "global atomic"),
|
||||
ErrorMap::value_type(ERR_LOCAL_ATOMIC, "local atomic"),
|
||||
ErrorMap::value_type(ERR_STRICT_MODE, "strict requirements failed. Wrong local work group size"),
|
||||
ErrorMap::value_type(ERR_BUILD_STATUS, "build status"),
|
||||
ErrorMap::value_type(ERR_UNKNOWN, "[unknown]"),
|
||||
ErrorMap::value_type(ERR_DIFFERENT, "[different]"),
|
||||
};
|
||||
|
||||
const int numElems = sizeof(rawDataErrorString)/sizeof(rawDataErrorString[0]);
|
||||
ErrorMap errorString (rawDataErrorString, rawDataErrorString+numElems);
|
||||
|
||||
ErrorClass::ErrorClass() {
|
||||
_overallNumberOfErrors = 0;
|
||||
_stats.clear();
|
||||
for (unsigned short i=0; i<sizeof(_errorArrayCounter)/sizeof(_errorArrayCounter[0]); i++) {
|
||||
_errorArrayCounter[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void ErrorClass::show(Type err, std::string where, std::string additionalInfo) {
|
||||
++_overallNumberOfErrors;
|
||||
|
||||
err = (errorString.find(err) == errorString.end())?ERR_UNKNOWN:err;
|
||||
++_stats[err];
|
||||
|
||||
if (_overallNumberOfErrors == MAX_NUMBER_OF_PRINTED_ERRORS)
|
||||
printError("\t. . . Too many errors. Application will skip printing them.");
|
||||
|
||||
if (_overallNumberOfErrors >= MAX_NUMBER_OF_PRINTED_ERRORS)
|
||||
return;
|
||||
|
||||
std::string errString = "Error ";
|
||||
errString += errorString[err];
|
||||
errString += " appeared";
|
||||
|
||||
if(where.compare("") != 0) {
|
||||
errString += " in ";
|
||||
errString += where;
|
||||
}
|
||||
|
||||
if(additionalInfo.compare("") != 0) {
|
||||
errString += " ";
|
||||
errString += additionalInfo;
|
||||
}
|
||||
printError(errString);
|
||||
}
|
||||
|
||||
void ErrorClass::show(Type whatErr, std::string where, cl_ulong valueIs, cl_ulong valueExpected) {
|
||||
std::ostringstream tmp;
|
||||
tmp << "(is: " << valueIs << ", expected: " << valueExpected << ")";
|
||||
show(whatErr, where, tmp.str());
|
||||
}
|
||||
|
||||
|
||||
void ErrorClass::show(std::string description) {
|
||||
++_overallNumberOfErrors;
|
||||
++_stats[ERR_DIFFERENT];
|
||||
if (_overallNumberOfErrors < MAX_NUMBER_OF_PRINTED_ERRORS)
|
||||
printError(description);
|
||||
|
||||
if (_overallNumberOfErrors == MAX_NUMBER_OF_PRINTED_ERRORS)
|
||||
printError("\t. . . Too many errors. Application will skip printing them.");
|
||||
}
|
||||
|
||||
void ErrorClass::printError(std::string errString) {
|
||||
log_error ("%s\n", errString.c_str());
|
||||
}
|
||||
|
||||
void ErrorClass::showStats() {
|
||||
|
||||
Type err;
|
||||
log_info ("T E S T S U M M A R Y:\n");
|
||||
for (ErrorStats::iterator it = _stats.begin(); it != _stats.end(); it++) {
|
||||
err = (errorString.find(it->first) == errorString.end())?ERR_UNKNOWN:it->first;
|
||||
std::string errName = errorString[err];
|
||||
log_info("Error %s:\t%d\n", errName.c_str(), it->second);
|
||||
}
|
||||
|
||||
log_info("Overall number of errors:\t%d\n", _overallNumberOfErrors);
|
||||
|
||||
}
|
||||
|
||||
bool ErrorClass::checkError() {
|
||||
return _overallNumberOfErrors > 0;
|
||||
}
|
||||
|
||||
// This method is required to synchronize errors counters between kernel and host
|
||||
void ErrorClass::synchronizeStatsMap() {
|
||||
for (unsigned short i=0; i<sizeof(_errorArrayCounter)/sizeof(_errorArrayCounter[0]); i++) {
|
||||
if(_errorArrayCounter[i] == 0)
|
||||
continue;
|
||||
|
||||
_stats[static_cast<Type>(i)] += _errorArrayCounter[i];
|
||||
_overallNumberOfErrors += _errorArrayCounter[i];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
109
test_conformance/non_uniform_work_group/tools.h
Normal file
109
test_conformance/non_uniform_work_group/tools.h
Normal file
@@ -0,0 +1,109 @@
|
||||
//
|
||||
// Copyright (c) 2017 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#ifndef _TOOLS_H
|
||||
#define _TOOLS_H
|
||||
|
||||
#include "procs.h"
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
typedef std::vector<unsigned int> PrimeNumbersCollection;
|
||||
|
||||
|
||||
|
||||
// Class responsible for distributing prime numbers
|
||||
class PrimeNumbers {
|
||||
|
||||
public:
|
||||
struct Result1d{
|
||||
size_t Val1;
|
||||
};
|
||||
|
||||
struct Result2d{
|
||||
size_t Val1;
|
||||
size_t Val2;
|
||||
};
|
||||
|
||||
struct Result3d{
|
||||
size_t Val1;
|
||||
size_t Val2;
|
||||
size_t Val3;
|
||||
};
|
||||
|
||||
static void generatePrimeNumbers (unsigned int maxValue);
|
||||
static int getPrimeNumberInRange (size_t lowerValue, size_t higherValue);
|
||||
static int getNextLowerPrimeNumber (size_t upperValue);
|
||||
static Result1d fitMaxPrime1d(size_t Val1, size_t productMax);
|
||||
// Return val1 and Val2 which are largest prime numbers who's product is <= productMax
|
||||
static Result2d fitMaxPrime2d(size_t Val1, size_t Val2, size_t productMax);
|
||||
// Return val1, val2 and val3, which are largest prime numbers who's product is <= productMax
|
||||
static Result3d fitMaxPrime3d(size_t Val1, size_t Val2, size_t Val3, size_t productMax);
|
||||
private:
|
||||
static PrimeNumbersCollection primeNumbers;
|
||||
PrimeNumbers();
|
||||
};
|
||||
|
||||
// Stores information about errors
|
||||
namespace Error {
|
||||
#define MAX_NUMBER_OF_PRINTED_ERRORS 10
|
||||
enum Type{
|
||||
ERR_GLOBAL_SIZE=0,
|
||||
ERR_GLOBAL_WORK_OFFSET,
|
||||
ERR_LOCAL_SIZE,
|
||||
ERR_GLOBAL_ID,
|
||||
ERR_LOCAL_ID,
|
||||
ERR_ENQUEUED_LOCAL_SIZE,
|
||||
ERR_NUM_GROUPS,
|
||||
ERR_GROUP_ID,
|
||||
ERR_WORK_DIM,
|
||||
ERR_GLOBAL_BARRIER,
|
||||
ERR_LOCAL_BARRIER,
|
||||
ERR_GLOBAL_ATOMIC,
|
||||
ERR_LOCAL_ATOMIC,
|
||||
|
||||
ERR_STRICT_MODE,
|
||||
ERR_BUILD_STATUS,
|
||||
|
||||
ERR_UNKNOWN,
|
||||
ERR_DIFFERENT,
|
||||
_LAST_ELEM
|
||||
};
|
||||
|
||||
typedef std::map<Type, std::string> ErrorMap;
|
||||
typedef std::map<Type, unsigned int> ErrorStats;
|
||||
|
||||
class ErrorClass {
|
||||
public:
|
||||
ErrorClass();
|
||||
void show(Type whatErr, std::string where="", std::string additionalInfo="");
|
||||
void show(Type whatErr, std::string where, cl_ulong valueIs, cl_ulong valueExpected);
|
||||
void show(std::string description);
|
||||
bool checkError();
|
||||
void showStats();
|
||||
void synchronizeStatsMap();
|
||||
cl_uint * errorArrayCounter() {return _errorArrayCounter;};
|
||||
size_t errorArrayCounterSize() {return sizeof(_errorArrayCounter);};
|
||||
private:
|
||||
cl_uint _errorArrayCounter[Error::_LAST_ELEM]; // this buffer is passed to kernel
|
||||
int _overallNumberOfErrors;
|
||||
ErrorStats _stats;
|
||||
void printError(std::string errString);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
#endif // _TOOLS_H
|
||||
Reference in New Issue
Block a user