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

Limit buffers sizes to leave some memory for the platform (#1172)

Browse Source 
Some conformance tests use directly the size returned by the runtime
for max memory size to allocate buffers.
This doesn't leave enough memory for the system to run the tests.
This commit is contained in:
arm-wk
2024-08-06 17:32:08 +01:00
committed by GitHub
parent 995e46590e
commit f47354680f
10 changed files with 186 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
test_conformance/allocations/allocation_functions.cpp
View File

@@ -188,27 +188,15 @@ int allocate_size(cl_context context, cl_command_queue *queue,
// one we don't end up returning a garbage value
*number_of_mems = 0;
error = clGetDeviceInfo(device_id, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(max_individual_allocation_size),
&max_individual_allocation_size, NULL);
test_error_abort(error,
"clGetDeviceInfo failed for CL_DEVICE_MAX_MEM_ALLOC_SIZE");
error = clGetDeviceInfo(device_id, CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(global_mem_size), &global_mem_size, NULL);
test_error_abort(error,
"clGetDeviceInfo failed for CL_DEVICE_GLOBAL_MEM_SIZE");
max_individual_allocation_size =
get_device_info_max_mem_alloc_size(device_id);
global_mem_size = get_device_info_global_mem_size(device_id);
if (global_mem_size > (cl_ulong)SIZE_MAX)
{
global_mem_size = (cl_ulong)SIZE_MAX;
}
// log_info("Device reports CL_DEVICE_MAX_MEM_ALLOC_SIZE=%llu bytes (%gMB),
// CL_DEVICE_GLOBAL_MEM_SIZE=%llu bytes (%gMB).\n",
// max_individual_allocation_size,
// toMB(max_individual_allocation_size), global_mem_size,
// toMB(global_mem_size));
if (size_to_allocate > global_mem_size)
{
log_error("Can not allocate more than the global memory size.\n");

25
test_conformance/allocations/main.cpp
View File

@@ -24,8 +24,10 @@
typedef long long unsigned llu;
#define REDUCTION_PERCENTAGE_DEFAULT 50
int g_repetition_count = 1;
int g_reduction_percentage = 100;
int g_reduction_percentage = REDUCTION_PERCENTAGE_DEFAULT;
int g_write_allocations = 1;
int g_multiple_allocations = 0;
int g_execute_kernel = 1;
@@ -44,24 +46,9 @@ test_status init_cl(cl_device_id device)
{
int error;
error = clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(g_max_individual_allocation_size),
&g_max_individual_allocation_size, NULL);
if (error)
{
print_error(error,
"clGetDeviceInfo failed for CL_DEVICE_MAX_MEM_ALLOC_SIZE");
return TEST_FAIL;
}
error =
clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(g_global_mem_size), &g_global_mem_size, NULL);
if (error)
{
print_error(error,
"clGetDeviceInfo failed for CL_DEVICE_GLOBAL_MEM_SIZE");
return TEST_FAIL;
}
g_max_individual_allocation_size =
get_device_info_max_mem_alloc_size(device);
g_global_mem_size = get_device_info_global_mem_size(device);
log_info("Device reports CL_DEVICE_MAX_MEM_ALLOC_SIZE=%llu bytes (%gMB), "
"CL_DEVICE_GLOBAL_MEM_SIZE=%llu bytes (%gMB).\n",

163
test_conformance/api/test_api_min_max.cpp
View File

@@ -112,6 +112,8 @@ const char *sample_const_max_arg_kernel_pattern =
"\n"
"}\n";
#define MAX_REDUCTION_FACTOR 4
int test_min_max_thread_dimensions(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
@@ -564,7 +566,7 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
int error;
cl_ulong maxAllocSize, memSize, minSizeToTry;
cl_ulong maxAllocSize, memSize, minSizeToTry, currentSize;
clMemWrapper memHdl;
cl_ulong requiredAllocSize;
@@ -574,56 +576,12 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
else
requiredAllocSize = 128 * 1024 * 1024;
/* Get the max mem alloc size */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get max mem alloc size from device");
error = clGetDeviceInfo(deviceID, CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(memSize), &memSize, NULL);
test_error(error, "Unable to get global memory size from device");
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if (maxAllocSize < requiredAllocSize)
{
log_error("ERROR: Reported max allocation size is less than required "
"%lldMB! (%llu or %lluMB, from a total mem size of %lldMB)\n",
(requiredAllocSize / 1024) / 1024, maxAllocSize,
(maxAllocSize / 1024) / 1024, (memSize / 1024) / 1024);
return -1;
}
requiredAllocSize = ((memSize / 4) > (1024 * 1024 * 1024))
? 1024 * 1024 * 1024
: memSize / 4;
if (gIsEmbedded)
requiredAllocSize = (requiredAllocSize < 1 * 1024 * 1024)
? 1 * 1024 * 1024
: requiredAllocSize;
else
requiredAllocSize = (requiredAllocSize < 128 * 1024 * 1024)
? 128 * 1024 * 1024
: requiredAllocSize;
if (maxAllocSize < requiredAllocSize)
{
log_error(
"ERROR: Reported max allocation size is less than required of "
"total memory! (%llu or %lluMB, from a total mem size of %lluMB)\n",
maxAllocSize, (maxAllocSize / 1024) / 1024,
(requiredAllocSize / 1024) / 1024);
return -1;
}
log_info("Reported max allocation size of %lld bytes (%gMB) and global mem "
"size of %lld bytes (%gMB).\n",
maxAllocSize, maxAllocSize / (1024.0 * 1024.0), requiredAllocSize,
requiredAllocSize / (1024.0 * 1024.0));
/* Get the max mem alloc size, limit the alloc to half of the available
* memory */
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize = get_device_info_global_mem_size(deviceID,
MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize < maxAllocSize)
{
@@ -632,27 +590,44 @@ int test_min_max_mem_alloc_size(cl_device_id deviceID, cl_context context,
maxAllocSize = memSize;
}
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if (maxAllocSize < requiredAllocSize)
{
log_error("ERROR: Reported max allocation size is less than required");
return -1;
}
log_info("Reported max allocation size of %lld bytes (%gMB) and global mem "
"size of %lld bytes (%gMB).\n",
maxAllocSize, maxAllocSize / (1024.0 * 1024.0), memSize,
memSize / (1024.0 * 1024.0));
minSizeToTry = maxAllocSize / 16;
while (maxAllocSize > (maxAllocSize / 4))
currentSize = maxAllocSize;
while (currentSize >= maxAllocSize / MAX_REDUCTION_FACTOR)
{
log_info("Trying to create a buffer of size of %lld bytes (%gMB).\n",
maxAllocSize, (double)maxAllocSize / (1024.0 * 1024.0));
memHdl = clCreateBuffer(context, CL_MEM_READ_ONLY, (size_t)maxAllocSize,
currentSize, (double)currentSize / (1024.0 * 1024.0));
memHdl = clCreateBuffer(context, CL_MEM_READ_ONLY, (size_t)currentSize,
NULL, &error);
if (error == CL_MEM_OBJECT_ALLOCATION_FAILURE
|| error == CL_OUT_OF_RESOURCES || error == CL_OUT_OF_HOST_MEMORY)
{
log_info("\tAllocation failed at size of %lld bytes (%gMB).\n",
maxAllocSize, (double)maxAllocSize / (1024.0 * 1024.0));
maxAllocSize -= minSizeToTry;
currentSize, (double)currentSize / (1024.0 * 1024.0));
currentSize -= minSizeToTry;
continue;
}
test_error(error, "clCreateBuffer failed for maximum sized buffer.");
return 0;
}
log_error("Failed to allocate even %lld bytes (%gMB).\n", maxAllocSize,
(double)maxAllocSize / (1024.0 * 1024.0));
log_error("Failed to allocate even %lld bytes (%gMB).\n", currentSize,
(double)currentSize / (1024.0 * 1024.0));
return -1;
}
@@ -709,9 +684,8 @@ int test_min_max_image_2d_width(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -787,9 +761,8 @@ int test_min_max_image_2d_height(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -855,9 +828,8 @@ int test_min_max_image_3d_width(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -924,9 +896,8 @@ int test_min_max_image_3d_height(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 2 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -994,9 +965,8 @@ int test_min_max_image_3d_depth(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -1063,9 +1033,8 @@ int test_min_max_image_array_size(cl_device_id deviceID, cl_context context,
}
/* Verify that we can actually allocate an image that large */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((cl_ulong)maxDimension * 1 * 4 > maxAllocSize)
{
log_error("Can not allocate a large enough image (min size: %lld "
@@ -1105,10 +1074,9 @@ int test_min_max_image_buffer_size(cl_device_id deviceID, cl_context context,
PASSIVE_REQUIRE_IMAGE_SUPPORT(deviceID);
/* Get the max memory allocation size */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, NULL);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE.");
/* Get the max memory allocation size, divide it */
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
/* Get the max image array width */
error =
@@ -1559,7 +1527,6 @@ int test_min_max_samplers(cl_device_id deviceID, cl_context context,
return 0;
}
#define PASSING_FRACTION 4
int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
@@ -1575,11 +1542,12 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
MTdata d;
/* Verify our test buffer won't be bigger than allowed */
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE,
sizeof(maxSize), &maxSize, 0);
test_error(error, "Unable to get max constant buffer size");
maxSize = get_device_info_max_constant_buffer_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if ((0 == gIsEmbedded && maxSize < 64L * 1024L) || maxSize < 1L * 1024L)
if ((0 == gIsEmbedded
&& (maxSize * MAX_DEVICE_MEMORY_SIZE_DIVISOR) < 64L * 1024L)
|| (maxSize * MAX_DEVICE_MEMORY_SIZE_DIVISOR) < 1L * 1024L)
{
log_error("ERROR: Reported max constant buffer size less than required "
"by OpenCL 1.0 (reported %d KB)\n",
@@ -1589,16 +1557,14 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
log_info("Reported max constant buffer size of %lld bytes.\n", maxSize);
// Limit test buffer size to 1/8 of CL_DEVICE_GLOBAL_MEM_SIZE
error = clGetDeviceInfo(deviceID, CL_DEVICE_GLOBAL_MEM_SIZE,
sizeof(maxGlobalSize), &maxGlobalSize, 0);
test_error(error, "Unable to get CL_DEVICE_GLOBAL_MEM_SIZE");
/* We have four buffers allocations */
maxGlobalSize = get_device_info_global_mem_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR * 4);
if (maxSize > maxGlobalSize / 8) maxSize = maxGlobalSize / 8;
if (maxSize > maxGlobalSize) maxSize = maxGlobalSize;
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_MEM_ALLOC_SIZE,
sizeof(maxAllocSize), &maxAllocSize, 0);
test_error(error, "Unable to get CL_DEVICE_MAX_MEM_ALLOC_SIZE ");
maxAllocSize = get_device_info_max_mem_alloc_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (maxSize > maxAllocSize) maxSize = maxAllocSize;
@@ -1615,7 +1581,7 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
currentSize = maxSize;
int allocPassed = 0;
d = init_genrand(gRandomSeed);
while (!allocPassed && currentSize >= maxSize / PASSING_FRACTION)
while (!allocPassed && currentSize >= maxSize / MAX_REDUCTION_FACTOR)
{
log_info("Attempting to allocate constant buffer of size %lld bytes\n",
maxSize);
@@ -1741,7 +1707,7 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
if (allocPassed)
{
if (currentSize < maxSize / PASSING_FRACTION)
if (currentSize < maxSize / MAX_REDUCTION_FACTOR)
{
log_error("Failed to allocate at least 1/8 of the reported "
"constant size.\n");
@@ -1808,10 +1774,9 @@ int test_min_max_constant_args(cl_device_id deviceID, cl_context context,
return -1;
}
error = clGetDeviceInfo(deviceID, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE,
sizeof(maxSize), &maxSize, 0);
test_error(error, "Unable to get max constant buffer size");
individualBufferSize = (maxSize / 2) / maxArgs;
maxSize = get_device_info_max_constant_buffer_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
individualBufferSize = ((int)maxSize / 2) / maxArgs;
log_info(
"Reported max constant arg count of %u and max constant buffer "

4
test_conformance/api/test_kernels.cpp
View File

@@ -389,8 +389,8 @@ int test_set_kernel_arg_constant(cl_device_id deviceID, cl_context context, cl_c
std::vector<cl_int> randomTestDataB(num_elements);
/* Verify our test buffer won't be bigger than allowed */
error = clGetDeviceInfo( deviceID, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof( maxSize ), &maxSize, 0 );
test_error( error, "Unable to get max constant buffer size" );
maxSize = get_device_info_max_constant_buffer_size(
deviceID, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (maxSize < sizeof(cl_int) * num_elements)
{
log_error( "ERROR: Unable to test constant argument to kernel: max size of constant buffer is reported as %d!\n", (int)maxSize );

19
test_conformance/images/clGetInfo/test_1D.cpp
View File

@@ -39,15 +39,20 @@ int test_get_image_info_1D( cl_device_id device, cl_context context, cl_image_fo
imageInfo.format = format;
pixelSize = get_pixel_size( imageInfo.format );
int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof( memSize ), &memSize, NULL );
int error = clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH,
sizeof(maxWidth), &maxWidth, NULL);
test_error( error, "Unable to get max image 1D size from device" );
if (memSize > (cl_ulong)SIZE_MAX) {
memSize = (cl_ulong)SIZE_MAX;
maxAllocSize = (cl_ulong)SIZE_MAX;
}
/* Reduce the size used by the test by half */
maxAllocSize = get_device_info_max_mem_alloc_size(
device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize =
get_device_info_global_mem_size(device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if( gTestSmallImages )
{

38
test_conformance/images/clGetInfo/test_1D_2D_array.cpp
View File

@@ -37,15 +37,20 @@ int test_get_image_info_1D_array( cl_device_id device, cl_context context, cl_im
imageInfo.type = CL_MEM_OBJECT_IMAGE1D_ARRAY;
int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof( maxArraySize ), &maxArraySize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof( memSize ), &memSize, NULL );
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
sizeof(maxArraySize), &maxArraySize, NULL);
test_error( error, "Unable to get max image 1D array size from device" );
if (memSize > (cl_ulong)SIZE_MAX) {
memSize = (cl_ulong)SIZE_MAX;
maxAllocSize = (cl_ulong)SIZE_MAX;
}
/* Reduce the size used by the test by half */
maxAllocSize = get_device_info_max_mem_alloc_size(
device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize =
get_device_info_global_mem_size(device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if( gTestSmallImages )
{
@@ -162,15 +167,20 @@ int test_get_image_info_2D_array( cl_device_id device, cl_context context, cl_im
int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof( maxArraySize ), &maxArraySize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof( memSize ), &memSize, NULL );
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
sizeof(maxArraySize), &maxArraySize, NULL);
test_error( error, "Unable to get max image 1D array size from device" );
if (memSize > (cl_ulong)SIZE_MAX) {
memSize = (cl_ulong)SIZE_MAX;
maxAllocSize = (cl_ulong)SIZE_MAX;
}
/* Reduce the size used by the test by half */
maxAllocSize = get_device_info_max_mem_alloc_size(
device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize =
get_device_info_global_mem_size(device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if( gTestSmallImages )
{

19
test_conformance/images/clGetInfo/test_2D.cpp
View File

@@ -301,15 +301,20 @@ int test_get_image_info_2D( cl_device_id device, cl_context context, cl_image_fo
pixelSize = get_pixel_size( imageInfo.format );
int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof( memSize ), &memSize, NULL );
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT,
sizeof(maxHeight), &maxHeight, NULL);
test_error( error, "Unable to get max image 2D width or max image 3D height or max memory allocation size or global memory size from device" );
if (memSize > (cl_ulong)SIZE_MAX) {
memSize = (cl_ulong)SIZE_MAX;
maxAllocSize = (cl_ulong)SIZE_MAX;
}
/* Reduce the size used by the test by half */
maxAllocSize = get_device_info_max_mem_alloc_size(
device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize =
get_device_info_global_mem_size(device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if( gTestSmallImages )
{

19
test_conformance/images/clGetInfo/test_3D.cpp
View File

@@ -40,15 +40,20 @@ int test_get_image_info_3D( cl_device_id device, cl_context context, cl_image_fo
int error = clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof( maxWidth ), &maxWidth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof( maxHeight ), &maxHeight, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof( maxDepth ), &maxDepth, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof( maxAllocSize ), &maxAllocSize, NULL );
error |= clGetDeviceInfo( device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof( memSize ), &memSize, NULL );
error |= clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH,
sizeof(maxDepth), &maxDepth, NULL);
test_error( error, "Unable to get max image 3D size from device" );
if (memSize > (cl_ulong)SIZE_MAX) {
memSize = (cl_ulong)SIZE_MAX;
maxAllocSize = (cl_ulong)SIZE_MAX;
}
/* Reduce the size used by the test by half */
maxAllocSize = get_device_info_max_mem_alloc_size(
device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
memSize =
get_device_info_global_mem_size(device, MAX_DEVICE_MEMORY_SIZE_DIVISOR);
if (memSize > (cl_ulong)SIZE_MAX)
{
memSize = (cl_ulong)SIZE_MAX;
}
if( gTestSmallImages )
{