From 918d561c6c42fb7f3e2ffe1d1574c0c37bb2b15b Mon Sep 17 00:00:00 2001 From: Michael Rizkalla Date: Tue, 19 Nov 2024 18:11:58 +0000 Subject: [PATCH] Refactor test copy from and to image to buffer (#2138) This change refactors the following files: 1. test_imagearraycopy.cpp 2. test_arrayimagecopy.cpp The purpose of refactoring is to allow passing different buffer and image flags to the test function as well as passing customisable test functions. Signed-off-by: Michael Rizkalla --- .../basic/test_arrayimagecopy.cpp | 115 +++++++++------- .../basic/test_imagearraycopy.cpp | 126 ++++++++++-------- 2 files changed, 141 insertions(+), 100 deletions(-) diff --git a/test_conformance/basic/test_arrayimagecopy.cpp b/test_conformance/basic/test_arrayimagecopy.cpp index 906070d0..b0322ed5 100644 --- a/test_conformance/basic/test_arrayimagecopy.cpp +++ b/test_conformance/basic/test_arrayimagecopy.cpp @@ -22,16 +22,22 @@ #include #include #include +#include #include "procs.h" +using test_function_t = int (*)(cl_device_id, cl_context, cl_command_queue, + cl_mem_flags, cl_mem_flags, cl_mem_object_type, + const cl_image_format *); + int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, cl_command_queue queue, - cl_mem_flags flags, + cl_mem_flags buffer_flags, + cl_mem_flags image_flags, cl_mem_object_type image_type, const cl_image_format *format) { - cl_uchar *bufptr, *imgptr; + std::unique_ptr bufptr, imgptr; clMemWrapper buffer, image; int img_width = 512; int img_height = 512; @@ -40,62 +46,78 @@ int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, size_t buffer_size; cl_int err; cl_event copyevent; + RandomSeed seed(gRandomSeed); log_info("Testing %s %s\n", GetChannelOrderName(format->image_channel_order), GetChannelTypeName(format->image_channel_data_type)); - if (CL_MEM_OBJECT_IMAGE2D == image_type) - { - image = create_image_2d(context, flags, format, img_width, img_height, - 0, nullptr, &err); - } - else - { - image = create_image_3d(context, flags, format, img_width, img_height, - img_depth, 0, 0, nullptr, &err); - } - test_error(err, "create_image_xd failed"); - - err = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), - &elem_size, NULL); - test_error(err, "clGetImageInfo failed"); + elem_size = get_pixel_size(format); buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height * img_depth; - buffer = - clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, NULL, &err); - test_error(err, "clCreateBuffer failed"); + if (image_flags & CL_MEM_USE_HOST_PTR || image_flags & CL_MEM_COPY_HOST_PTR) + { + imgptr.reset(static_cast( + create_random_data(kUChar, seed, buffer_size))); + } - RandomSeed seed(gRandomSeed); - bufptr = - static_cast(create_random_data(kUChar, seed, buffer_size)); + bufptr.reset( + static_cast(create_random_data(kUChar, seed, buffer_size))); + + if (CL_MEM_OBJECT_IMAGE2D == image_type) + { + image = create_image_2d(context, image_flags, format, img_width, + img_height, 0, imgptr.get(), &err); + } + else + { + image = + create_image_3d(context, image_flags, format, img_width, img_height, + img_depth, 0, 0, imgptr.get(), &err); + } + test_error(err, "create_image_xd failed"); + + if (buffer_flags & CL_MEM_USE_HOST_PTR + || buffer_flags & CL_MEM_COPY_HOST_PTR) + { + buffer = clCreateBuffer(context, buffer_flags, buffer_size, + bufptr.get(), &err); + test_error(err, "clCreateBuffer failed"); + } + else + { + buffer = + clCreateBuffer(context, buffer_flags, buffer_size, nullptr, &err); + test_error(err, "clCreateBuffer failed"); + + err = clEnqueueWriteBuffer(queue, buffer, CL_TRUE, 0, buffer_size, + bufptr.get(), 0, nullptr, nullptr); + test_error(err, "clEnqueueWriteBuffer failed"); + } size_t origin[3] = { 0, 0, 0 }, region[3] = { img_width, img_height, img_depth }; - err = clEnqueueWriteBuffer(queue, buffer, CL_TRUE, 0, buffer_size, bufptr, - 0, NULL, NULL); - test_error(err, "clEnqueueWriteBuffer failed"); err = clEnqueueCopyBufferToImage(queue, buffer, image, 0, origin, region, 0, - NULL, ©event); + nullptr, ©event); test_error(err, "clEnqueueCopyImageToBuffer failed"); - imgptr = static_cast(malloc(buffer_size)); + imgptr.reset(static_cast(malloc(buffer_size))); err = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0, - imgptr, 1, ©event, NULL); + imgptr.get(), 1, ©event, nullptr); test_error(err, "clEnqueueReadImage failed"); err = clReleaseEvent(copyevent); test_error(err, "clReleaseEvent failed"); - if (memcmp(bufptr, imgptr, buffer_size) != 0) + if (memcmp(bufptr.get(), imgptr.get(), buffer_size) != 0) { log_error("ERROR: Results did not validate!\n"); - auto inchar = static_cast(bufptr); - auto outchar = static_cast(imgptr); + auto inchar = static_cast(bufptr.get()); + auto outchar = static_cast(imgptr.get()); int failuresPrinted = 0; for (int i = 0; i < (int)buffer_size; i += (int)elem_size) { @@ -119,9 +141,6 @@ int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, err = -1; } - free(bufptr); - free(imgptr); - if (err) log_error( "ARRAY to IMAGE copy test failed for image_channel_order=0x%lx and " @@ -134,26 +153,28 @@ int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, int test_arrayimagecommon(cl_device_id device, cl_context context, - cl_command_queue queue, cl_mem_flags flags, - cl_mem_object_type image_type) + cl_command_queue queue, cl_mem_flags buffer_flags, + cl_mem_flags image_flags, + cl_mem_object_type image_type, + test_function_t test_function) { cl_int err; cl_uint num_formats; - err = clGetSupportedImageFormats(context, flags, image_type, 0, NULL, - &num_formats); + err = clGetSupportedImageFormats(context, image_flags, image_type, 0, + nullptr, &num_formats); test_error(err, "clGetSupportedImageFormats failed"); std::vector formats(num_formats); - err = clGetSupportedImageFormats(context, flags, image_type, num_formats, - formats.data(), NULL); + err = clGetSupportedImageFormats(context, image_flags, image_type, + num_formats, formats.data(), nullptr); test_error(err, "clGetSupportedImageFormats failed"); for (const auto &format : formats) { - err |= test_arrayimagecopy_single_format(device, context, queue, flags, - image_type, &format); + err |= test_function(device, context, queue, buffer_flags, image_flags, + image_type, &format); } if (err) @@ -172,7 +193,8 @@ int test_arrayimagecopy(cl_device_id device, cl_context context, PASSIVE_REQUIRE_IMAGE_SUPPORT(device) return test_arrayimagecommon(device, context, queue, CL_MEM_READ_WRITE, - CL_MEM_OBJECT_IMAGE2D); + CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D, + test_arrayimagecopy_single_format); } @@ -181,6 +203,7 @@ int test_arrayimagecopy3d(cl_device_id device, cl_context context, { PASSIVE_REQUIRE_3D_IMAGE_SUPPORT(device) - return test_arrayimagecommon(device, context, queue, CL_MEM_READ_ONLY, - CL_MEM_OBJECT_IMAGE3D); + return test_arrayimagecommon(device, context, queue, CL_MEM_READ_WRITE, + CL_MEM_READ_ONLY, CL_MEM_OBJECT_IMAGE3D, + test_arrayimagecopy_single_format); } diff --git a/test_conformance/basic/test_imagearraycopy.cpp b/test_conformance/basic/test_imagearraycopy.cpp index 0ba2ea52..abd33236 100644 --- a/test_conformance/basic/test_imagearraycopy.cpp +++ b/test_conformance/basic/test_imagearraycopy.cpp @@ -22,15 +22,22 @@ #include #include #include +#include #include "procs.h" +using test_function_t = int (*)(cl_device_id, cl_context, cl_command_queue, + cl_mem_flags, cl_mem_flags, cl_mem_object_type, + const cl_image_format *); + int test_imagearraycopy_single_format(cl_device_id device, cl_context context, cl_command_queue queue, - cl_mem_flags flags, + cl_mem_flags image_flags, + cl_mem_flags buffer_flags, cl_mem_object_type image_type, const cl_image_format *format) { + std::unique_ptr bufptr, imgptr; clMemWrapper buffer, image; const int img_width = 512; const int img_height = 512; @@ -39,53 +46,63 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, size_t buffer_size; cl_int err; cl_event copyevent; + RandomSeed seed(gRandomSeed); + + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, img_depth }; log_info("Testing %s %s\n", GetChannelOrderName(format->image_channel_order), GetChannelTypeName(format->image_channel_data_type)); - if (CL_MEM_OBJECT_IMAGE2D == image_type) - { - image = create_image_2d(context, flags, format, img_width, img_height, - 0, nullptr, &err); - } - else - { - image = create_image_3d(context, flags, format, img_width, img_height, - img_depth, 0, 0, nullptr, &err); - } - test_error(err, "create_image_xd failed"); - - err = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), - &elem_size, nullptr); - test_error(err, "clGetImageInfo failed"); - + elem_size = get_pixel_size(format); buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height * img_depth; - buffer = - clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, nullptr, &err); + if (image_flags & CL_MEM_USE_HOST_PTR || image_flags & CL_MEM_COPY_HOST_PTR) + { + imgptr.reset(static_cast( + create_random_data(kUChar, seed, buffer_size))); + } + + bufptr.reset( + static_cast(create_random_data(kUChar, seed, buffer_size))); + + if (CL_MEM_OBJECT_IMAGE2D == image_type) + { + image = create_image_2d(context, image_flags, format, img_width, + img_height, 0, imgptr.get(), &err); + } + else + { + image = + create_image_3d(context, image_flags, format, img_width, img_height, + img_depth, 0, 0, imgptr.get(), &err); + } + test_error(err, "create_image_xd failed"); + + if (!(image_flags & CL_MEM_USE_HOST_PTR + || image_flags & CL_MEM_COPY_HOST_PTR)) + { + imgptr.reset(static_cast( + create_random_data(kUChar, seed, buffer_size))); + + err = clEnqueueWriteImage(queue, image, CL_TRUE, origin, region, 0, 0, + imgptr.get(), 0, nullptr, nullptr); + test_error(err, "clEnqueueWriteImage failed"); + } + + buffer = clCreateBuffer(context, buffer_flags, buffer_size, nullptr, &err); test_error(err, "clCreateBuffer failed"); - - RandomSeed seed(gRandomSeed); - cl_uchar *imgptr = - static_cast(create_random_data(kUChar, seed, buffer_size)); - - const size_t origin[3] = { 0, 0, 0 }, - region[3] = { img_width, img_height, img_depth }; - err = clEnqueueWriteImage(queue, image, CL_TRUE, origin, region, 0, 0, - imgptr, 0, nullptr, nullptr); - test_error(err, "clEnqueueWriteImage failed"); - err = clEnqueueCopyImageToBuffer(queue, image, buffer, origin, region, 0, 0, nullptr, ©event); test_error(err, "clEnqueueCopyImageToBuffer failed"); - cl_uchar *bufptr = static_cast(malloc(buffer_size)); + bufptr.reset(static_cast(malloc(buffer_size))); - err = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, buffer_size, bufptr, 1, - ©event, nullptr); + err = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, buffer_size, + bufptr.get(), 1, ©event, nullptr); test_error(err, "clEnqueueReadBuffer failed"); err = clReleaseEvent(copyevent); @@ -94,14 +111,14 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, image_descriptor compareImageInfo = { 0 }; compareImageInfo.format = format; compareImageInfo.width = buffer_size / get_pixel_size(format); - size_t where = compare_scanlines(&compareImageInfo, - reinterpret_cast(imgptr), - reinterpret_cast(bufptr)); + size_t where = compare_scanlines( + &compareImageInfo, reinterpret_cast(imgptr.get()), + reinterpret_cast(bufptr.get())); if (where < compareImageInfo.width) { log_error("ERROR: Results did not validate!\n"); - auto inchar = static_cast(imgptr); - auto outchar = static_cast(bufptr); + auto inchar = static_cast(imgptr.get()); + auto outchar = static_cast(bufptr.get()); int failuresPrinted = 0; for (size_t i = 0; i < buffer_size; i += elem_size) { @@ -125,9 +142,6 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, err = -1; } - free(imgptr); - free(bufptr); - if (err) log_error( "IMAGE to ARRAY copy test failed for image_channel_order=0x%lx and " @@ -139,33 +153,35 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, } int test_imagearraycommon(cl_device_id device, cl_context context, - cl_command_queue queue, cl_mem_flags flags, - cl_mem_object_type image_type) + cl_command_queue queue, cl_mem_flags image_flags, + cl_mem_flags buffer_flags, + cl_mem_object_type image_type, + test_function_t test_function) { cl_int err; cl_uint num_formats; - err = clGetSupportedImageFormats(context, flags, image_type, 0, nullptr, - &num_formats); + err = clGetSupportedImageFormats(context, image_flags, image_type, 0, + nullptr, &num_formats); test_error(err, "clGetSupportedImageFormats failed"); std::vector formats(num_formats); - err = clGetSupportedImageFormats(context, flags, image_type, num_formats, - formats.data(), nullptr); + err = clGetSupportedImageFormats(context, image_flags, image_type, + num_formats, formats.data(), nullptr); test_error(err, "clGetSupportedImageFormats failed"); for (const auto &format : formats) { - err |= test_imagearraycopy_single_format(device, context, queue, flags, - image_type, &format); + err |= test_function(device, context, queue, image_flags, buffer_flags, + image_type, &format); } if (err) - log_error("ARRAY to IMAGE%s copy test failed\n", + log_error("IMAGE%s to ARRAY copy test failed\n", convert_image_type_to_string(image_type)); else - log_info("ARRAY to IMAGE%s copy test passed\n", + log_info("IMAGE%s to ARRAY copy test passed\n", convert_image_type_to_string(image_type)); return err; @@ -177,7 +193,8 @@ int test_imagearraycopy(cl_device_id device, cl_context context, PASSIVE_REQUIRE_IMAGE_SUPPORT(device) return test_imagearraycommon(device, context, queue, CL_MEM_READ_WRITE, - CL_MEM_OBJECT_IMAGE2D); + CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D, + test_imagearraycopy_single_format); } @@ -187,5 +204,6 @@ int test_imagearraycopy3d(cl_device_id device, cl_context context, PASSIVE_REQUIRE_3D_IMAGE_SUPPORT(device) return test_imagearraycommon(device, context, queue, CL_MEM_READ_ONLY, - CL_MEM_OBJECT_IMAGE3D); -} \ No newline at end of file + CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE3D, + test_imagearraycopy_single_format); +}