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

api: fix -Wformat warnings (#2025)

Browse Source 
The main sources of warnings were:

 * Printing of a `size_t` which requires the `%zu` specifier.

 * Printing of `cl_long`/`cl_ulong` which is now done using the `PRI*64`
macros to ensure portability across 32 and 64-bit builds.

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
This commit is contained in:
Sven van Haastregt
2024-09-02 12:02:28 +02:00
committed by GitHub
parent a7162188d6
commit 90f523ea57
8 changed files with 126 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test_conformance/api/test_api_consistency.cpp
View File

@@ -13,6 +13,8 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
// //
#include <cinttypes>
#include "testBase.h" #include "testBase.h"
#include "harness/testHarness.h" #include "harness/testHarness.h"
#include "harness/deviceInfo.h" #include "harness/deviceInfo.h"
@@ -158,8 +160,9 @@ static int check_atomic_capabilities(cl_device_atomic_capabilities atomicCaps,
{ {
if ((atomicCaps & requiredCaps) != requiredCaps) if ((atomicCaps & requiredCaps) != requiredCaps)
{ {
log_error("Atomic capabilities %llx is missing support for at least " log_error("Atomic capabilities %" PRIx64
"one required capability %llx!\n", " is missing support for at least "
"one required capability %" PRIx64 "!\n",
atomicCaps, requiredCaps); atomicCaps, requiredCaps);
return TEST_FAIL; return TEST_FAIL;
} }

107
test_conformance/api/test_api_min_max.cpp
View File

@@ -18,6 +18,7 @@
#include "harness/testHarness.h" #include "harness/testHarness.h"
#include <ctype.h> #include <ctype.h>
#include <string.h> #include <string.h>
#include <cinttypes>
const char *sample_single_param_kernel[] = { const char *sample_single_param_kernel[] = {
"__kernel void sample_test(__global int *src)\n" "__kernel void sample_test(__global int *src)\n"
@@ -227,13 +228,13 @@ int test_min_max_work_items_sizes(cl_device_id deviceID, cl_context context,
{ {
if (deviceMaxWorkItemSize[i] < 1) if (deviceMaxWorkItemSize[i] < 1)
{ {
log_error("MAX_WORK_ITEM_SIZE in dimension %d is invalid: %lu\n", i, log_error("MAX_WORK_ITEM_SIZE in dimension %d is invalid: %zu\n", i,
deviceMaxWorkItemSize[i]); deviceMaxWorkItemSize[i]);
errors++; errors++;
} }
else else
{ {
log_info("Dimension %d has max work item size %lu\n", i, log_info("Dimension %d has max work item size %zu\n", i,
deviceMaxWorkItemSize[i]); deviceMaxWorkItemSize[i]);
} }
} }
@@ -257,7 +258,7 @@ int test_min_max_work_group_size(cl_device_id deviceID, cl_context context,
NULL); NULL);
test_error(error, "Unable to get max work group size from device"); test_error(error, "Unable to get max work group size from device");
log_info("Reported %ld max device work group size.\n", deviceMaxThreadSize); log_info("Reported %zu max device work group size.\n", deviceMaxThreadSize);
if (deviceMaxThreadSize == 0) if (deviceMaxThreadSize == 0)
{ {
@@ -601,8 +602,9 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
return -1; return -1;
} }
log_info("Reported max allocation size of %lld bytes (%gMB) and global mem " log_info("Reported max allocation size of %" PRIu64
"size of %lld bytes (%gMB).\n", " bytes (%gMB) and global mem "
"size of %" PRIu64 " bytes (%gMB).\n",
maxAllocSize, maxAllocSize / (1024.0 * 1024.0), memSize, maxAllocSize, maxAllocSize / (1024.0 * 1024.0), memSize,
memSize / (1024.0 * 1024.0)); memSize / (1024.0 * 1024.0));
@@ -611,14 +613,16 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
while (currentSize >= maxAllocSize / MAX_REDUCTION_FACTOR) while (currentSize >= maxAllocSize / MAX_REDUCTION_FACTOR)
{ {
log_info("Trying to create a buffer of size of %lld bytes (%gMB).\n", log_info("Trying to create a buffer of size of %" PRIu64
" bytes (%gMB).\n",
currentSize, (double)currentSize / (1024.0 * 1024.0)); currentSize, (double)currentSize / (1024.0 * 1024.0));
memHdl = clCreateBuffer(context, CL_MEM_READ_ONLY, (size_t)currentSize, memHdl = clCreateBuffer(context, CL_MEM_READ_ONLY, (size_t)currentSize,
NULL, &error); NULL, &error);
if (error == CL_MEM_OBJECT_ALLOCATION_FAILURE if (error == CL_MEM_OBJECT_ALLOCATION_FAILURE
|| error == CL_OUT_OF_RESOURCES || error == CL_OUT_OF_HOST_MEMORY) || error == CL_OUT_OF_RESOURCES || error == CL_OUT_OF_HOST_MEMORY)
{ {
log_info("\tAllocation failed at size of %lld bytes (%gMB).\n", log_info("\tAllocation failed at size of %" PRIu64
" bytes (%gMB).\n",
currentSize, (double)currentSize / (1024.0 * 1024.0)); currentSize, (double)currentSize / (1024.0 * 1024.0));
currentSize -= minSizeToTry; currentSize -= minSizeToTry;
continue; continue;
@@ -626,8 +630,8 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
test_error(error, "clCreateBuffer failed for maximum sized buffer."); test_error(error, "clCreateBuffer failed for maximum sized buffer.");
return 0; return 0;
} }
log_error("Failed to allocate even %lld bytes (%gMB).\n", currentSize, log_error("Failed to allocate even %" PRIu64 " bytes (%gMB).\n",
(double)currentSize / (1024.0 * 1024.0)); currentSize, (double)currentSize / (1024.0 * 1024.0));
return -1; return -1;
} }
@@ -671,7 +675,7 @@ int test_min_max_image_2d_width(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported width is %ld.\n", maxDimension); log_info("Max reported width is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -688,8 +692,8 @@ int test_min_max_image_2d_width(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 1 * 4, maxAllocSize); (cl_ulong)maxDimension * 1 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -748,7 +752,7 @@ int test_min_max_image_2d_height(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported height is %ld.\n", maxDimension); log_info("Max reported height is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -765,8 +769,8 @@ int test_min_max_image_2d_height(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 1 * 4, maxAllocSize); (cl_ulong)maxDimension * 1 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -815,7 +819,7 @@ int test_min_max_image_3d_width(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported width is %ld.\n", maxDimension); log_info("Max reported width is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -832,8 +836,8 @@ int test_min_max_image_3d_width(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 2 * 4, maxAllocSize); (cl_ulong)maxDimension * 2 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -883,7 +887,7 @@ int test_min_max_image_3d_height(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported height is %ld.\n", maxDimension); log_info("Max reported height is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -900,8 +904,8 @@ int test_min_max_image_3d_height(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 2 * 4, maxAllocSize); (cl_ulong)maxDimension * 2 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -952,7 +956,7 @@ int test_min_max_image_3d_depth(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported depth is %ld.\n", maxDimension); log_info("Max reported depth is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -969,8 +973,8 @@ int test_min_max_image_3d_depth(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 1 * 4, maxAllocSize); (cl_ulong)maxDimension * 1 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -1019,7 +1023,7 @@ int test_min_max_image_array_size(cl_device_id deviceID, cl_context context,
(int)maxDimension); (int)maxDimension);
return -1; return -1;
} }
log_info("Max reported image array size is %ld.\n", maxDimension); log_info("Max reported image array size is %zu.\n", maxDimension);
/* Verify we can use the format */ /* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8; image_format_desc.image_channel_data_type = CL_UNORM_INT8;
@@ -1037,8 +1041,8 @@ int test_min_max_image_array_size(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize) if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{ {
log_error("Can not allocate a large enough image (min size: %lld " log_error("Can not allocate a large enough image (min size: %" PRIu64
"bytes, max allowed: %lld bytes) to test.\n", " bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 1 * 4, maxAllocSize); (cl_ulong)maxDimension * 1 * 4, maxAllocSize);
return -1; return -1;
} }
@@ -1091,7 +1095,7 @@ int test_min_max_image_buffer_size(cl_device_id deviceID, cl_context context,
(int)maxDimensionPixels); (int)maxDimensionPixels);
return -1; return -1;
} }
log_info("Max reported image buffer size is %ld pixels.\n", log_info("Max reported image buffer size is %zu pixels.\n",
maxDimensionPixels); maxDimensionPixels);
pixelBytes = maxAllocSize / maxDimensionPixels; pixelBytes = maxAllocSize / maxDimensionPixels;
@@ -1209,7 +1213,7 @@ int test_min_max_parameter_size(cl_device_id deviceID, cl_context context,
{ {
log_info( log_info(
"Trying a kernel with %ld int arguments (%ld bytes) and one " "Trying a kernel with %ld int arguments (%ld bytes) and one "
"cl_mem (%ld bytes) for %ld bytes total.\n", "cl_mem (%zu bytes) for %ld bytes total.\n",
numberOfIntParametersToTry, numberOfIntParametersToTry,
sizeof(cl_int) * numberOfIntParametersToTry, sizeof(cl_mem), sizeof(cl_int) * numberOfIntParametersToTry, sizeof(cl_mem),
sizeof(cl_mem) + numberOfIntParametersToTry * sizeof(cl_int)); sizeof(cl_mem) + numberOfIntParametersToTry * sizeof(cl_int));
@@ -1218,7 +1222,7 @@ int test_min_max_parameter_size(cl_device_id deviceID, cl_context context,
{ {
log_info( log_info(
"Trying a kernel with %ld long arguments (%ld bytes) and one " "Trying a kernel with %ld long arguments (%ld bytes) and one "
"cl_mem (%ld bytes) for %ld bytes total.\n", "cl_mem (%zu bytes) for %ld bytes total.\n",
numberOfIntParametersToTry, numberOfIntParametersToTry,
sizeof(cl_long) * numberOfIntParametersToTry, sizeof(cl_mem), sizeof(cl_long) * numberOfIntParametersToTry, sizeof(cl_mem),
sizeof(cl_mem) + numberOfIntParametersToTry * sizeof(cl_long)); sizeof(cl_mem) + numberOfIntParametersToTry * sizeof(cl_long));
@@ -1365,8 +1369,8 @@ int test_min_max_parameter_size(cl_device_id deviceID, cl_context context,
{ {
if (long_result != expectedResult) if (long_result != expectedResult)
{ {
log_error("Expected result (%lld) does not equal actual result " log_error("Expected result (%" PRId64
"(%lld).\n", ") does not equal actual result (%" PRId64 ").\n",
expectedResult, long_result); expectedResult, long_result);
numberOfIntParametersToTry -= decrement; numberOfIntParametersToTry -= decrement;
continue; continue;
@@ -1383,8 +1387,8 @@ int test_min_max_parameter_size(cl_device_id deviceID, cl_context context,
{ {
if (int_result != expectedResult) if (int_result != expectedResult)
{ {
log_error("Expected result (%lld) does not equal actual result " log_error("Expected result (%" PRId64
"(%d).\n", ") does not equal actual result (%d).\n",
expectedResult, int_result); expectedResult, int_result);
numberOfIntParametersToTry -= decrement; numberOfIntParametersToTry -= decrement;
continue; continue;
@@ -1555,7 +1559,8 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
return -1; return -1;
} }
log_info("Reported max constant buffer size of %lld bytes.\n", maxSize); log_info("Reported max constant buffer size of %" PRIu64 " bytes.\n",
maxSize);
/* We have four buffers allocations */ /* We have four buffers allocations */
maxGlobalSize = get_device_info_global_mem_size( maxGlobalSize = get_device_info_global_mem_size(
@@ -1583,7 +1588,8 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
d = init_genrand(gRandomSeed); d = init_genrand(gRandomSeed);
while (!allocPassed && currentSize >= maxSize / MAX_REDUCTION_FACTOR) while (!allocPassed && currentSize >= maxSize / MAX_REDUCTION_FACTOR)
{ {
log_info("Attempting to allocate constant buffer of size %lld bytes\n", log_info("Attempting to allocate constant buffer of size %" PRIu64
" bytes\n",
maxSize); maxSize);
/* Create some I/O streams */ /* Create some I/O streams */
@@ -1631,8 +1637,8 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
|| (error == CL_MEM_OBJECT_ALLOCATION_FAILURE) || (error == CL_MEM_OBJECT_ALLOCATION_FAILURE)
|| (error == CL_OUT_OF_HOST_MEMORY)) || (error == CL_OUT_OF_HOST_MEMORY))
{ {
log_info("Kernel enqueue failed at size %lld, trying at a reduced " log_info("Kernel enqueue failed at size %" PRIu64
"size.\n", ", trying at a reduced size.\n",
currentSize); currentSize);
currentSize -= stepSize; currentSize -= stepSize;
free(constantData); free(constantData);
@@ -1657,8 +1663,8 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
|| (event_status == CL_MEM_OBJECT_ALLOCATION_FAILURE) || (event_status == CL_MEM_OBJECT_ALLOCATION_FAILURE)
|| (event_status == CL_OUT_OF_HOST_MEMORY)) || (event_status == CL_OUT_OF_HOST_MEMORY))
{ {
log_info("Kernel event indicates failure at size %lld, trying " log_info("Kernel event indicates failure at size %" PRIu64
"at a reduced size.\n", ", trying at a reduced size.\n",
currentSize); currentSize);
currentSize -= stepSize; currentSize -= stepSize;
free(constantData); free(constantData);
@@ -1715,7 +1721,8 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
} }
else if (currentSize != maxSize) else if (currentSize != maxSize)
{ {
log_info("Passed at reduced size. (%lld of %lld bytes)\n", log_info("Passed at reduced size. (%" PRIu64 " of %" PRIu64
" bytes)\n",
currentSize, maxSize); currentSize, maxSize);
return 0; return 0;
} }
@@ -1778,11 +1785,11 @@ int test_min_max_constant_args(cl_device_id deviceID, cl_context context,
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR); deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
individualBufferSize = ((int)maxSize / 2) / maxArgs; individualBufferSize = ((int)maxSize / 2) / maxArgs;
log_info( log_info("Reported max constant arg count of %u and max constant buffer "
"Reported max constant arg count of %u and max constant buffer " "size of %" PRIu64
"size of %llu. Test will attempt to allocate half of that, or %llu " ". Test will attempt to allocate half of that, or %u "
"buffers of size %zu.\n", "buffers of size %zu.\n",
maxArgs, maxSize, maxArgs, individualBufferSize); maxArgs, maxSize, maxArgs, individualBufferSize);
str2 = (char *)malloc(sizeof(char) * 32 * (maxArgs + 2)); str2 = (char *)malloc(sizeof(char) * 32 * (maxArgs + 2));
constArgs = (char *)malloc(sizeof(char) * 32 * (maxArgs + 2)); constArgs = (char *)malloc(sizeof(char) * 32 * (maxArgs + 2));
@@ -2034,7 +2041,7 @@ int test_min_max_local_mem_size(cl_device_id deviceID, cl_context context,
return -1; return -1;
} }
log_info("Reported max local buffer size for device: %lld bytes.\n", log_info("Reported max local buffer size for device: %" PRIu64 " bytes.\n",
maxSize); maxSize);
/* Create a kernel to test with */ /* Create a kernel to test with */
@@ -2052,7 +2059,7 @@ int test_min_max_local_mem_size(cl_device_id deviceID, cl_context context,
"clGetKernelWorkGroupInfo for CL_KERNEL_LOCAL_MEM_SIZE failed"); "clGetKernelWorkGroupInfo for CL_KERNEL_LOCAL_MEM_SIZE failed");
log_info("Reported local buffer usage for kernel " log_info("Reported local buffer usage for kernel "
"(CL_KERNEL_LOCAL_MEM_SIZE): %lld bytes.\n", "(CL_KERNEL_LOCAL_MEM_SIZE): %" PRIu64 " bytes.\n",
kernelLocalUsage); kernelLocalUsage);
/* Create some I/O streams */ /* Create some I/O streams */
@@ -2167,13 +2174,13 @@ int test_min_max_kernel_preferred_work_group_size_multiple(
// Since the preferred size is only a performance hint, we can only really // Since the preferred size is only a performance hint, we can only really
// check that we get a sane value back // check that we get a sane value back
log_info("size: %ld preferred: %ld max: %ld\n", max_workgroup_size, log_info("size: %zu preferred: %zu max: %zu\n", max_workgroup_size,
preferred_workgroup_size, max_local_workgroup_size[0]); preferred_workgroup_size, max_local_workgroup_size[0]);
if (preferred_workgroup_size > max_workgroup_size) if (preferred_workgroup_size > max_workgroup_size)
{ {
log_error("ERROR: Reported preferred workgroup multiple larger than " log_error("ERROR: Reported preferred workgroup multiple larger than "
"max workgroup size (preferred %ld, max %ld)\n", "max workgroup size (preferred %zu, max %zu)\n",
preferred_workgroup_size, max_workgroup_size); preferred_workgroup_size, max_workgroup_size);
return -1; return -1;
} }

49
test_conformance/api/test_mem_object_info.cpp
View File

@@ -18,21 +18,24 @@
#include "harness/testHarness.h" #include "harness/testHarness.h"
#define TEST_MEM_OBJECT_PARAM( mem, paramName, val, expected, name, type, cast ) \ #define TEST_MEM_OBJECT_PARAM(mem, paramName, val, expected, name, type, cast) \
error = clGetMemObjectInfo( mem, paramName, sizeof( val ), &val, &size ); \ error = clGetMemObjectInfo(mem, paramName, sizeof(val), &val, &size); \
test_error( error, "Unable to get mem object " name ); \ test_error(error, "Unable to get mem object " name); \
if( val != expected ) \ if (val != expected) \
{ \ { \
log_error( "ERROR: Mem object " name " did not validate! (expected " type ", got " type " from %s:%d)\n", \ log_error("ERROR: Mem object " name \
expected, (cast)val, __FILE__, __LINE__ ); \ " did not validate! (expected " type ", got " type \
return -1; \ " from %s:%d)\n", \
} \ (cast)expected, (cast)val, __FILE__, __LINE__); \
if( size != sizeof( val ) ) \ return -1; \
{ \ } \
log_error( "ERROR: Returned size of mem object " name " does not validate! (expected %d, got %d from %s:%d)\n", \ if (size != sizeof(val)) \
(int)sizeof( val ), (int)size , __FILE__, __LINE__ ); \ { \
return -1; \ log_error("ERROR: Returned size of mem object " name \
} " does not validate! (expected %d, got %d from %s:%d)\n", \
(int)sizeof(val), (int)size, __FILE__, __LINE__); \
return -1; \
}
static void CL_CALLBACK mem_obj_destructor_callback( cl_mem, void * data ) static void CL_CALLBACK mem_obj_destructor_callback( cl_mem, void * data )
{ {
@@ -236,7 +239,8 @@ int test_get_buffer_info( cl_device_id deviceID, cl_context context, cl_command_
TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_FLAGS, flags, (unsigned int)bufferFlags[ i ], "flags", "%d", unsigned int ) TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_FLAGS, flags, (unsigned int)bufferFlags[ i ], "flags", "%d", unsigned int )
size_t sz; size_t sz;
TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_SIZE, sz, (size_t)( addressAlign * 4 ), "size", "%ld", size_t ) TEST_MEM_OBJECT_PARAM(bufferObject, CL_MEM_SIZE, sz,
(size_t)(addressAlign * 4), "size", "%zu", size_t)
cl_uint mapCount; cl_uint mapCount;
error = clGetMemObjectInfo( bufferObject, CL_MEM_MAP_COUNT, sizeof( mapCount ), &mapCount, &size ); error = clGetMemObjectInfo( bufferObject, CL_MEM_MAP_COUNT, sizeof( mapCount ), &mapCount, &size );
@@ -265,7 +269,8 @@ int test_get_buffer_info( cl_device_id deviceID, cl_context context, cl_command_
TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_ASSOCIATED_MEMOBJECT, origObj, (void *)NULL, "associated mem object", "%p", void * ) TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_ASSOCIATED_MEMOBJECT, origObj, (void *)NULL, "associated mem object", "%p", void * )
size_t offset; size_t offset;
TEST_MEM_OBJECT_PARAM( bufferObject, CL_MEM_OFFSET, offset, 0L, "offset", "%ld", size_t ) TEST_MEM_OBJECT_PARAM(bufferObject, CL_MEM_OFFSET, offset, size_t(0),
"offset", "%zu", size_t)
cl_buffer_region region; cl_buffer_region region;
region.origin = addressAlign; region.origin = addressAlign;
@@ -321,7 +326,8 @@ int test_get_buffer_info( cl_device_id deviceID, cl_context context, cl_command_
} }
TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_FLAGS, flags, (unsigned int)inheritedFlags, "flags", "%d", unsigned int ) TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_FLAGS, flags, (unsigned int)inheritedFlags, "flags", "%d", unsigned int )
TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_SIZE, sz, (size_t)( addressAlign ), "size", "%ld", size_t ) TEST_MEM_OBJECT_PARAM(subBufferObject, CL_MEM_SIZE, sz,
(size_t)(addressAlign), "size", "%zu", size_t)
if ( bufferFlags[ i ] & CL_MEM_USE_HOST_PTR ) if ( bufferFlags[ i ] & CL_MEM_USE_HOST_PTR )
{ {
@@ -356,7 +362,9 @@ int test_get_buffer_info( cl_device_id deviceID, cl_context context, cl_command_
TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_ASSOCIATED_MEMOBJECT, origObj, (cl_mem)bufferObject, "associated mem object", "%p", void * ) TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_ASSOCIATED_MEMOBJECT, origObj, (cl_mem)bufferObject, "associated mem object", "%p", void * )
TEST_MEM_OBJECT_PARAM( subBufferObject, CL_MEM_OFFSET, offset, (size_t)( addressAlign ), "offset", "%ld", size_t ) TEST_MEM_OBJECT_PARAM(subBufferObject, CL_MEM_OFFSET, offset,
(size_t)(addressAlign), "offset", "%zu",
size_t)
} }
} }
@@ -405,7 +413,8 @@ int test_get_imageObject_info( cl_mem * image, cl_mem_flags objectFlags, cl_imag
TEST_MEM_OBJECT_PARAM( *image, CL_MEM_CONTEXT, otherCtx, context, "context", "%p", cl_context ) TEST_MEM_OBJECT_PARAM( *image, CL_MEM_CONTEXT, otherCtx, context, "context", "%p", cl_context )
TEST_MEM_OBJECT_PARAM( *image, CL_MEM_OFFSET, offset, 0L, "offset", "%ld", size_t ) TEST_MEM_OBJECT_PARAM(*image, CL_MEM_OFFSET, offset, size_t(0), "offset",
"%zu", size_t)
return CL_SUCCESS; return CL_SUCCESS;
} }

2
test_conformance/api/test_mem_object_properties_queries.cpp
View File

@@ -165,7 +165,7 @@ static int create_object_and_check_properties(cl_context context,
} }
if (set_size != test_case.properties.size() * sizeof(cl_mem_properties)) if (set_size != test_case.properties.size() * sizeof(cl_mem_properties))
{ {
log_error("ERROR: CL_MEM_PROPERTIES size is %d, expected %d.\n", log_error("ERROR: CL_MEM_PROPERTIES size is %zu, expected %zu.\n",
set_size, set_size,
test_case.properties.size() * sizeof(cl_queue_properties)); test_case.properties.size() * sizeof(cl_queue_properties));
return TEST_FAIL; return TEST_FAIL;

2
test_conformance/api/test_pipe_properties_queries.cpp
View File

@@ -60,7 +60,7 @@ static int create_pipe_and_check_array_properties(
} }
if (set_size != test_case.properties.size() * sizeof(cl_pipe_properties)) if (set_size != test_case.properties.size() * sizeof(cl_pipe_properties))
{ {
log_error("ERROR: CL_PIPE_PROPERTIES size is %d, expected %d.\n", log_error("ERROR: CL_PIPE_PROPERTIES size is %zu, expected %zu.\n",
set_size, set_size,
test_case.properties.size() * sizeof(cl_pipe_properties)); test_case.properties.size() * sizeof(cl_pipe_properties));
return TEST_FAIL; return TEST_FAIL;

36
test_conformance/api/test_platform.cpp
View File

@@ -189,8 +189,10 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetPlatformInfo for CL_PLATFORM_PROFILE failed"); test_error(err, "clGetPlatformInfo for CL_PLATFORM_PROFILE failed");
log_info("\tCL_PLATFORM_PROFILE: %s\n", string_returned); log_info("\tCL_PLATFORM_PROFILE: %s\n", string_returned);
if (strlen(string_returned)+1 != size) { if (strlen(string_returned)+1 != size) {
log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size); log_error(
total_errors++; "Returned string length %zu does not equal reported one %zu.\n",
strlen(string_returned) + 1, size);
total_errors++;
} }
memset(string_returned, 0, 8192); memset(string_returned, 0, 8192);
@@ -198,8 +200,10 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetPlatformInfo for CL_PLATFORM_VERSION failed"); test_error(err, "clGetPlatformInfo for CL_PLATFORM_VERSION failed");
log_info("\tCL_PLATFORM_VERSION: %s\n", string_returned); log_info("\tCL_PLATFORM_VERSION: %s\n", string_returned);
if (strlen(string_returned)+1 != size) { if (strlen(string_returned)+1 != size) {
log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size); log_error(
total_errors++; "Returned string length %zu does not equal reported one %zu.\n",
strlen(string_returned) + 1, size);
total_errors++;
} }
memset(string_returned, 0, 8192); memset(string_returned, 0, 8192);
@@ -207,8 +211,10 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetPlatformInfo for CL_PLATFORM_NAME failed"); test_error(err, "clGetPlatformInfo for CL_PLATFORM_NAME failed");
log_info("\tCL_PLATFORM_NAME: %s\n", string_returned); log_info("\tCL_PLATFORM_NAME: %s\n", string_returned);
if (strlen(string_returned)+1 != size) { if (strlen(string_returned)+1 != size) {
log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size); log_error(
total_errors++; "Returned string length %zu does not equal reported one %zu.\n",
strlen(string_returned) + 1, size);
total_errors++;
} }
memset(string_returned, 0, 8192); memset(string_returned, 0, 8192);
@@ -216,8 +222,10 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetPlatformInfo for CL_PLATFORM_VENDOR failed"); test_error(err, "clGetPlatformInfo for CL_PLATFORM_VENDOR failed");
log_info("\tCL_PLATFORM_VENDOR: %s\n", string_returned); log_info("\tCL_PLATFORM_VENDOR: %s\n", string_returned);
if (strlen(string_returned)+1 != size) { if (strlen(string_returned)+1 != size) {
log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size); log_error(
total_errors++; "Returned string length %zu does not equal reported one %zu.\n",
strlen(string_returned) + 1, size);
total_errors++;
} }
memset(string_returned, 0, 8192); memset(string_returned, 0, 8192);
@@ -225,8 +233,10 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetPlatformInfo for CL_PLATFORM_EXTENSIONS failed"); test_error(err, "clGetPlatformInfo for CL_PLATFORM_EXTENSIONS failed");
log_info("\tCL_PLATFORM_EXTENSIONS: %s\n", string_returned); log_info("\tCL_PLATFORM_EXTENSIONS: %s\n", string_returned);
if (strlen(string_returned)+1 != size) { if (strlen(string_returned)+1 != size) {
log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size); log_error(
total_errors++; "Returned string length %zu does not equal reported one %zu.\n",
strlen(string_returned) + 1, size);
total_errors++;
} }
err = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices); err = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
@@ -258,8 +268,8 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
test_error(err, "clGetDeviceInfo failed for CL_DEVICE_PLATFORM\n"); test_error(err, "clGetDeviceInfo failed for CL_DEVICE_PLATFORM\n");
if (returned_size != sizeof(cl_platform_id)) if (returned_size != sizeof(cl_platform_id))
{ {
log_error("Reported return size (%ld) does not match expected size " log_error("Reported return size (%zu) does not match expected size "
"(%ld).\n", "(%zu).\n",
returned_size, sizeof(cl_platform_id)); returned_size, sizeof(cl_platform_id));
total_errors++; total_errors++;
} }
@@ -288,7 +298,7 @@ int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_
if (returned_size != sizeof(cl_context_properties) * 3) if (returned_size != sizeof(cl_context_properties) * 3)
{ {
log_error("Invalid size returned from clGetContextInfo for " log_error("Invalid size returned from clGetContextInfo for "
"CL_CONTEXT_PROPERTIES. Got %ld, expected %ld.\n", "CL_CONTEXT_PROPERTIES. Got %zu, expected %zu.\n",
returned_size, sizeof(cl_context_properties) * 3); returned_size, sizeof(cl_context_properties) * 3);
total_errors++; total_errors++;
} }

10
test_conformance/api/test_queries.cpp
View File

@@ -19,6 +19,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <ctype.h> #include <ctype.h>
#include <algorithm> #include <algorithm>
#include <cinttypes>
#include <vector> #include <vector>
int test_get_platform_info(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) int test_get_platform_info(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
@@ -237,7 +238,7 @@ int test_sampler_params(cl_device_id deviceID, cl_context context,
if (set_size != 0) if (set_size != 0)
{ {
log_error( log_error(
"ERROR: CL_SAMPLER_PROPERTIES size is %d, expected 0\n", "ERROR: CL_SAMPLER_PROPERTIES size is %zu, expected 0\n",
set_size); set_size);
return TEST_FAIL; return TEST_FAIL;
} }
@@ -248,7 +249,7 @@ int test_sampler_params(cl_device_id deviceID, cl_context context,
!= test_properties.size() * sizeof(cl_sampler_properties)) != test_properties.size() * sizeof(cl_sampler_properties))
{ {
log_error( log_error(
"ERROR: CL_SAMPLER_PROPERTIES size is %d, expected %d.\n", "ERROR: CL_SAMPLER_PROPERTIES size is %zu, expected %zu.\n",
set_size, set_size,
test_properties.size() * sizeof(cl_sampler_properties)); test_properties.size() * sizeof(cl_sampler_properties));
return TEST_FAIL; return TEST_FAIL;
@@ -380,7 +381,8 @@ int check_get_command_queue_info_params(cl_device_id deviceID,
clGetDeviceInfo(deviceID, host_queue_query, sizeof(host_queue_props), clGetDeviceInfo(deviceID, host_queue_query, sizeof(host_queue_props),
&host_queue_props, NULL); &host_queue_props, NULL);
test_error(error, "clGetDeviceInfo failed"); test_error(error, "clGetDeviceInfo failed");
log_info("CL_DEVICE_QUEUE_ON_HOST_PROPERTIES is %d\n", host_queue_props); log_info("CL_DEVICE_QUEUE_ON_HOST_PROPERTIES is %" PRIu64 "\n",
host_queue_props);
cl_queue_properties device_queue_props = 0; cl_queue_properties device_queue_props = 0;
if (version >= Version(2, 0)) if (version >= Version(2, 0))
@@ -389,7 +391,7 @@ int check_get_command_queue_info_params(cl_device_id deviceID,
sizeof(device_queue_props), &device_queue_props, sizeof(device_queue_props), &device_queue_props,
NULL); NULL);
test_error(error, "clGetDeviceInfo failed"); test_error(error, "clGetDeviceInfo failed");
log_info("CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES is %d\n", log_info("CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES is %" PRIu64 "\n",
device_queue_props); device_queue_props);
} }

7
test_conformance/api/test_queue_properties_queries.cpp
View File

@@ -142,9 +142,10 @@ static int create_queue_and_check_array_properties(
} }
if (set_size != test_case.properties.size() * sizeof(cl_queue_properties)) if (set_size != test_case.properties.size() * sizeof(cl_queue_properties))
{ {
log_error("ERROR: CL_QUEUE_PROPERTIES_ARRAY size is %d, expected %d.\n", log_error(
set_size, "ERROR: CL_QUEUE_PROPERTIES_ARRAY size is %zu, expected %zu.\n",
test_case.properties.size() * sizeof(cl_queue_properties)); set_size,
test_case.properties.size() * sizeof(cl_queue_properties));
return TEST_FAIL; return TEST_FAIL;
} }