From 560d6eafbdd95f35d708cf8463e1ec94972e0f94 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Jastrz=C4=99bski?= Date: Mon, 20 Feb 2023 09:36:34 +0100 Subject: [PATCH] Added tests for 1.1 individual command entry-points. (#1594) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Added tests for 1.1 individual command entry-points. * Adding fixes pointed out in review: checks for CL_DEVICE_IMAGE_SUPPORT, remove redundant buffers, synchronisation issues, fixed clang-format, other minor issues. * Fix compilation issues for Windows and macOS, fix clang-format. * Fix compilation issue for Windows. * Removed redundant blocking and event operations. * Style fixes for test skip conditions. * Fix clang format. * Fixed function names, file names, comments and barrier test. * Restored Individual command entry-points tests after merge with main. * Fix clang format. * Superficial fixes for review. * Fix Skip() condition for barrier test * Fix typos * Fix new line Signed-off-by: Paweł Jastrzębski --- .../cl_khr_command_buffer/CMakeLists.txt | 3 + .../command_buffer_test_barrier.cpp | 123 ++++++ .../command_buffer_test_copy.cpp | 394 ++++++++++++++++++ .../command_buffer_test_fill.cpp | 142 +++++++ .../extensions/cl_khr_command_buffer/main.cpp | 28 +- .../extensions/cl_khr_command_buffer/procs.h | 16 + 6 files changed, 697 insertions(+), 9 deletions(-) create mode 100644 test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp create mode 100644 test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp create mode 100644 test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp diff --git a/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt b/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt index 4ba6eeeb..fbf10b46 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt +++ b/test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt @@ -4,6 +4,9 @@ set(${MODULE_NAME}_SOURCES main.cpp basic_command_buffer.cpp command_buffer_queue_substitution.cpp + command_buffer_test_fill.cpp + command_buffer_test_copy.cpp + command_buffer_test_barrier.cpp ) include(../../CMakeCommon.txt) diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp new file mode 100644 index 00000000..d73fc9ce --- /dev/null +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp @@ -0,0 +1,123 @@ +// +// Copyright (c) 2022 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 "basic_command_buffer.h" +#include "procs.h" + +#include + + +namespace { + +//////////////////////////////////////////////////////////////////////////////// +// Command-bufer barrier tests which handles below cases: +// +// - barrier wait list + +struct BarrierWithWaitListKHR : public BasicCommandBufferTest +{ + + using BasicCommandBufferTest::BasicCommandBufferTest; + + BarrierWithWaitListKHR(cl_device_id device, cl_context context, + cl_command_queue queue) + : BasicCommandBufferTest(device, context, queue), + out_of_order_queue(nullptr), out_of_order_command_buffer(this), + event(nullptr) + {} + + cl_int Run() override + { + cl_int error = + clCommandFillBufferKHR(out_of_order_command_buffer, nullptr, in_mem, + &pattern, sizeof(cl_int), 0, data_size(), 0, + nullptr, &sync_points[0], nullptr); + test_error(error, "clCommandFillBufferKHR failed"); + + const cl_int overwritten_pattern = 0xACDC; + error = clCommandFillBufferKHR(out_of_order_command_buffer, nullptr, + out_mem, &overwritten_pattern, + sizeof(cl_int), 0, data_size(), 0, + nullptr, &sync_points[1], nullptr); + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandBarrierWithWaitListKHR(out_of_order_command_buffer, + nullptr, 2, sync_points, + nullptr, nullptr); + test_error(error, "clCommandBarrierWithWaitListKHR failed"); + + error = clCommandNDRangeKernelKHR( + out_of_order_command_buffer, nullptr, nullptr, kernel, 1, nullptr, + &num_elements, nullptr, 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandNDRangeKernelKHR failed"); + + error = clFinalizeCommandBufferKHR(out_of_order_command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR( + 0, nullptr, out_of_order_command_buffer, 0, nullptr, &event); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(num_elements); + error = clEnqueueReadBuffer(out_of_order_queue, out_mem, CL_TRUE, 0, + data_size(), output_data.data(), 1, &event, + nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < num_elements; i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + out_of_order_queue = clCreateCommandQueue( + context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &error); + test_error(error, "Unable to create command queue to test with"); + + out_of_order_command_buffer = + clCreateCommandBufferKHR(1, &out_of_order_queue, nullptr, &error); + test_error(error, "clCreateCommandBufferKHR failed"); + + return CL_SUCCESS; + } + + bool Skip() override + { + return BasicCommandBufferTest::Skip() || !out_of_order_support; + } + + const cl_int pattern = 0x16; + clCommandQueueWrapper out_of_order_queue; + clCommandBufferWrapper out_of_order_command_buffer; + clEventWrapper event; + cl_sync_point_khr sync_points[2]; + clEventWrapper user_event; +}; +}; + + +int test_barrier_wait_list(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp new file mode 100644 index 00000000..102ae761 --- /dev/null +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp @@ -0,0 +1,394 @@ +// +// Copyright (c) 2022 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 "basic_command_buffer.h" +#include "harness/typeWrappers.h" +#include "procs.h" + +#include + + +namespace { + +//////////////////////////////////////////////////////////////////////////////// +// Command-buffer copy tests which handles below cases: +// +// -copy image +// -copy buffer +// -copy buffer to image +// -copy image to buffer +// -copy buffer rect + +struct CopyImageKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = clCommandFillImageKHR(command_buffer, nullptr, src_image, + fill_color, origin, region, 0, + nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillImageKHR failed"); + + error = clCommandCopyImageKHR(command_buffer, nullptr, src_image, + dst_image, origin, origin, region, 0, 0, + nullptr, nullptr); + + test_error(error, "clCommandCopyImageKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size); + error = clEnqueueReadImage(queue, dst_image, CL_TRUE, origin, region, 0, + 0, output_data.data(), 0, nullptr, nullptr); + + for (size_t i = 0; i < data_size; i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + src_image = create_image_2d(context, CL_MEM_READ_ONLY, &formats, + img_width, img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + dst_image = create_image_2d(context, CL_MEM_WRITE_ONLY, &formats, + img_width, img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + return CL_SUCCESS; + } + + bool Skip() override + { + bool imageSupport = + checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED; + + return imageSupport || BasicCommandBufferTest::Skip(); + } + + const size_t img_width = 512; + const size_t img_height = 512; + const size_t data_size = img_width * img_height * 4 * sizeof(cl_char); + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + const cl_uint pattern = 0x05; + const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern }; + const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 }; + clMemWrapper src_image; + clMemWrapper dst_image; +}; + +struct CopyBufferKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0, + data_size(), 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandCopyBufferKHR(command_buffer, nullptr, in_mem, out_mem, + 0, 0, data_size(), 0, nullptr, nullptr, + nullptr); + test_error(error, "clCommandCopyBufferKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size()); + error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(), + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < data_size(); i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + const cl_char pattern = 0x14; +}; + +struct CopyBufferToImageKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, buffer, &pattern, sizeof(cl_char), 0, + data_size, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandCopyBufferToImageKHR(command_buffer, nullptr, buffer, + image, 0, origin, region, 0, 0, + nullptr, nullptr); + + test_error(error, "clCommandCopyBufferToImageKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size); + + error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0, + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadImage failed"); + + for (size_t i = 0; i < data_size; i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width, + img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr, + &error); + test_error(error, "Unable to create buffer"); + + return CL_SUCCESS; + } + + bool Skip() override + { + bool imageSupport = + checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED; + + return imageSupport || BasicCommandBufferTest::Skip(); + } + + const size_t img_width = 512; + const size_t img_height = 512; + const size_t data_size = img_width * img_height * 4 * sizeof(cl_char); + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + const cl_char pattern = 0x11; + const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 }; + + clMemWrapper buffer; + clMemWrapper image; +}; + +struct CopyImageToBufferKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = + clCommandFillImageKHR(command_buffer, nullptr, image, fill_color, + origin, region, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillImageKHR failed"); + + error = clCommandCopyImageToBufferKHR(command_buffer, nullptr, image, + buffer, origin, region, 0, 0, + nullptr, nullptr, nullptr); + + test_error(error, "clCommandCopyImageToBufferKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size); + + error = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, data_size, + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < data_size; i++) + { + CHECK_VERIFICATION_ERROR(static_cast(pattern), + output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width, + img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr, + &error); + test_error(error, "Unable to create buffer"); + + return CL_SUCCESS; + } + + bool Skip() override + { + bool imageSupport = + checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED; + + return imageSupport || BasicCommandBufferTest::Skip(); + } + + const size_t img_width = 512; + const size_t img_height = 512; + const size_t data_size = img_width * img_height * 4 * sizeof(cl_char); + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + const cl_uint pattern = 0x12; + const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern }; + const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 }; + + clMemWrapper image; + clMemWrapper buffer; +}; + +struct CopyBufferRectKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0, + data_size, 0, nullptr, nullptr, nullptr); + test_error(error, "clCommandFillBufferKHR failed"); + + error = clCommandCopyBufferRectKHR( + command_buffer, nullptr, in_mem, out_mem, origin, origin, region, 0, + 0, 0, 0, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandCopyBufferRectKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size); + error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size, + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < data_size; i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + in_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr, + &error); + test_error(error, "clCreateBuffer failed"); + + out_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr, + &error); + test_error(error, "Unable to create buffer"); + + return CL_SUCCESS; + } + + const size_t img_width = 512; + const size_t img_height = 512; + const size_t data_size = img_width * img_height * sizeof(cl_char); + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + const cl_char pattern = 0x13; + + clMemWrapper in_mem; + clMemWrapper out_mem; +}; +}; + +int test_copy_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, num_elements); +} + +int test_copy_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, num_elements); +} + +int test_copy_buffer_to_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +int test_copy_image_to_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} + +int test_copy_buffer_rect(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, + num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp new file mode 100644 index 00000000..88e97a27 --- /dev/null +++ b/test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp @@ -0,0 +1,142 @@ +// +// Copyright (c) 2022 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 "basic_command_buffer.h" +#include "harness/typeWrappers.h" +#include "procs.h" + +#include + + +namespace { + +//////////////////////////////////////////////////////////////////////////////// +// Command-buffer fill tests which handles below cases: +// +// -fill image +// -fill buffer + +struct FillImageKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = + clCommandFillImageKHR(command_buffer, nullptr, image, fill_color, + origin, region, 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillImageKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size); + error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0, + output_data.data(), 0, nullptr, nullptr); + + for (size_t i = 0; i < data_size; i++) + { + CHECK_VERIFICATION_ERROR(static_cast(pattern), + output_data[i], i); + } + + return CL_SUCCESS; + } + + cl_int SetUp(int elements) override + { + cl_int error = BasicCommandBufferTest::SetUp(elements); + test_error(error, "BasicCommandBufferTest::SetUp failed"); + + image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width, + img_height, 0, NULL, &error); + test_error(error, "create_image_2d failed"); + + return CL_SUCCESS; + } + + bool Skip() override + { + bool imageSupport = + checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED; + + return imageSupport || BasicCommandBufferTest::Skip(); + } + + const size_t img_width = 512; + const size_t img_height = 512; + const size_t data_size = img_width * img_height * 4 * sizeof(cl_char); + const size_t origin[3] = { 0, 0, 0 }, + region[3] = { img_width, img_height, 1 }; + const cl_uint pattern = 0x10; + const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern }; + const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 }; + + clMemWrapper image; +}; + +struct FillBufferKHR : public BasicCommandBufferTest +{ + using BasicCommandBufferTest::BasicCommandBufferTest; + + cl_int Run() override + { + cl_int error = clCommandFillBufferKHR( + command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0, + data_size(), 0, nullptr, nullptr, nullptr); + + test_error(error, "clCommandFillBufferKHR failed"); + + error = clFinalizeCommandBufferKHR(command_buffer); + test_error(error, "clFinalizeCommandBufferKHR failed"); + + error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, + nullptr, nullptr); + test_error(error, "clEnqueueCommandBufferKHR failed"); + + std::vector output_data(data_size()); + error = clEnqueueReadBuffer(queue, in_mem, CL_TRUE, 0, data_size(), + output_data.data(), 0, nullptr, nullptr); + test_error(error, "clEnqueueReadBuffer failed"); + + for (size_t i = 0; i < data_size(); i++) + { + CHECK_VERIFICATION_ERROR(pattern, output_data[i], i); + } + + return CL_SUCCESS; + } + + const char pattern = 0x15; +}; + +}; + +int test_fill_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, num_elements); +} + +int test_fill_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements) +{ + return MakeAndRunTest(device, context, queue, num_elements); +} diff --git a/test_conformance/extensions/cl_khr_command_buffer/main.cpp b/test_conformance/extensions/cl_khr_command_buffer/main.cpp index 338d4d4c..4d475a51 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/main.cpp +++ b/test_conformance/extensions/cl_khr_command_buffer/main.cpp @@ -15,15 +15,25 @@ #include "procs.h" #include "harness/testHarness.h" -test_definition test_list[] = { ADD_TEST(single_ndrange), - ADD_TEST(interleaved_enqueue), - ADD_TEST(mixed_commands), - ADD_TEST(explicit_flush), - ADD_TEST(user_events), - ADD_TEST(out_of_order), - ADD_TEST(queue_substitution), - ADD_TEST(properties_queue_substitution), - ADD_TEST(simultaneous_queue_substitution) }; +test_definition test_list[] = { + ADD_TEST(single_ndrange), + ADD_TEST(interleaved_enqueue), + ADD_TEST(mixed_commands), + ADD_TEST(explicit_flush), + ADD_TEST(user_events), + ADD_TEST(out_of_order), + ADD_TEST(queue_substitution), + ADD_TEST(properties_queue_substitution), + ADD_TEST(simultaneous_queue_substitution), + ADD_TEST(fill_image), + ADD_TEST(fill_buffer), + ADD_TEST(copy_image), + ADD_TEST(copy_buffer), + ADD_TEST(copy_buffer_to_image), + ADD_TEST(copy_image_to_buffer), + ADD_TEST(copy_buffer_rect), + ADD_TEST(barrier_wait_list), +}; int main(int argc, const char *argv[]) diff --git a/test_conformance/extensions/cl_khr_command_buffer/procs.h b/test_conformance/extensions/cl_khr_command_buffer/procs.h index f63d7847..a8911eef 100644 --- a/test_conformance/extensions/cl_khr_command_buffer/procs.h +++ b/test_conformance/extensions/cl_khr_command_buffer/procs.h @@ -41,6 +41,22 @@ extern int test_simultaneous_queue_substitution(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements); +extern int test_fill_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_fill_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_copy_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_copy_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_copy_buffer_to_image(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_copy_image_to_buffer(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_copy_buffer_rect(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); +extern int test_barrier_wait_list(cl_device_id device, cl_context context, + cl_command_queue queue, int num_elements); #endif /*_CL_KHR_COMMAND_BUFFER_PROCS_H*/