ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Enable -Wnarrowing in non_uniform_work_group test suite. (#2464)

Browse Source 
Modify the prime numbers generator function to return `size_t` instead
of `int` and use `0` as a sentinal value instead of hardcoded negative
ones. `0` is not a prime number, so it is suitable to use to indicate an
error.

Fixes #1159

---------

Signed-off-by: Ahmed Hesham <ahmed.hesham@arm.com>
This commit is contained in:
Ahmed Hesham
2025-07-30 18:49:38 +01:00
committed by GitHub
parent 82508f709a
commit 16dfa2217c
7 changed files with 843 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test_conformance/non_uniform_work_group/CMakeLists.txt
View File

@@ -1,9 +1,5 @@
set(MODULE_NAME NON_UNIFORM_WORK_GROUP)
if(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?Clang")
add_cxx_flag_if_supported(-Wno-narrowing)
endif()
set(${MODULE_NAME}_SOURCES
main.cpp
test_advanced_2d.cpp
@@ -15,5 +11,3 @@ set(${MODULE_NAME}_SOURCES
)
include(../CMakeCommon.txt)
# end of file #

213
test_conformance/non_uniform_work_group/test_advanced_2d.cpp
View File

@@ -39,8 +39,10 @@ REGISTER_TEST(non_uniform_2d_basic)
// non_uniform_2d_prime_number_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -52,25 +54,31 @@ REGISTER_TEST(non_uniform_2d_basic)
// non_uniform_2d_two_prime_numbers_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 1759;
size_t primeNumber2 = 1759;
size_t globalSize[] = { primeNumber2, primeNumber };
size_t localSize[] = { 16, maxWgSize / 16 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_2d_prime_number_basic_2
{
int primeNumber = 1327;
size_t primeNumber = 1327;
size_t globalSize[] = { primeNumber, primeNumber };
size_t localSize[] = { maxWgSize / 32, 32 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_2d_combination_of_max_wg_size_basic
@@ -83,56 +91,69 @@ REGISTER_TEST(non_uniform_2d_basic)
// non_uniform_2d_two_prime_numbers_and_ls_null_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 1669;
size_t primeNumber2 = 1669;
size_t globalSize[] = { primeNumber, primeNumber2 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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 primeNumber = 1249;
size_t globalSize[] = { primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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;
size_t primeNumber = 1951;
size_t primeNumber2 = 911;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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) {
size_t 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 primeNumber2 = 42967;
size_t primeNumber3 = 13;
size_t globalSize[] = { primeNumber2, primeNumber3 };
size_t localSize[] = { primeNumber, 1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
return exec.status();
@@ -160,8 +181,10 @@ REGISTER_TEST(non_uniform_2d_atomics)
// non_uniform_2d_prime_number_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -173,25 +196,31 @@ REGISTER_TEST(non_uniform_2d_atomics)
// non_uniform_2d_two_prime_numbers_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 1759;
size_t primeNumber2 = 1759;
size_t globalSize[] = { primeNumber2, primeNumber };
size_t localSize[] = { 16, maxWgSize / 16 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_2d_prime_number_atomics_2
{
int primeNumber = 1327;
size_t primeNumber = 1327;
size_t globalSize[] = { primeNumber, primeNumber };
size_t localSize[] = { maxWgSize / 32, 32 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_2d_combination_of_max_wg_size_atomics
@@ -204,56 +233,69 @@ REGISTER_TEST(non_uniform_2d_atomics)
// non_uniform_2d_two_prime_numbers_and_ls_null_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 1669;
size_t primeNumber2 = 1669;
size_t globalSize[] = { primeNumber, primeNumber2 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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 primeNumber = 1249;
size_t globalSize[] = { primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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;
size_t primeNumber = 1951;
size_t primeNumber2 = 911;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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) {
size_t 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 primeNumber2 = 42967;
size_t primeNumber3 = 13;
size_t globalSize[] = { primeNumber2, primeNumber3 };
size_t localSize[] = { primeNumber, 1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
return exec.status();
@@ -281,8 +323,10 @@ REGISTER_TEST(non_uniform_2d_barriers)
// non_uniform_2d_prime_number_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -294,25 +338,31 @@ REGISTER_TEST(non_uniform_2d_barriers)
// non_uniform_2d_two_prime_numbers_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 1759;
size_t primeNumber2 = 1759;
size_t globalSize[] = { primeNumber2, primeNumber };
size_t localSize[] = { 16, maxWgSize / 16 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_2d_prime_number_barriers_2
{
int primeNumber = 1327;
size_t primeNumber = 1327;
size_t globalSize[] = { primeNumber, primeNumber };
size_t localSize[] = { maxWgSize / 32, 32 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_2d_combination_of_max_wg_size_barriers
@@ -325,54 +375,67 @@ REGISTER_TEST(non_uniform_2d_barriers)
// non_uniform_2d_two_prime_numbers_and_ls_null_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 1669;
size_t primeNumber2 = 1669;
size_t globalSize[] = { primeNumber, primeNumber2 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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 primeNumber = 1249;
size_t globalSize[] = { primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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;
size_t primeNumber = 1951;
size_t primeNumber2 = 911;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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) {
size_t 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 primeNumber2 = 42967;
size_t primeNumber3 = 13;
size_t globalSize[] = { primeNumber2, primeNumber3 };
size_t localSize[] = { primeNumber, 1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
return exec.status();

279
test_conformance/non_uniform_work_group/test_advanced_3d.cpp
View File

@@ -39,8 +39,10 @@ REGISTER_TEST(non_uniform_3d_basic)
// non_uniform_3d_prime_number_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -52,95 +54,118 @@ REGISTER_TEST(non_uniform_3d_basic)
// non_uniform_3d_two_prime_numbers_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 13;
size_t 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);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_3d_prime_number_basic_2
{
int primeNumber = 113;
size_t 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);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 23;
size_t primeNumber2 = 23;
size_t globalSize[] = { primeNumber, primeNumber2, maxWgSize / 16 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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 primeNumber = 113;
size_t globalSize[] = { primeNumber, primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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) {
size_t 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 primeNumber2 = 10711;
size_t 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);
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;
size_t primeNumber = 541;
size_t primeNumber2 = 251;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4,primeNumber5,primeNumber6,maxWgSize );
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
size_t localSize[] = { fit3dResult.Val1, fit3dResult.Val2,
fit3dResult.Val3 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
return exec.status();
@@ -168,8 +193,10 @@ REGISTER_TEST(non_uniform_3d_atomics)
// non_uniform_3d_prime_number_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -181,95 +208,118 @@ REGISTER_TEST(non_uniform_3d_atomics)
// non_uniform_3d_two_prime_numbers_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 13;
size_t 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);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_3d_prime_number_atomics_2
{
int primeNumber = 113;
size_t 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);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 23;
size_t primeNumber2 = 23;
size_t globalSize[] = { primeNumber, primeNumber2, maxWgSize / 16 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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 primeNumber = 113;
size_t globalSize[] = { primeNumber, primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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) {
size_t 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 primeNumber2 = 10711;
size_t 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);
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;
size_t primeNumber = 541;
size_t primeNumber2 = 251;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize);
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
size_t localSize[] = { fit3dResult.Val1, fit3dResult.Val2,
fit3dResult.Val3 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
return exec.status();
@@ -297,8 +347,10 @@ REGISTER_TEST(non_uniform_3d_barriers)
// non_uniform_3d_prime_number_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -310,96 +362,119 @@ REGISTER_TEST(non_uniform_3d_barriers)
// non_uniform_3d_two_prime_numbers_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
int primeNumber2 = 13;
size_t 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);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_3d_prime_number_barriers_2
{
int primeNumber = 113;
size_t 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);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
unsigned int primeNumber2 = 23;
size_t primeNumber2 = 23;
size_t globalSize[] = { primeNumber, primeNumber2, maxWgSize / 16 };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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 primeNumber = 113;
size_t globalSize[] = { primeNumber, primeNumber, primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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) {
size_t 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 primeNumber2 = 10711;
size_t 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);
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;
size_t primeNumber = 541;
size_t primeNumber2 = 251;
size_t primeNumber3 = 13;
size_t primeNumber4 = 17;
PrimeNumbers::Result2d fit2dResult;
fit2dResult = PrimeNumbers::fitMaxPrime2d(primeNumber3, primeNumber4, maxWgSize);
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4,primeNumber5,primeNumber6,maxWgSize );
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
size_t localSize[] = { fit3dResult.Val1, fit3dResult.Val2,
fit3dResult.Val3 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
return exec.status();

207
test_conformance/non_uniform_work_group/test_advanced_other.cpp
View File

@@ -31,8 +31,8 @@ REGISTER_TEST(non_uniform_other_basic)
// non_uniform_1d_two_prime_numbers_offset_basic
{
unsigned int primeNumber = 42967;
unsigned int primeNumber2 = 113;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize);
@@ -41,63 +41,78 @@ REGISTER_TEST(non_uniform_other_basic)
size_t localSize[] = { fit1dResult.Val1 };
size_t offset[] = { 23 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BASIC);
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) {
size_t 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 primeNumber2 = 42967;
size_t 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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
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};
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);
exec.runTestNonUniformWorkGroup(
sizeof(globalSize) / sizeof(globalSize[0]), globalSize, localSize,
NULL, reqdWorkGroupSize, Range::BASIC);
}
return exec.status();
@@ -117,8 +132,8 @@ REGISTER_TEST(non_uniform_other_atomics)
// non_uniform_1d_two_prime_numbers_offset_atomics
{
unsigned int primeNumber = 42967;
unsigned int primeNumber2 = 113;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize);
@@ -127,61 +142,76 @@ REGISTER_TEST(non_uniform_other_atomics)
size_t localSize[] = { fit1dResult.Val1 };
size_t offset[] = { 23 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::ATOMICS);
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) {
size_t 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 primeNumber2 = 42967;
size_t 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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
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};
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);
exec.runTestNonUniformWorkGroup(
sizeof(globalSize) / sizeof(globalSize[0]), globalSize, localSize,
NULL, reqdWorkGroupSize, Range::ATOMICS);
}
return exec.status();
@@ -201,8 +231,8 @@ REGISTER_TEST(non_uniform_other_barriers)
// non_uniform_1d_two_prime_numbers_offset_barriers
{
unsigned int primeNumber = 42967;
unsigned int primeNumber2 = 113;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize);
@@ -212,63 +242,78 @@ REGISTER_TEST(non_uniform_other_barriers)
size_t localSize[] = { fit1dResult.Val1 };
size_t offset[] = { 23 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, offset, NULL, Range::BARRIERS);
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) {
size_t 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 primeNumber2 = 42967;
size_t 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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5,
primeNumber6, maxWgSize);
size_t globalSize[] = { primeNumber, primeNumber2, primeNumber3 };
size_t localSize[] = {fit3dResult.Val1, fit3dResult.Val2, fit3dResult.Val3};
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);
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;
size_t primeNumber = 373;
size_t primeNumber2 = 13;
size_t primeNumber3 = 279;
size_t primeNumber4 = 3;
size_t primeNumber5 = 5;
size_t primeNumber6 = 7;
PrimeNumbers::Result3d fit3dResult;
fit3dResult = PrimeNumbers::fitMaxPrime3d(primeNumber4, primeNumber5, primeNumber6, maxWgSize );
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};
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);
exec.runTestNonUniformWorkGroup(
sizeof(globalSize) / sizeof(globalSize[0]), globalSize, localSize,
NULL, reqdWorkGroupSize, Range::BARRIERS);
}
return exec.status();

168
test_conformance/non_uniform_work_group/test_basic.cpp
View File

@@ -39,8 +39,10 @@ REGISTER_TEST(non_uniform_1d_basic)
// non_uniform_1d_prime_number_basic
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -52,20 +54,24 @@ REGISTER_TEST(non_uniform_1d_basic)
// non_uniform_1d_max_wg_size_plus_prime_number_basic
{
int primeNumber = 11;
size_t primeNumber = 11;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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 primeNumber = 53;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_1d_2max_wg_size_minus_1_basic
@@ -78,35 +84,43 @@ REGISTER_TEST(non_uniform_1d_basic)
// non_uniform_1d_prime_number_basic_2
{
unsigned int primeNumber = 20101;
size_t primeNumber = 20101;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_1d_prime_number_basic_3
{
unsigned int primeNumber = 42967;
size_t primeNumber = 42967;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
// non_uniform_1d_prime_number_basic_4
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -118,17 +132,19 @@ REGISTER_TEST(non_uniform_1d_basic)
// non_uniform_1d_prime_number_and_ls_null_basic_3
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
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;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize);
@@ -136,7 +152,9 @@ REGISTER_TEST(non_uniform_1d_basic)
size_t globalSize[] = { primeNumber };
size_t localSize[] = { fit1dResult.Val1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BASIC);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BASIC);
}
return exec.status();
@@ -164,8 +182,10 @@ REGISTER_TEST(non_uniform_1d_atomics)
// non_uniform_1d_prime_number_atomics
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -177,20 +197,24 @@ REGISTER_TEST(non_uniform_1d_atomics)
// non_uniform_1d_max_wg_size_plus_prime_number_atomics
{
int primeNumber = 11;
size_t primeNumber = 11;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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 primeNumber = 53;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_1d_2max_wg_size_minus_1_atomics
@@ -203,35 +227,43 @@ REGISTER_TEST(non_uniform_1d_atomics)
// non_uniform_1d_prime_number_atomics_2
{
unsigned int primeNumber = 20101;
size_t primeNumber = 20101;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_1d_prime_number_atomics_3
{
unsigned int primeNumber = 42967;
size_t primeNumber = 42967;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
// non_uniform_1d_prime_number_atomics_4
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -243,17 +275,19 @@ REGISTER_TEST(non_uniform_1d_atomics)
// non_uniform_1d_prime_number_and_ls_null_atomics_3
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
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;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
fit1dResult = PrimeNumbers::fitMaxPrime1d(primeNumber2, maxWgSize);
@@ -261,7 +295,9 @@ REGISTER_TEST(non_uniform_1d_atomics)
size_t globalSize[] = { primeNumber };
size_t localSize[] = { fit1dResult.Val1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::ATOMICS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::ATOMICS);
}
return exec.status();
@@ -289,8 +325,10 @@ REGISTER_TEST(non_uniform_1d_barriers)
// non_uniform_1d_prime_number_barriers
{
int primeNumber = PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2*maxWgSize);
if (primeNumber < 1) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -302,20 +340,24 @@ REGISTER_TEST(non_uniform_1d_barriers)
// non_uniform_1d_max_wg_size_plus_prime_number_barriers
{
int primeNumber = 11;
size_t primeNumber = 11;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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 primeNumber = 53;
size_t globalSize[] = { maxWgSize + primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_1d_2max_wg_size_minus_1_barriers
@@ -328,35 +370,43 @@ REGISTER_TEST(non_uniform_1d_barriers)
// non_uniform_1d_prime_number_barriers_2
{
unsigned int primeNumber = 20101;
size_t primeNumber = 20101;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_1d_prime_number_barriers_3
{
unsigned int primeNumber = 42967;
size_t primeNumber = 42967;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
// non_uniform_1d_prime_number_barriers_4
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t localSize[] = { maxWgSize };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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) {
size_t primeNumber =
PrimeNumbers::getPrimeNumberInRange(maxWgSize, 2 * maxWgSize);
if (primeNumber < 1)
{
log_error("Cannot find proper prime number.");
return -1;
}
@@ -368,17 +418,19 @@ REGISTER_TEST(non_uniform_1d_barriers)
// non_uniform_1d_prime_number_and_ls_null_barriers_3
{
unsigned int primeNumber = 65521;
size_t primeNumber = 65521;
size_t globalSize[] = { primeNumber };
size_t *localSize = NULL;
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
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;
size_t primeNumber = 42967;
size_t primeNumber2 = 113;
PrimeNumbers::Result1d fit1dResult;
@@ -387,7 +439,9 @@ REGISTER_TEST(non_uniform_1d_barriers)
size_t globalSize[] = { primeNumber };
size_t localSize[] = { fit1dResult.Val1 };
exec.runTestNonUniformWorkGroup(sizeof(globalSize)/sizeof(globalSize[0]), globalSize, localSize, Range::BARRIERS);
exec.runTestNonUniformWorkGroup(sizeof(globalSize)
/ sizeof(globalSize[0]),
globalSize, localSize, Range::BARRIERS);
}
return exec.status();

23
test_conformance/non_uniform_work_group/tools.cpp
View File

@@ -46,28 +46,31 @@ void PrimeNumbers::generatePrimeNumbers (unsigned int maxValue) {
}
// Returns prime number for specified range
int PrimeNumbers::getPrimeNumberInRange (size_t lowerValue, size_t higherValue) {
if(lowerValue >= higherValue)
return -1;
size_t PrimeNumbers::getPrimeNumberInRange(size_t lowerValue,
size_t higherValue)
{
if (lowerValue >= higherValue) return 0;
if(primeNumbers.back() < lowerValue)
return -2;
if (primeNumbers.back() < lowerValue) return 0;
PrimeNumbersCollection::iterator it = primeNumbers.begin();
for (; it != primeNumbers.end(); ++it) {
if (lowerValue<*it) {
for (; it != primeNumbers.end(); ++it)
{
if (lowerValue < *it)
{
if (higherValue > *it)
return *it;
else
return -3;
return 0;
}
}
return -1;
return 0;
}
int PrimeNumbers::getNextLowerPrimeNumber(size_t upperValue) {
size_t PrimeNumbers::getNextLowerPrimeNumber(size_t upperValue)
{
size_t retVal = 1;
PrimeNumbersCollection::iterator it = primeNumbers.begin();

7
test_conformance/non_uniform_work_group/tools.h
View File

@@ -23,8 +23,7 @@
#include <map>
#include <string>
typedef std::vector<unsigned int> PrimeNumbersCollection;
typedef std::vector<size_t> PrimeNumbersCollection;
// Class responsible for distributing prime numbers
@@ -47,8 +46,8 @@ public:
};
static void generatePrimeNumbers (unsigned int maxValue);
static int getPrimeNumberInRange (size_t lowerValue, size_t higherValue);
static int getNextLowerPrimeNumber (size_t upperValue);
static size_t getPrimeNumberInRange(size_t lowerValue, size_t higherValue);
static size_t 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);