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

NFC: clang-format test_basic_parameter_types.cpp (#1151)

Browse Source 
* Use raw string literals in basic parameter test; NFC

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
Change-Id: I294d2aa95c6bab37e5efb7c8b1e43a06d31a0081

* clang-format test_basic_parameter_types.cpp; NFC

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
Change-Id: I0792037f5fa6f79d493c099bed15238f0f1486ac
This commit is contained in:
Sven van Haastregt
2021-02-11 11:37:14 +00:00
committed by GitHub
parent 8ad1088af9
commit 87a1525d53
1 changed files with 349 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
test_conformance/basic/test_basic_parameter_types.cpp
View File

@@ -23,40 +23,41 @@
#include "procs.h" #include "procs.h"
const char *kernel_code = const char *kernel_code = R"(
"__kernel void test_kernel(\n" __kernel void test_kernel(
"char%s c, uchar%s uc, short%s s, ushort%s us, int%s i, uint%s ui, float%s f,\n" char%s c, uchar%s uc, short%s s, ushort%s us, int%s i, uint%s ui, float%s f,
"__global float%s *result)\n" __global float%s *result)
"{\n" {
" result[0] = %s(c);\n" result[0] = %s(c);
" result[1] = %s(uc);\n" result[1] = %s(uc);
" result[2] = %s(s);\n" result[2] = %s(s);
" result[3] = %s(us);\n" result[3] = %s(us);
" result[4] = %s(i);\n" result[4] = %s(i);
" result[5] = %s(ui);\n" result[5] = %s(ui);
" result[6] = f;\n" result[6] = f;
"}\n"; })";
const char *kernel_code_long = const char *kernel_code_long = R"(
"__kernel void test_kernel_long(\n" __kernel void test_kernel_long(
"long%s l, ulong%s ul,\n" long%s l, ulong%s ul,
"__global float%s *result)\n" __global float%s *result)
"{\n" {
" result[0] = %s(l);\n" result[0] = %s(l);
" result[1] = %s(ul);\n" result[1] = %s(ul);
"}\n"; })";
int test_parameter_types_long(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) int test_parameter_types_long(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
{ {
clMemWrapper results; clMemWrapper results;
int error; int error;
size_t global[3] = {1, 1, 1}; size_t global[3] = { 1, 1, 1 };
float results_back[2*16]; float results_back[2 * 16];
int count, index; int count, index;
const char* types[] = { "long", "ulong" }; const char *types[] = { "long", "ulong" };
char kernel_string[8192]; char kernel_string[8192];
int sizes[] = {1, 2, 4, 8, 16}; int sizes[] = { 1, 2, 4, 8, 16 };
const char* size_strings[] = {"", "2", "4", "8", "16"}; const char *size_strings[] = { "", "2", "4", "8", "16" };
float expected; float expected;
int total_errors = 0; int total_errors = 0;
int size_to_test; int size_to_test;
@@ -64,9 +65,11 @@ int test_parameter_types_long(cl_device_id device, cl_context context, cl_comman
char convert_string[1024]; char convert_string[1024];
size_t max_parameter_size; size_t max_parameter_size;
// We don't really care about the contents since we're just testing that the types work. // We don't really care about the contents since we're just testing that the
cl_long l[16]={-21,-1,2,-3,4,-5,6,-7,8,-9,10,-11,12,-13,14,-15}; // types work.
cl_ulong ul[16]={22,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; cl_long l[16] = { -21, -1, 2, -3, 4, -5, 6, -7,
8, -9, 10, -11, 12, -13, 14, -15 };
cl_ulong ul[16] = { 22, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
// Calculate how large our paramter size is to the kernel // Calculate how large our paramter size is to the kernel
size_t parameter_size = sizeof(cl_long) + sizeof(cl_ulong); size_t parameter_size = sizeof(cl_long) + sizeof(cl_ulong);
@@ -76,79 +79,115 @@ int test_parameter_types_long(cl_device_id device, cl_context context, cl_comman
convert_string[0] = '\0'; convert_string[0] = '\0';
// Get the maximum parameter size allowed // Get the maximum parameter size allowed
error = clGetDeviceInfo( device, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof( max_parameter_size ), &max_parameter_size, NULL ); error =
test_error( error, "Unable to get max parameter size from device" ); clGetDeviceInfo(device, CL_DEVICE_MAX_PARAMETER_SIZE,
sizeof(max_parameter_size), &max_parameter_size, NULL);
test_error(error, "Unable to get max parameter size from device");
// Create the results buffer // Create the results buffer
results = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float)*2*16, NULL, &error); results = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_float) * 2 * 16, NULL, &error);
test_error(error, "clCreateBuffer failed"); test_error(error, "clCreateBuffer failed");
// Go over all the vector sizes // Go over all the vector sizes
for (size_to_test = 0; size_to_test < 5; size_to_test++) { for (size_to_test = 0; size_to_test < 5; size_to_test++)
{
clProgramWrapper program; clProgramWrapper program;
clKernelWrapper kernel; clKernelWrapper kernel;
size_t total_parameter_size = parameter_size*sizes[size_to_test] + sizeof(cl_mem); size_t total_parameter_size =
if (total_parameter_size > max_parameter_size) { parameter_size * sizes[size_to_test] + sizeof(cl_mem);
log_info("Can not test with vector size %d because it would exceed the maximum allowed parameter size to the kernel. (%d > %d)\n", if (total_parameter_size > max_parameter_size)
(int)sizes[size_to_test], (int)total_parameter_size, (int)max_parameter_size); {
log_info(
"Can not test with vector size %d because it would exceed the "
"maximum allowed parameter size to the kernel. (%d > %d)\n",
(int)sizes[size_to_test], (int)total_parameter_size,
(int)max_parameter_size);
continue; continue;
} }
log_info("Testing vector size %d\n", sizes[size_to_test]); log_info("Testing vector size %d\n", sizes[size_to_test]);
// If size is > 1, then we need a explicit convert call. // If size is > 1, then we need a explicit convert call.
if (sizes[size_to_test] > 1) { if (sizes[size_to_test] > 1)
sprintf(convert_string, "convert_float%s", size_strings[size_to_test]); {
} else { sprintf(convert_string, "convert_float%s",
size_strings[size_to_test]);
}
else
{
sprintf(convert_string, " "); sprintf(convert_string, " ");
} }
// Build the kernel // Build the kernel
sprintf(kernel_string, kernel_code_long, sprintf(kernel_string, kernel_code_long, size_strings[size_to_test],
size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test],
convert_string, convert_string convert_string, convert_string);
);
ptr = kernel_string; ptr = kernel_string;
error = create_single_kernel_helper(context, &program, &kernel, 1, (const char **)&ptr, "test_kernel_long"); error = create_single_kernel_helper(context, &program, &kernel, 1,
(const char **)&ptr,
"test_kernel_long");
test_error(error, "create single kernel failed"); test_error(error, "create single kernel failed");
// Set the arguments // Set the arguments
for (count = 0; count < 2; count++) { for (count = 0; count < 2; count++)
switch (count) { {
case 0: error = clSetKernelArg(kernel, count, sizeof(cl_long)*sizes[size_to_test], &l); break; switch (count)
case 1: error = clSetKernelArg(kernel, count, sizeof(cl_ulong)*sizes[size_to_test], &ul); break; {
case 0:
error = clSetKernelArg(
kernel, count, sizeof(cl_long) * sizes[size_to_test],
&l);
break;
case 1:
error = clSetKernelArg(
kernel, count, sizeof(cl_ulong) * sizes[size_to_test],
&ul);
break;
default: log_error("Test error"); break; default: log_error("Test error"); break;
} }
if (error) if (error)
log_error("Setting kernel arg %d %s%s: ", count, types[count], size_strings[size_to_test]); log_error("Setting kernel arg %d %s%s: ", count, types[count],
size_strings[size_to_test]);
test_error(error, "clSetKernelArgs failed"); test_error(error, "clSetKernelArgs failed");
} }
error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &results); error = clSetKernelArg(kernel, 2, sizeof(cl_mem), &results);
test_error(error, "clSetKernelArgs failed"); test_error(error, "clSetKernelArgs failed");
// Execute // Execute
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global, NULL, 0, NULL, NULL); error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global, NULL, 0,
NULL, NULL);
test_error(error, "clEnqueueNDRangeKernel failed"); test_error(error, "clEnqueueNDRangeKernel failed");
// Read back the results // Read back the results
error = clEnqueueReadBuffer(queue, results, CL_TRUE, 0, sizeof(cl_float)*2*16, results_back, 0, NULL, NULL); error = clEnqueueReadBuffer(queue, results, CL_TRUE, 0,
sizeof(cl_float) * 2 * 16, results_back, 0,
NULL, NULL);
test_error(error, "clEnqueueReadBuffer failed"); test_error(error, "clEnqueueReadBuffer failed");
// Verify the results // Verify the results
for (count = 0; count < 2; count++) { for (count = 0; count < 2; count++)
for (index=0; index < sizes[size_to_test]; index++) { {
switch (count) { for (index = 0; index < sizes[size_to_test]; index++)
{
switch (count)
{
case 0: expected = (float)l[index]; break; case 0: expected = (float)l[index]; break;
case 1: expected = (float)ul[index]; break; case 1: expected = (float)ul[index]; break;
default: log_error("Test error"); break; default: log_error("Test error"); break;
} }
if (results_back[count*sizes[size_to_test]+index] != expected) { if (results_back[count * sizes[size_to_test] + index]
!= expected)
{
total_errors++; total_errors++;
log_error("Conversion from %s%s failed: index %d got %g, expected %g.\n", types[count], size_strings[size_to_test], log_error("Conversion from %s%s failed: index %d got %g, "
index, results_back[count*sizes[size_to_test]+index], expected); "expected %g.\n",
types[count], size_strings[size_to_test], index,
results_back[count * sizes[size_to_test] + index],
expected);
} }
} }
} }
@@ -157,17 +196,19 @@ int test_parameter_types_long(cl_device_id device, cl_context context, cl_comman
return total_errors; return total_errors;
} }
int test_parameter_types(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements) int test_parameter_types(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
{ {
clMemWrapper results; clMemWrapper results;
int error; int error;
size_t global[3] = {1, 1, 1}; size_t global[3] = { 1, 1, 1 };
float results_back[7*16]; float results_back[7 * 16];
int count, index; int count, index;
const char* types[] = {"char", "uchar", "short", "ushort", "int", "uint", "float"}; const char *types[] = { "char", "uchar", "short", "ushort",
"int", "uint", "float" };
char kernel_string[8192]; char kernel_string[8192];
int sizes[] = {1, 2, 4, 8, 16}; int sizes[] = { 1, 2, 4, 8, 16 };
const char* size_strings[] = {"", "2", "4", "8", "16"}; const char *size_strings[] = { "", "2", "4", "8", "16" };
float expected; float expected;
int total_errors = 0; int total_errors = 0;
int size_to_test; int size_to_test;
@@ -175,98 +216,154 @@ int test_parameter_types(cl_device_id device, cl_context context, cl_command_que
char convert_string[1024]; char convert_string[1024];
size_t max_parameter_size; size_t max_parameter_size;
// We don't really care about the contents since we're just testing that the types work. // We don't really care about the contents since we're just testing that the
cl_char c[16]={0,-1,2,-3,4,-5,6,-7,8,-9,10,-11,12,-13,14,-15}; // types work.
cl_uchar uc[16]={16,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; cl_char c[16] = { 0, -1, 2, -3, 4, -5, 6, -7,
cl_short s[16]={-17,-1,2,-3,4,-5,6,-7,8,-9,10,-11,12,-13,14,-15}; 8, -9, 10, -11, 12, -13, 14, -15 };
cl_ushort us[16]={18,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; cl_uchar uc[16] = { 16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
cl_int i[16]={-19,-1,2,-3,4,-5,6,-7,8,-9,10,-11,12,-13,14,-15}; cl_short s[16] = { -17, -1, 2, -3, 4, -5, 6, -7,
cl_uint ui[16]={20,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; 8, -9, 10, -11, 12, -13, 14, -15 };
cl_float f[16]={-23,-1,2,-3,4,-5,6,-7,8,-9,10,-11,12,-13,14,-15}; cl_ushort us[16] = {
18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
};
cl_int i[16] = { -19, -1, 2, -3, 4, -5, 6, -7,
8, -9, 10, -11, 12, -13, 14, -15 };
cl_uint ui[16] = { 20, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
cl_float f[16] = { -23, -1, 2, -3, 4, -5, 6, -7,
8, -9, 10, -11, 12, -13, 14, -15 };
// Calculate how large our paramter size is to the kernel // Calculate how large our paramter size is to the kernel
size_t parameter_size = sizeof(cl_char) + sizeof(cl_uchar) + size_t parameter_size = sizeof(cl_char) + sizeof(cl_uchar)
sizeof(cl_short) +sizeof(cl_ushort) + + sizeof(cl_short) + sizeof(cl_ushort) + sizeof(cl_int)
sizeof(cl_int) +sizeof(cl_uint) + + sizeof(cl_uint) + sizeof(cl_float);
sizeof(cl_float);
// Init our strings. // Init our strings.
kernel_string[0] = '\0'; kernel_string[0] = '\0';
convert_string[0] = '\0'; convert_string[0] = '\0';
// Get the maximum parameter size allowed // Get the maximum parameter size allowed
error = clGetDeviceInfo( device, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof( max_parameter_size ), &max_parameter_size, NULL ); error =
test_error( error, "Unable to get max parameter size from device" ); clGetDeviceInfo(device, CL_DEVICE_MAX_PARAMETER_SIZE,
sizeof(max_parameter_size), &max_parameter_size, NULL);
test_error(error, "Unable to get max parameter size from device");
// Create the results buffer // Create the results buffer
results = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float)*7*16, NULL, &error); results = clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_float) * 7 * 16, NULL, &error);
test_error(error, "clCreateBuffer failed"); test_error(error, "clCreateBuffer failed");
// Go over all the vector sizes // Go over all the vector sizes
for (size_to_test = 0; size_to_test < 5; size_to_test++) { for (size_to_test = 0; size_to_test < 5; size_to_test++)
{
clProgramWrapper program; clProgramWrapper program;
clKernelWrapper kernel; clKernelWrapper kernel;
size_t total_parameter_size = parameter_size*sizes[size_to_test] + sizeof(cl_mem); size_t total_parameter_size =
if (total_parameter_size > max_parameter_size) { parameter_size * sizes[size_to_test] + sizeof(cl_mem);
log_info("Can not test with vector size %d because it would exceed the maximum allowed parameter size to the kernel. (%d > %d)\n", if (total_parameter_size > max_parameter_size)
(int)sizes[size_to_test], (int)total_parameter_size, (int)max_parameter_size); {
log_info(
"Can not test with vector size %d because it would exceed the "
"maximum allowed parameter size to the kernel. (%d > %d)\n",
(int)sizes[size_to_test], (int)total_parameter_size,
(int)max_parameter_size);
continue; continue;
} }
log_info("Testing vector size %d\n", sizes[size_to_test]); log_info("Testing vector size %d\n", sizes[size_to_test]);
// If size is > 1, then we need a explicit convert call. // If size is > 1, then we need a explicit convert call.
if (sizes[size_to_test] > 1) { if (sizes[size_to_test] > 1)
sprintf(convert_string, "convert_float%s", size_strings[size_to_test]); {
} else { sprintf(convert_string, "convert_float%s",
size_strings[size_to_test]);
}
else
{
sprintf(convert_string, " "); sprintf(convert_string, " ");
} }
// Build the kernel // Build the kernel
sprintf(kernel_string, kernel_code, sprintf(kernel_string, kernel_code, size_strings[size_to_test],
size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test],
size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test],
size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test], size_strings[size_to_test],
convert_string, convert_string, convert_string, size_strings[size_to_test], size_strings[size_to_test],
convert_string, convert_string, convert_string size_strings[size_to_test], size_strings[size_to_test],
); size_strings[size_to_test], convert_string, convert_string,
convert_string, convert_string, convert_string, convert_string);
ptr = kernel_string; ptr = kernel_string;
error = create_single_kernel_helper(context, &program, &kernel, 1, (const char **)&ptr, "test_kernel"); error = create_single_kernel_helper(context, &program, &kernel, 1,
(const char **)&ptr, "test_kernel");
test_error(error, "create single kernel failed"); test_error(error, "create single kernel failed");
// Set the arguments // Set the arguments
for (count = 0; count < 7; count++) { for (count = 0; count < 7; count++)
switch (count) { {
case 0: error = clSetKernelArg(kernel, count, sizeof(cl_char)*sizes[size_to_test], &c); break; switch (count)
case 1: error = clSetKernelArg(kernel, count, sizeof(cl_uchar)*sizes[size_to_test], &uc); break; {
case 2: error = clSetKernelArg(kernel, count, sizeof(cl_short)*sizes[size_to_test], &s); break; case 0:
case 3: error = clSetKernelArg(kernel, count, sizeof(cl_ushort)*sizes[size_to_test], &us); break; error = clSetKernelArg(
case 4: error = clSetKernelArg(kernel, count, sizeof(cl_int)*sizes[size_to_test], &i); break; kernel, count, sizeof(cl_char) * sizes[size_to_test],
case 5: error = clSetKernelArg(kernel, count, sizeof(cl_uint)*sizes[size_to_test], &ui); break; &c);
case 6: error = clSetKernelArg(kernel, count, sizeof(cl_float)*sizes[size_to_test], &f); break; break;
case 1:
error = clSetKernelArg(
kernel, count, sizeof(cl_uchar) * sizes[size_to_test],
&uc);
break;
case 2:
error = clSetKernelArg(
kernel, count, sizeof(cl_short) * sizes[size_to_test],
&s);
break;
case 3:
error = clSetKernelArg(
kernel, count, sizeof(cl_ushort) * sizes[size_to_test],
&us);
break;
case 4:
error = clSetKernelArg(kernel, count,
sizeof(cl_int) * sizes[size_to_test],
&i);
break;
case 5:
error = clSetKernelArg(
kernel, count, sizeof(cl_uint) * sizes[size_to_test],
&ui);
break;
case 6:
error = clSetKernelArg(
kernel, count, sizeof(cl_float) * sizes[size_to_test],
&f);
break;
default: log_error("Test error"); break; default: log_error("Test error"); break;
} }
if (error) if (error)
log_error("Setting kernel arg %d %s%s: ", count, types[count], size_strings[size_to_test]); log_error("Setting kernel arg %d %s%s: ", count, types[count],
size_strings[size_to_test]);
test_error(error, "clSetKernelArgs failed"); test_error(error, "clSetKernelArgs failed");
} }
error = clSetKernelArg(kernel, 7, sizeof(cl_mem), &results); error = clSetKernelArg(kernel, 7, sizeof(cl_mem), &results);
test_error(error, "clSetKernelArgs failed"); test_error(error, "clSetKernelArgs failed");
// Execute // Execute
error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global, NULL, 0, NULL, NULL); error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global, NULL, 0,
NULL, NULL);
test_error(error, "clEnqueueNDRangeKernel failed"); test_error(error, "clEnqueueNDRangeKernel failed");
// Read back the results // Read back the results
error = clEnqueueReadBuffer(queue, results, CL_TRUE, 0, sizeof(cl_float)*7*16, results_back, 0, NULL, NULL); error = clEnqueueReadBuffer(queue, results, CL_TRUE, 0,
sizeof(cl_float) * 7 * 16, results_back, 0,
NULL, NULL);
test_error(error, "clEnqueueReadBuffer failed"); test_error(error, "clEnqueueReadBuffer failed");
// Verify the results // Verify the results
for (count = 0; count < 7; count++) { for (count = 0; count < 7; count++)
for (index=0; index < sizes[size_to_test]; index++) { {
switch (count) { for (index = 0; index < sizes[size_to_test]; index++)
{
switch (count)
{
case 0: expected = (float)c[index]; break; case 0: expected = (float)c[index]; break;
case 1: expected = (float)uc[index]; break; case 1: expected = (float)uc[index]; break;
case 2: expected = (float)s[index]; break; case 2: expected = (float)s[index]; break;
@@ -277,25 +374,30 @@ int test_parameter_types(cl_device_id device, cl_context context, cl_command_que
default: log_error("Test error"); break; default: log_error("Test error"); break;
} }
if (results_back[count*sizes[size_to_test]+index] != expected) { if (results_back[count * sizes[size_to_test] + index]
!= expected)
{
total_errors++; total_errors++;
log_error("Conversion from %s%s failed: index %d got %g, expected %g.\n", types[count], size_strings[size_to_test], log_error("Conversion from %s%s failed: index %d got %g, "
index, results_back[count*sizes[size_to_test]+index], expected); "expected %g.\n",
types[count], size_strings[size_to_test], index,
results_back[count * sizes[size_to_test] + index],
expected);
} }
} }
} }
} }
if (gHasLong) { if (gHasLong)
{
log_info("Testing long types...\n"); log_info("Testing long types...\n");
total_errors += test_parameter_types_long( device, context, queue, num_elements ); total_errors +=
test_parameter_types_long(device, context, queue, num_elements);
} }
else { else
{
log_info("Longs unsupported, skipping."); log_info("Longs unsupported, skipping.");
} }
return total_errors; return total_errors;
} }