From 185c02a70093faac6f0461c362ced663ee6791e0 Mon Sep 17 00:00:00 2001 From: Grzegorz Wawiorko Date: Tue, 18 Aug 2020 18:06:09 +0200 Subject: [PATCH] Test against clCreateBufferWithProperties and clCreateImageWithProperties OpenCL 3.0 API (#857) * Test against clCreateBufferWithProperties and clCreateImageWithProperties OpenCL 3.0 API * Test against clCreateBufferWithProperties and clCreateImageWithProperties - review fixes * Do not use enum query_type * Fix test success/failure conditions * Fix test_mem_object_properties_queries.cpp build error. * Review Fix test_mem_object_properties_queries.cpp --- test_conformance/api/CMakeLists.txt | 1 + test_conformance/api/main.cpp | 2 + test_conformance/api/procs.h | 8 + .../test_mem_object_properties_queries.cpp | 309 ++++++++++++++++++ 4 files changed, 320 insertions(+) create mode 100644 test_conformance/api/test_mem_object_properties_queries.cpp diff --git a/test_conformance/api/CMakeLists.txt b/test_conformance/api/CMakeLists.txt index 3d58ffb2..b3df9f79 100644 --- a/test_conformance/api/CMakeLists.txt +++ b/test_conformance/api/CMakeLists.txt @@ -28,6 +28,7 @@ set(${MODULE_NAME}_SOURCES test_clone_kernel.cpp test_zero_sized_enqueue.cpp test_context_destructor_callback.cpp + test_mem_object_properties_queries.cpp ) include(../CMakeCommon.txt) diff --git a/test_conformance/api/main.cpp b/test_conformance/api/main.cpp index 314b9de6..5eb42ab9 100644 --- a/test_conformance/api/main.cpp +++ b/test_conformance/api/main.cpp @@ -122,6 +122,8 @@ test_definition test_list[] = { ADD_TEST_VERSION(sub_group_dispatch, Version(2, 1)), ADD_TEST_VERSION(clone_kernel, Version(2, 1)), ADD_TEST_VERSION(zero_sized_enqueue, Version(2, 1)), + ADD_TEST_VERSION(buffer_properties_queries, Version(3, 0)), + ADD_TEST_VERSION(image_properties_queries, Version(3, 0)) }; const int test_num = ARRAY_SIZE(test_list); diff --git a/test_conformance/api/procs.h b/test_conformance/api/procs.h index b3a29515..15c6a257 100644 --- a/test_conformance/api/procs.h +++ b/test_conformance/api/procs.h @@ -121,3 +121,11 @@ extern int test_sub_group_dispatch(cl_device_id deviceID, cl_context contex extern int test_clone_kernel(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); extern int test_zero_sized_enqueue(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements); extern int test_queue_properties( cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements ); +extern int test_buffer_properties_queries(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); +extern int test_image_properties_queries(cl_device_id deviceID, + cl_context context, + cl_command_queue queue, + int num_elements); diff --git a/test_conformance/api/test_mem_object_properties_queries.cpp b/test_conformance/api/test_mem_object_properties_queries.cpp new file mode 100644 index 00000000..c38595cc --- /dev/null +++ b/test_conformance/api/test_mem_object_properties_queries.cpp @@ -0,0 +1,309 @@ +// +// Copyright (c) 2020 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include "testBase.h" +#include "harness/typeWrappers.h" +#include +#include + +typedef enum +{ + image, + buffer +} mem_obj_type; + +struct test_data +{ + mem_obj_type obj_t; + std::vector properties; + std::string description; + std::string src; + std::string kernel_name; +}; + +int create_object_and_check_properties(cl_context context, + clMemWrapper& test_object, + test_data test_case, cl_mem_flags flags, + std::vector local_data, + cl_uint size_x, cl_uint size_y) +{ + int error = CL_SUCCESS; + size_t set_size; + std::vector object_properties_check; + + + if (test_case.obj_t == image) + { + cl_image_format format; + format.image_channel_order = CL_RGBA; + format.image_channel_data_type = CL_UNSIGNED_INT32; + cl_image_desc desc; + memset(&desc, 0x0, sizeof(cl_image_desc)); + desc.image_type = CL_MEM_OBJECT_IMAGE2D; + desc.image_width = size_x; + desc.image_height = size_y; + + if (test_case.properties.size() == 0) + { + test_object = + clCreateImageWithProperties(context, NULL, flags, &format, + &desc, local_data.data(), &error); + } + else + { + test_object = clCreateImageWithProperties( + context, test_case.properties.data(), flags, &format, &desc, + local_data.data(), &error); + } + test_error(error, "clCreateImageWithProperties failed"); + } + if (test_case.obj_t == buffer) + { + if (test_case.properties.size() == 0) + { + test_object = clCreateBufferWithProperties( + context, NULL, flags, local_data.size() * sizeof(cl_uint), + local_data.data(), &error); + } + else + { + test_object = clCreateBufferWithProperties( + context, test_case.properties.data(), flags, + local_data.size() * sizeof(cl_uint), local_data.data(), &error); + } + + test_error(error, "clCreateBufferWithProperties failed."); + } + clGetMemObjectInfo(test_object, CL_MEM_PROPERTIES, 0, NULL, &set_size); + test_error(error, + "clGetMemObjectInfo failed asking for CL_MEM_PROPERTIES."); + + // verify set_size 0 returned + if (test_case.properties.size() == 0 && set_size == 0) + { + return TEST_PASS; + } + + cl_uint number_of_props = set_size / sizeof(cl_mem_properties); + object_properties_check.resize(number_of_props); + clGetMemObjectInfo(test_object, CL_MEM_PROPERTIES, set_size, + object_properties_check.data(), NULL); + test_error(error, + "clGetMemObjectInfo failed asking for CL_MEM_PROPERTIES."); + + // check list with 0 terminator is returned + if (object_properties_check.size() == 1 && object_properties_check[0] == 0 + && test_case.properties.size() == 0) + { + return TEST_PASS; + } + if (object_properties_check.back() != 0) + { + log_error("ERROR: Incorrect last properties value - should be 0!\n"); + return TEST_FAIL; + } + object_properties_check.pop_back(); + test_case.properties.pop_back(); + if (object_properties_check != test_case.properties) + { + for (cl_uint i = 0; i < test_case.properties.size(); i = i + 2) + { + cl_mem_properties set_property = test_case.properties[i]; + cl_mem_properties set_property_value = test_case.properties[i + 1]; + std::vector::iterator it = + std::find(object_properties_check.begin(), + object_properties_check.end(), set_property); + + if (it == object_properties_check.end()) + { + log_error("ERROR: Property not found ... 0x%x\n", set_property); + return TEST_FAIL; + } + else + { + if (set_property_value != *std::next(it)) + { + log_error("ERROR: Incorrect preperty value expected %x, " + "obtained %x\n", + set_property_value, *std::next(it)); + return TEST_FAIL; + } + } + } + log_error( + "ERROR: ALL properties and values matched but order incorrect!\n"); + return TEST_FAIL; + } + + return error; +} + +int run_test_query_properties(cl_context context, cl_command_queue queue, + test_data test_case) +{ + int error = CL_SUCCESS; + log_info("\nTC description: %s\n", test_case.description.c_str()); + + clProgramWrapper program; + clKernelWrapper kernel; + clMemWrapper obj_src; + clMemWrapper obj_dst; + clEventWrapper event; + MTdata init_generator = init_genrand(gRandomSeed); + cl_mem_flags flags; + cl_uint size_x = 4; + cl_uint size_y = 4; + size_t size = size_x * size_y * 4; + size_t global_dim[2] = { size_x, size_y }; + const size_t origin[3] = { 0, 0, 0 }; + const size_t region[3] = { size_x, size_y, 1 }; + + std::vector src_data(size); + std::vector dst_data(size); + + generate_random_data(kUInt, size, init_generator, src_data.data()); + generate_random_data(kUInt, size, init_generator, dst_data.data()); + free_mtdata(init_generator); + init_generator = NULL; + const char* kernel_src = test_case.src.c_str(); + error = + create_single_kernel_helper(context, &program, &kernel, 1, &kernel_src, + test_case.kernel_name.c_str()); + + test_error(error, "create_single_kernel_helper failed"); + + flags = (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR); + error = create_object_and_check_properties(context, obj_src, test_case, + flags, src_data, size_x, size_y); + test_error(error, "create_object_and_check_properties obj_src failed."); + + flags = (cl_mem_flags)(CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR); + error = create_object_and_check_properties(context, obj_dst, test_case, + flags, dst_data, size_x, size_y); + test_error(error, "create_object_and_check_properties obj_dst failed."); + + error = clSetKernelArg(kernel, 0, sizeof(obj_src), &obj_src); + test_error(error, "clSetKernelArg 0 failed."); + + error = clSetKernelArg(kernel, 1, sizeof(obj_dst), &obj_dst); + test_error(error, "clSetKernelArg 1 failed."); + if (test_case.obj_t == image) + { + error = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, global_dim, NULL, + 0, NULL, &event); + test_error(error, "clEnqueueNDRangeKernel failed."); + + error = clWaitForEvents(1, &event); + test_error(error, "clWaitForEvents failed."); + + error = clEnqueueReadImage(queue, obj_dst, CL_TRUE, origin, region, 0, + 0, dst_data.data(), 0, NULL, NULL); + test_error(error, "clEnqueueReadImage failed."); + } + if (test_case.obj_t == buffer) + { + error = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &size, NULL, 0, + NULL, &event); + test_error(error, "clEnqueueNDRangeKernel failed."); + + error = clWaitForEvents(1, &event); + test_error(error, "clWaitForEvents failed."); + + error = clEnqueueReadBuffer(queue, obj_dst, CL_TRUE, 0, + dst_data.size() * sizeof(cl_uint), + dst_data.data(), 0, NULL, NULL); + test_error(error, "clEnqueueReadBuffer failed."); + } + + for (size_t i = 0; i < size; ++i) + { + if (dst_data[i] != src_data[i]) + { + log_error("ERROR: Output results mismatch."); + return TEST_FAIL; + } + } + + log_info("TC result: passed\n"); + return TEST_PASS; +} + +int test_image_properties_queries(cl_device_id deviceID, cl_context context, + cl_command_queue queue, int num_elements) +{ + int error = CL_SUCCESS; + cl_bool supports_images = CL_TRUE; + + error = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, + sizeof(supports_images), &supports_images, NULL); + test_error(error, "clGetDeviceInfo for CL_DEVICE_IMAGE_SUPPORT failed"); + + if (supports_images == CL_FALSE) + { + log_info("No image support on current device - skipped\n"); + return TEST_SKIPPED_ITSELF; + } + + std::vector test_cases; + std::string test_kernel = { "__kernel void data_copy(read_only image2d_t " + "src, write_only image2d_t dst)\n" + "{\n" + " int tid_x = get_global_id(0);\n" + " int tid_y = get_global_id(1);\n" + " int2 coords = (int2)(tid_x, tid_y);\n" + " uint4 val = read_imageui(src, coords);\n" + " write_imageui(dst, coords, val);\n" + "\n" + "}\n" }; + test_cases.push_back( + { image, { 0 }, "image, 0 properties", test_kernel, "data_copy" }); + test_cases.push_back( + { image, {}, "image, NULL properties", test_kernel, "data_copy" }); + + for (auto test_case : test_cases) + { + error |= run_test_query_properties(context, queue, test_case); + } + + return error; +} + +int test_buffer_properties_queries(cl_device_id deviceID, cl_context context, + cl_command_queue queue, int num_elements) +{ + int error = CL_SUCCESS; + std::vector test_cases; + std::string test_kernel = { + "__kernel void data_copy(__global int *src, __global int *dst)\n" + "{\n" + " int tid = get_global_id(0);\n" + "\n" + " dst[tid] = src[tid];\n" + "\n" + "}\n" + }; + test_cases.push_back( + { buffer, { 0 }, "buffer, 0 properties", test_kernel, "data_copy" }); + test_cases.push_back( + { buffer, {}, "buffer, NULL properties", test_kernel, "data_copy" }); + + for (auto test_case : test_cases) + { + error |= run_test_query_properties(context, queue, test_case); + } + + return error; +}