Skip to content

Added support for querying the max 3d image dimensions when the device does not support images #2637

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
shajder wants to merge 1 commit into
base: main
Choose a base branch
from
+87 −51
Open

Added support for querying the max 3d image dimensions when the device does not support images #2637

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
138 changes: 87 additions & 51 deletions test_conformance/api/test_api_min_max.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -786,19 +786,31 @@ REGISTER_TEST(min_max_image_3d_width)
{
int error;
size_t maxDimension;
clMemWrapper streams[1];
cl_image_format image_format_desc;
clMemWrapper streams;
cl_image_format imageFormatDesc;
cl_ulong maxAllocSize;

if (checkFor3DImageSupport(device))
{
/* Get the max 3d image width */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d width from device");

PASSIVE_REQUIRE_3D_IMAGE_SUPPORT(device)
test_failure_error_ret(maxDimension, 0,
"Missing 3d image support but "
"CL_DEVICE_IMAGE3D_MAX_WIDTH query did "
"not return 0",
TEST_FAIL);
return TEST_SKIPPED_ITSELF;
}

/* Just get any ol format to test with */
error = get_8_bit_image_format(context, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_READ_ONLY, 0, &image_format_desc);
CL_MEM_READ_ONLY, 0, &imageFormatDesc);
test_error(error, "Unable to obtain suitable image format to test with!");

/* Get the max 2d image width */
/* Get the max 3d image width */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d width from device");
Expand All @@ -808,18 +820,18 @@ REGISTER_TEST(min_max_image_3d_width)
log_error(
"ERROR: Reported max image 3d width is less than required! (%d)\n",
(int)maxDimension);
return -1;
return TEST_FAIL;
}
log_info("Max reported width is %zu.\n", maxDimension);

/* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8;
image_format_desc.image_channel_order = CL_RGBA;
imageFormatDesc.image_channel_data_type = CL_UNORM_INT8;
imageFormatDesc.image_channel_order = CL_RGBA;
if (!is_image_format_supported(context, CL_MEM_READ_ONLY,
CL_MEM_OBJECT_IMAGE3D, &image_format_desc))
CL_MEM_OBJECT_IMAGE3D, &imageFormatDesc))
{
log_error("CL_UNORM_INT8 CL_RGBA not supported. Can not test.");
return -1;
return TEST_FAIL;
}

/* Verify that we can actually allocate an image that large */
Expand All @@ -830,42 +842,54 @@ REGISTER_TEST(min_max_image_3d_width)
log_error("Can not allocate a large enough image (min size: %" PRIu64
" bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 2 * 4, maxAllocSize);
return -1;
return TEST_FAIL;
}

log_info("Attempting to create an image of size %d x 1 x 2 = %gMB.\n",
(int)maxDimension,
(2 * (float)maxDimension * 4 / 1024.0 / 1024.0));

/* Try to allocate a very big image */
streams[0] = create_image_3d(context, CL_MEM_READ_ONLY, &image_format_desc,
maxDimension, 1, 2, 0, 0, NULL, &error);
if ((streams[0] == NULL) || (error != CL_SUCCESS))
streams = create_image_3d(context, CL_MEM_READ_ONLY, &imageFormatDesc,
maxDimension, 1, 2, 0, 0, NULL, &error);
if ((streams == nullptr) || (error != CL_SUCCESS))
{
print_error(error, "Image 3D creation failed for maximum width");
return -1;
return TEST_FAIL;
}

return 0;
return TEST_PASS;
}

REGISTER_TEST(min_max_image_3d_height)
{
int error;
size_t maxDimension;
clMemWrapper streams[1];
cl_image_format image_format_desc;
clMemWrapper streams;
cl_image_format imageFormatDesc;
cl_ulong maxAllocSize;

if (checkFor3DImageSupport(device))
{
/* Get the max 3d image height */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d height from device");

PASSIVE_REQUIRE_3D_IMAGE_SUPPORT(device)
test_failure_error_ret(maxDimension, 0,
"Missing 3d image support but "
"CL_DEVICE_IMAGE3D_MAX_HEIGHT query did "
"not return 0",
TEST_FAIL);
return TEST_SKIPPED_ITSELF;
}

/* Just get any ol format to test with */
error = get_8_bit_image_format(context, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_READ_ONLY, 0, &image_format_desc);
CL_MEM_READ_ONLY, 0, &imageFormatDesc);
test_error(error, "Unable to obtain suitable image format to test with!");

/* Get the max 2d image width */
/* Get the max 3d image height */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d height from device");
Expand All @@ -875,18 +899,18 @@ REGISTER_TEST(min_max_image_3d_height)
log_error(
"ERROR: Reported max image 3d height is less than required! (%d)\n",
(int)maxDimension);
return -1;
return TEST_FAIL;
}
log_info("Max reported height is %zu.\n", maxDimension);

/* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8;
image_format_desc.image_channel_order = CL_RGBA;
imageFormatDesc.image_channel_data_type = CL_UNORM_INT8;
imageFormatDesc.image_channel_order = CL_RGBA;
if (!is_image_format_supported(context, CL_MEM_READ_ONLY,
CL_MEM_OBJECT_IMAGE3D, &image_format_desc))
CL_MEM_OBJECT_IMAGE3D, &imageFormatDesc))
{
log_error("CL_UNORM_INT8 CL_RGBA not supported. Can not test.");
return -1;
return TEST_FAIL;
}

/* Verify that we can actually allocate an image that large */
Expand All @@ -897,64 +921,76 @@ REGISTER_TEST(min_max_image_3d_height)
log_error("Can not allocate a large enough image (min size: %" PRIu64
" bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 2 * 4, maxAllocSize);
return -1;
return TEST_FAIL;
}

log_info("Attempting to create an image of size 1 x %d x 2 = %gMB.\n",
(int)maxDimension,
(2 * (float)maxDimension * 4 / 1024.0 / 1024.0));

/* Try to allocate a very big image */
streams[0] = create_image_3d(context, CL_MEM_READ_ONLY, &image_format_desc,
1, maxDimension, 2, 0, 0, NULL, &error);
if ((streams[0] == NULL) || (error != CL_SUCCESS))
streams = create_image_3d(context, CL_MEM_READ_ONLY, &imageFormatDesc, 1,
maxDimension, 2, 0, 0, NULL, &error);
if ((streams == NULL) || (error != CL_SUCCESS))
{
print_error(error, "Image 3D creation failed for maximum height");
return -1;
return TEST_FAIL;
}

return 0;
return TEST_PASS;
}


REGISTER_TEST(min_max_image_3d_depth)
{
int error;
size_t maxDimension;
clMemWrapper streams[1];
cl_image_format image_format_desc;
clMemWrapper streams;
cl_image_format imageFormatDesc;
cl_ulong maxAllocSize;

if (checkFor3DImageSupport(device))
{
/* Get the max 3d image depth */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d depth from device");

PASSIVE_REQUIRE_3D_IMAGE_SUPPORT(device)
test_failure_error_ret(maxDimension, 0,
"Missing 3d image support but "
"CL_DEVICE_IMAGE3D_MAX_DEPTH query did "
"not return 0",
TEST_FAIL);
return TEST_SKIPPED_ITSELF;
}

/* Just get any ol format to test with */
error = get_8_bit_image_format(context, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_READ_ONLY, 0, &image_format_desc);
CL_MEM_READ_ONLY, 0, &imageFormatDesc);
test_error(error, "Unable to obtain suitable image format to test with!");

/* Get the max 2d image width */
/* Get the max 3d image depth */
error = clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH,
sizeof(maxDimension), &maxDimension, NULL);
test_error(error, "Unable to get max image 3d depth from device");

if (maxDimension < 2048)
{
log_error(
"ERROR: Reported max image 3d depth is less than required! (%d)\n",
(int)maxDimension);
return -1;
log_error("ERROR: Reported max image 3d depth is less than "
"required! (%d)\n",
(int)maxDimension);
return TEST_FAIL;
}
log_info("Max reported depth is %zu.\n", maxDimension);

/* Verify we can use the format */
image_format_desc.image_channel_data_type = CL_UNORM_INT8;
image_format_desc.image_channel_order = CL_RGBA;
imageFormatDesc.image_channel_data_type = CL_UNORM_INT8;
imageFormatDesc.image_channel_order = CL_RGBA;
if (!is_image_format_supported(context, CL_MEM_READ_ONLY,
CL_MEM_OBJECT_IMAGE3D, &image_format_desc))
CL_MEM_OBJECT_IMAGE3D, &imageFormatDesc))
{
log_error("CL_UNORM_INT8 CL_RGBA not supported. Can not test.");
return -1;
return TEST_FAIL;
}

/* Verify that we can actually allocate an image that large */
Expand All @@ -965,22 +1001,22 @@ REGISTER_TEST(min_max_image_3d_depth)
log_error("Can not allocate a large enough image (min size: %" PRIu64
" bytes, max allowed: %" PRIu64 " bytes) to test.\n",
(cl_ulong)maxDimension * 1 * 4, maxAllocSize);
return -1;
return TEST_FAIL;
}

log_info("Attempting to create an image of size 1 x 1 x %d = %gMB.\n",
(int)maxDimension, ((float)maxDimension * 4 / 1024.0 / 1024.0));

/* Try to allocate a very big image */
streams[0] = create_image_3d(context, CL_MEM_READ_ONLY, &image_format_desc,
1, 1, maxDimension, 0, 0, NULL, &error);
if ((streams[0] == NULL) || (error != CL_SUCCESS))
streams = create_image_3d(context, CL_MEM_READ_ONLY, &imageFormatDesc, 1, 1,
maxDimension, 0, 0, NULL, &error);
if ((streams == nullptr) || (error != CL_SUCCESS))
{
print_error(error, "Image 3D creation failed for maximum depth");
return -1;
return TEST_FAIL;
}

return 0;
return TEST_PASS;
}

REGISTER_TEST(min_max_image_array_size)
Expand Down
Loading