From 6a44b93aec54740145b1ada5817bfe65da107ffa Mon Sep 17 00:00:00 2001 From: Martin Morrison-Grant Date: Thu, 7 Mar 2024 12:46:45 +0000 Subject: [PATCH 1/3] [CTS] Modify various urEnqueueMemBuffer* conformance tests to use parameterized fixtures. --- test/conformance/enqueue/helpers.h | 52 +++++++++++++ .../enqueue/urEnqueueMemBufferCopy.cpp | 28 ++++--- .../enqueue/urEnqueueMemBufferFill.cpp | 16 +--- .../enqueue/urEnqueueMemBufferMap.cpp | 76 +++++++++++++------ .../enqueue/urEnqueueMemBufferRead.cpp | 46 ++++++++--- .../enqueue/urEnqueueMemBufferWrite.cpp | 42 +++++++--- .../conformance/enqueue/urEnqueueMemUnmap.cpp | 47 +++++++++--- .../testing/include/uur/fixtures.h | 41 +++++----- 8 files changed, 252 insertions(+), 96 deletions(-) diff --git a/test/conformance/enqueue/helpers.h b/test/conformance/enqueue/helpers.h index 6fc8dfacba..714e002ea9 100644 --- a/test/conformance/enqueue/helpers.h +++ b/test/conformance/enqueue/helpers.h @@ -96,6 +96,58 @@ print2DTestString(const testing::TestParamInfo &info) { return test_name.str(); } +struct mem_buffer_test_parameters_t { + size_t count; + ur_mem_flag_t mem_flag; +}; + +struct mem_buffer_map_write_test_parameters_t { + size_t count; + ur_mem_flag_t mem_flag; + ur_map_flag_t map_flag; +}; + +template +inline std::string printMemBufferTestString( + const testing::TestParamInfo &info) { + // ParamType will be std::tuple + const auto device_handle = std::get<0>(info.param); + const auto platform_device_name = GetPlatformAndDeviceName(device_handle); + + std::stringstream ss; + ss << std::get<1>(info.param).count; + ss << "_"; + ss << std::get<1>(info.param).mem_flag; + + return platform_device_name + "__" + ss.str(); +} + +template +inline std::string printMemBufferMapWriteTestString( + const testing::TestParamInfo &info) { + // ParamType will be std::tuple + const auto device_handle = std::get<0>(info.param); + const auto platform_device_name = GetPlatformAndDeviceName(device_handle); + + std::stringstream ss; + ss << std::get<1>(info.param).map_flag; + + return platform_device_name + "__" + ss.str(); +} + +template +inline std::string +printFillTestString(const testing::TestParamInfo &info) { + const auto device_handle = std::get<0>(info.param); + const auto platform_device_name = + uur::GetPlatformAndDeviceName(device_handle); + std::stringstream test_name; + test_name << platform_device_name << "__size__" + << std::get<1>(info.param).size << "__patternSize__" + << std::get<1>(info.param).pattern_size; + return test_name.str(); +} + } // namespace uur #endif // UUR_ENQUEUE_RECT_HELPERS_H_INCLUDED diff --git a/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp b/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp index fb51f789d2..ad73d4aa69 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp @@ -3,11 +3,12 @@ // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include -struct urEnqueueMemBufferCopyTest : uur::urQueueTest { +struct urEnqueueMemBufferCopyTestWithParam : uur::urQueueTestWithParam { void SetUp() override { - UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp()); + UUR_RETURN_ON_FATAL_FAILURE(urQueueTestWithParam::SetUp()); ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_WRITE_ONLY, size, nullptr, &src_buffer)); ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_ONLY, size, @@ -25,18 +26,23 @@ struct urEnqueueMemBufferCopyTest : uur::urQueueTest { if (src_buffer) { EXPECT_SUCCESS(urMemRelease(dst_buffer)); } - urQueueTest::TearDown(); + urQueueTestWithParam::TearDown(); } - const size_t count = 1024; + const size_t count = std::get<1>(this->GetParam()); const size_t size = sizeof(uint32_t) * count; ur_mem_handle_t src_buffer = nullptr; ur_mem_handle_t dst_buffer = nullptr; std::vector input; }; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferCopyTest); -TEST_P(urEnqueueMemBufferCopyTest, Success) { +static std::vector test_parameters{1024, 2500, 4096, 6000}; + +UUR_TEST_SUITE_P(urEnqueueMemBufferCopyTestWithParam, + ::testing::ValuesIn(test_parameters), + uur::deviceTestWithParamPrinter); + +TEST_P(urEnqueueMemBufferCopyTestWithParam, Success) { ASSERT_SUCCESS(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0, size, 0, nullptr, nullptr)); std::vector output(count, 1); @@ -45,25 +51,25 @@ TEST_P(urEnqueueMemBufferCopyTest, Success) { ASSERT_EQ(input, output); } -TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleQueue) { +TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleQueue) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferCopy(nullptr, src_buffer, dst_buffer, 0, 0, size, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleBufferSrc) { +TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleBufferSrc) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferCopy(queue, nullptr, dst_buffer, 0, 0, size, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleBufferDst) { +TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleBufferDst) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferCopy(queue, src_buffer, nullptr, 0, 0, size, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferCopyTest, InvalidNullPtrEventWaitList) { +TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullPtrEventWaitList) { ASSERT_EQ_RESULT(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0, size, 1, nullptr, nullptr), UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST); @@ -83,7 +89,7 @@ TEST_P(urEnqueueMemBufferCopyTest, InvalidNullPtrEventWaitList) { ASSERT_SUCCESS(urEventRelease(validEvent)); } -TEST_P(urEnqueueMemBufferCopyTest, InvalidSize) { +TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidSize) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 1, 0, size, 0, nullptr, nullptr)); diff --git a/test/conformance/enqueue/urEnqueueMemBufferFill.cpp b/test/conformance/enqueue/urEnqueueMemBufferFill.cpp index 0ca75c45b9..f4c8caabc9 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferFill.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferFill.cpp @@ -2,6 +2,7 @@ // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include struct testParametersFill { @@ -9,19 +10,6 @@ struct testParametersFill { size_t pattern_size; }; -template -inline std::string -printFillTestString(const testing::TestParamInfo &info) { - const auto device_handle = std::get<0>(info.param); - const auto platform_device_name = - uur::GetPlatformAndDeviceName(device_handle); - std::stringstream test_name; - test_name << platform_device_name << "__size__" - << std::get<1>(info.param).size << "__patternSize__" - << std::get<1>(info.param).pattern_size; - return test_name.str(); -} - struct urEnqueueMemBufferFillTest : uur::urQueueTestWithParam { void SetUp() override { @@ -76,7 +64,7 @@ static std::vector test_cases{ {256, 32}}; UUR_TEST_SUITE_P(urEnqueueMemBufferFillTest, testing::ValuesIn(test_cases), - printFillTestString); + uur::printFillTestString); TEST_P(urEnqueueMemBufferFillTest, Success) { ASSERT_SUCCESS(urEnqueueMemBufferFill(queue, buffer, pattern.data(), diff --git a/test/conformance/enqueue/urEnqueueMemBufferMap.cpp b/test/conformance/enqueue/urEnqueueMemBufferMap.cpp index 4e9af10592..7fc848a0ef 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferMap.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferMap.cpp @@ -2,12 +2,36 @@ // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include -using urEnqueueMemBufferMapTest = uur::urMemBufferQueueTest; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferMapTest); - -TEST_P(urEnqueueMemBufferMapTest, SuccessRead) { +using urEnqueueMemBufferMapTestWithParam = + uur::urMemBufferQueueTestWithParam; + +static std::vector test_parameters{ + {1024, UR_MEM_FLAG_READ_WRITE}, + {2500, UR_MEM_FLAG_READ_WRITE}, + {4096, UR_MEM_FLAG_READ_WRITE}, + {6000, UR_MEM_FLAG_READ_WRITE}, + {1024, UR_MEM_FLAG_WRITE_ONLY}, + {2500, UR_MEM_FLAG_WRITE_ONLY}, + {4096, UR_MEM_FLAG_WRITE_ONLY}, + {6000, UR_MEM_FLAG_WRITE_ONLY}, + {1024, UR_MEM_FLAG_READ_ONLY}, + {2500, UR_MEM_FLAG_READ_ONLY}, + {4096, UR_MEM_FLAG_READ_ONLY}, + {6000, UR_MEM_FLAG_READ_ONLY}, + {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, +}; + +UUR_TEST_SUITE_P( + urEnqueueMemBufferMapTestWithParam, ::testing::ValuesIn(test_parameters), + uur::printMemBufferTestString); + +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessRead) { const std::vector input(count, 42); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); @@ -21,12 +45,20 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessRead) { } } +static std::vector + map_write_test_parameters{ + {8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE}, + {8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE_INVALIDATE_REGION}, + }; + using urEnqueueMemBufferMapTestWithWriteFlagParam = - uur::urMemBufferQueueTestWithParam; + uur::urMemBufferQueueTestWithParam< + uur::mem_buffer_map_write_test_parameters_t>; + UUR_TEST_SUITE_P(urEnqueueMemBufferMapTestWithWriteFlagParam, - ::testing::Values(UR_MAP_FLAG_WRITE, - UR_MAP_FLAG_WRITE_INVALIDATE_REGION), - uur::deviceTestWithParamPrinter); + ::testing::ValuesIn(map_write_test_parameters), + uur::printMemBufferMapWriteTestString< + urEnqueueMemBufferMapTestWithWriteFlagParam>); TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) { const std::vector input(count, 0); @@ -34,9 +66,9 @@ TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) { input.data(), 0, nullptr, nullptr)); uint32_t *map = nullptr; - ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, getParam(), 0, - size, 0, nullptr, nullptr, - (void **)&map)); + ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, + getParam().map_flag, 0, size, 0, + nullptr, nullptr, (void **)&map)); for (unsigned i = 0; i < count; ++i) { map[i] = 42; } @@ -49,7 +81,7 @@ TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) { } } -TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) { +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessOffset) { const std::vector input(count, 0); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); @@ -78,7 +110,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) { } } -TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) { +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessPartialMap) { const std::vector input(count, 0); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); @@ -106,7 +138,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) { } } -TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) { +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedRead) { const size_t memSize = sizeof(int); const int value = 20; @@ -130,7 +162,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) { ASSERT_SUCCESS(urMemRelease(memObj)); } -TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) { +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedWrite) { const size_t memSize = sizeof(int); const int value = 30; @@ -157,7 +189,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) { ASSERT_SUCCESS(urMemRelease(memObj)); } -TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) { +TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessMultiMaps) { const std::vector input(count, 0); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); @@ -198,7 +230,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) { } } -TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleQueue) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleQueue) { void *map = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferMap(nullptr, buffer, true, @@ -206,7 +238,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleQueue) { 0, size, 0, nullptr, nullptr, &map)); } -TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleBuffer) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleBuffer) { void *map = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferMap(queue, nullptr, true, @@ -214,7 +246,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleBuffer) { 0, size, 0, nullptr, nullptr, &map)); } -TEST_P(urEnqueueMemBufferMapTest, InvalidEnumerationMapFlags) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidEnumerationMapFlags) { void *map = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urEnqueueMemBufferMap(queue, buffer, true, @@ -222,7 +254,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidEnumerationMapFlags) { nullptr, nullptr, &map)); } -TEST_P(urEnqueueMemBufferMapTest, InvalidNullPointerRetMap) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPointerRetMap) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, urEnqueueMemBufferMap(queue, buffer, true, UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE, @@ -230,7 +262,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullPointerRetMap) { nullptr)); } -TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPtrEventWaitList) { void *map; ASSERT_EQ_RESULT(urEnqueueMemBufferMap(queue, buffer, true, UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE, @@ -255,7 +287,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) { ASSERT_SUCCESS(urEventRelease(validEvent)); } -TEST_P(urEnqueueMemBufferMapTest, InvalidSize) { +TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidSize) { void *map = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urEnqueueMemBufferMap(queue, buffer, true, 0, 1, size, 0, diff --git a/test/conformance/enqueue/urEnqueueMemBufferRead.cpp b/test/conformance/enqueue/urEnqueueMemBufferRead.cpp index fa3c2ec4a4..70f4b5370b 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferRead.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferRead.cpp @@ -2,18 +2,42 @@ // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include -using urEnqueueMemBufferReadTest = uur::urMemBufferQueueTest; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferReadTest); - -TEST_P(urEnqueueMemBufferReadTest, Success) { +using urEnqueueMemBufferReadTestWithParam = + uur::urMemBufferQueueTestWithParam; + +static std::vector test_parameters{ + {1024, UR_MEM_FLAG_READ_WRITE}, + {2500, UR_MEM_FLAG_READ_WRITE}, + {4096, UR_MEM_FLAG_READ_WRITE}, + {6000, UR_MEM_FLAG_READ_WRITE}, + {1024, UR_MEM_FLAG_WRITE_ONLY}, + {2500, UR_MEM_FLAG_WRITE_ONLY}, + {4096, UR_MEM_FLAG_WRITE_ONLY}, + {6000, UR_MEM_FLAG_WRITE_ONLY}, + {1024, UR_MEM_FLAG_READ_ONLY}, + {2500, UR_MEM_FLAG_READ_ONLY}, + {4096, UR_MEM_FLAG_READ_ONLY}, + {6000, UR_MEM_FLAG_READ_ONLY}, + {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, +}; + +UUR_TEST_SUITE_P( + urEnqueueMemBufferReadTestWithParam, ::testing::ValuesIn(test_parameters), + uur::printMemBufferTestString); + +TEST_P(urEnqueueMemBufferReadTestWithParam, Success) { std::vector output(count, 42); ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, buffer, true, 0, size, output.data(), 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferReadTest, InvalidNullHandleQueue) { +TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullHandleQueue) { std::vector output(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferRead(nullptr, buffer, true, 0, size, @@ -21,7 +45,7 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidNullHandleQueue) { nullptr)); } -TEST_P(urEnqueueMemBufferReadTest, InvalidNullHandleBuffer) { +TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullHandleBuffer) { std::vector output(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferRead(queue, nullptr, true, 0, size, @@ -29,14 +53,14 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidNullHandleBuffer) { nullptr)); } -TEST_P(urEnqueueMemBufferReadTest, InvalidNullPointerDst) { +TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullPointerDst) { std::vector output(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, urEnqueueMemBufferRead(queue, buffer, true, 0, size, nullptr, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferReadTest, InvalidNullPtrEventWaitList) { +TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullPtrEventWaitList) { std::vector output(count, 42); ASSERT_EQ_RESULT(urEnqueueMemBufferRead(queue, buffer, true, 0, size, output.data(), 1, nullptr, nullptr), @@ -59,7 +83,7 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidNullPtrEventWaitList) { ASSERT_SUCCESS(urEventRelease(validEvent)); } -TEST_P(urEnqueueMemBufferReadTest, InvalidSize) { +TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidSize) { std::vector output(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urEnqueueMemBufferRead(queue, buffer, true, 1, size, @@ -67,7 +91,7 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidSize) { nullptr)); } -TEST_P(urEnqueueMemBufferReadTest, Blocking) { +TEST_P(urEnqueueMemBufferReadTestWithParam, Blocking) { constexpr const size_t memSize = 10u; constexpr const size_t bytes = memSize * sizeof(int); const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; @@ -93,7 +117,7 @@ TEST_P(urEnqueueMemBufferReadTest, Blocking) { } } -TEST_P(urEnqueueMemBufferReadTest, NonBlocking) { +TEST_P(urEnqueueMemBufferReadTestWithParam, NonBlocking) { constexpr const size_t memSize = 10u; constexpr const size_t bytes = memSize * sizeof(int); const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; diff --git a/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp b/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp index 27ceefa3d1..c64be4c5db 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp @@ -2,18 +2,42 @@ // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include -using urEnqueueMemBufferWriteTest = uur::urMemBufferQueueTest; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferWriteTest); +using urEnqueueMemBufferWriteTestWithParam = + uur::urMemBufferQueueTestWithParam; -TEST_P(urEnqueueMemBufferWriteTest, Success) { +static std::vector test_parameters{ + {1024, UR_MEM_FLAG_READ_WRITE}, + {2500, UR_MEM_FLAG_READ_WRITE}, + {4096, UR_MEM_FLAG_READ_WRITE}, + {6000, UR_MEM_FLAG_READ_WRITE}, + {1024, UR_MEM_FLAG_WRITE_ONLY}, + {2500, UR_MEM_FLAG_WRITE_ONLY}, + {4096, UR_MEM_FLAG_WRITE_ONLY}, + {6000, UR_MEM_FLAG_WRITE_ONLY}, + {1024, UR_MEM_FLAG_READ_ONLY}, + {2500, UR_MEM_FLAG_READ_ONLY}, + {4096, UR_MEM_FLAG_READ_ONLY}, + {6000, UR_MEM_FLAG_READ_ONLY}, + {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, +}; + +UUR_TEST_SUITE_P( + urEnqueueMemBufferWriteTestWithParam, ::testing::ValuesIn(test_parameters), + uur::printMemBufferTestString); + +TEST_P(urEnqueueMemBufferWriteTestWithParam, Success) { std::vector input(count, 42); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferWriteTest, SuccessWriteRead) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, SuccessWriteRead) { std::vector input(count, 42); ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 0, nullptr, nullptr)); @@ -25,7 +49,7 @@ TEST_P(urEnqueueMemBufferWriteTest, SuccessWriteRead) { } } -TEST_P(urEnqueueMemBufferWriteTest, InvalidNullHandleQueue) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullHandleQueue) { std::vector input(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferWrite(nullptr, buffer, true, 0, size, @@ -33,7 +57,7 @@ TEST_P(urEnqueueMemBufferWriteTest, InvalidNullHandleQueue) { nullptr)); } -TEST_P(urEnqueueMemBufferWriteTest, InvalidNullHandleBuffer) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullHandleBuffer) { std::vector input(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemBufferWrite(queue, nullptr, true, 0, size, @@ -41,14 +65,14 @@ TEST_P(urEnqueueMemBufferWriteTest, InvalidNullHandleBuffer) { nullptr)); } -TEST_P(urEnqueueMemBufferWriteTest, InvalidNullPointerSrc) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullPointerSrc) { std::vector input(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, urEnqueueMemBufferWrite(queue, buffer, true, 0, size, nullptr, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemBufferWriteTest, InvalidNullPtrEventWaitList) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullPtrEventWaitList) { std::vector input(count, 42); ASSERT_EQ_RESULT(urEnqueueMemBufferWrite(queue, buffer, true, 0, size, input.data(), 1, nullptr, nullptr), @@ -71,7 +95,7 @@ TEST_P(urEnqueueMemBufferWriteTest, InvalidNullPtrEventWaitList) { ASSERT_SUCCESS(urEventRelease(validEvent)); } -TEST_P(urEnqueueMemBufferWriteTest, InvalidSize) { +TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidSize) { std::vector output(count, 42); ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urEnqueueMemBufferWrite(queue, buffer, true, 1, size, diff --git a/test/conformance/enqueue/urEnqueueMemUnmap.cpp b/test/conformance/enqueue/urEnqueueMemUnmap.cpp index a669ee26e3..bf6ed77b85 100644 --- a/test/conformance/enqueue/urEnqueueMemUnmap.cpp +++ b/test/conformance/enqueue/urEnqueueMemUnmap.cpp @@ -2,45 +2,74 @@ // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions. // See LICENSE.TXT // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +#include "helpers.h" #include -struct urEnqueueMemUnmapTest : public uur::urMemBufferQueueTest { +struct urEnqueueMemUnmapTestWithParam + : uur::urMemBufferQueueTestWithParam { void SetUp() override { - UUR_RETURN_ON_FATAL_FAILURE(uur::urMemBufferQueueTest::SetUp()); + UUR_RETURN_ON_FATAL_FAILURE( + uur::urMemBufferQueueTestWithParam< + uur::mem_buffer_test_parameters_t>::SetUp()); ASSERT_SUCCESS(urEnqueueMemBufferMap( queue, buffer, true, UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE, 0, size, 0, nullptr, nullptr, (void **)&map)); }; - void TearDown() override { uur::urMemBufferQueueTest::TearDown(); } + void TearDown() override { + uur::urMemBufferQueueTestWithParam< + uur::mem_buffer_test_parameters_t>::TearDown(); + } uint32_t *map = nullptr; }; -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemUnmapTest); -TEST_P(urEnqueueMemUnmapTest, Success) { +static std::vector test_parameters{ + {1024, UR_MEM_FLAG_READ_WRITE}, + {2500, UR_MEM_FLAG_READ_WRITE}, + {4096, UR_MEM_FLAG_READ_WRITE}, + {6000, UR_MEM_FLAG_READ_WRITE}, + {1024, UR_MEM_FLAG_WRITE_ONLY}, + {2500, UR_MEM_FLAG_WRITE_ONLY}, + {4096, UR_MEM_FLAG_WRITE_ONLY}, + {6000, UR_MEM_FLAG_WRITE_ONLY}, + {1024, UR_MEM_FLAG_READ_ONLY}, + {2500, UR_MEM_FLAG_READ_ONLY}, + {4096, UR_MEM_FLAG_READ_ONLY}, + {6000, UR_MEM_FLAG_READ_ONLY}, + {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, +}; + +UUR_TEST_SUITE_P(urEnqueueMemUnmapTestWithParam, + ::testing::ValuesIn(test_parameters), + uur::printMemBufferTestString); + +TEST_P(urEnqueueMemUnmapTestWithParam, Success) { ASSERT_SUCCESS(urEnqueueMemUnmap(queue, buffer, map, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemUnmapTest, InvalidNullHandleQueue) { +TEST_P(urEnqueueMemUnmapTestWithParam, InvalidNullHandleQueue) { ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemUnmap(nullptr, buffer, map, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemUnmapTest, InvalidNullHandleMem) { +TEST_P(urEnqueueMemUnmapTestWithParam, InvalidNullHandleMem) { ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_NULL_HANDLE, urEnqueueMemUnmap(queue, nullptr, map, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemUnmapTest, InvalidNullPtrMap) { +TEST_P(urEnqueueMemUnmapTestWithParam, InvalidNullPtrMap) { ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_NULL_POINTER, urEnqueueMemUnmap(queue, buffer, nullptr, 0, nullptr, nullptr)); } -TEST_P(urEnqueueMemUnmapTest, InvalidNullPtrEventWaitList) { +TEST_P(urEnqueueMemUnmapTestWithParam, InvalidNullPtrEventWaitList) { ASSERT_EQ_RESULT(urEnqueueMemUnmap(queue, buffer, map, 1, nullptr, nullptr), UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST); diff --git a/test/conformance/testing/include/uur/fixtures.h b/test/conformance/testing/include/uur/fixtures.h index 794a29ac14..7767640b3d 100644 --- a/test/conformance/testing/include/uur/fixtures.h +++ b/test/conformance/testing/include/uur/fixtures.h @@ -379,6 +379,27 @@ template struct urQueueTestWithParam : urContextTestWithParam { ur_queue_handle_t queue; }; +template +struct urMemBufferQueueTestWithParam : urQueueTestWithParam { + void SetUp() override { + UUR_RETURN_ON_FATAL_FAILURE(urQueueTestWithParam::SetUp()); + ASSERT_SUCCESS( + urMemBufferCreate(this->context, mem_flag, size, nullptr, &buffer)); + } + + void TearDown() override { + if (buffer) { + EXPECT_SUCCESS(urMemRelease(buffer)); + } + UUR_RETURN_ON_FATAL_FAILURE(urQueueTestWithParam::TearDown()); + } + + const size_t count = this->getParam().count; + const size_t size = sizeof(uint32_t) * count; + ur_mem_handle_t buffer = nullptr; + ur_mem_flag_t mem_flag = this->getParam().mem_flag; +}; + struct urProfilingQueueTest : urContextTest { void SetUp() override { UUR_RETURN_ON_FATAL_FAILURE(urContextTest::SetUp()); @@ -526,26 +547,6 @@ struct urMemBufferQueueTest : urQueueTest { ur_mem_handle_t buffer = nullptr; }; -template -struct urMemBufferQueueTestWithParam : urQueueTestWithParam { - void SetUp() override { - UUR_RETURN_ON_FATAL_FAILURE(uur::urQueueTestWithParam::SetUp()); - ASSERT_SUCCESS(urMemBufferCreate(this->context, UR_MEM_FLAG_READ_WRITE, - size, nullptr, &buffer)); - } - - void TearDown() override { - if (buffer) { - EXPECT_SUCCESS(urMemRelease(buffer)); - } - UUR_RETURN_ON_FATAL_FAILURE(uur::urQueueTestWithParam::TearDown()); - } - - const size_t count = 8; - const size_t size = sizeof(uint32_t) * count; - ur_mem_handle_t buffer = nullptr; -}; - struct urMemImageQueueTest : urQueueTest { void SetUp() override { UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp()); From c9813081e5cb5e5e8551dc5f5c074770397c781d Mon Sep 17 00:00:00 2001 From: Martin Grant Date: Wed, 27 Mar 2024 15:54:54 +0000 Subject: [PATCH 2/3] Update test/conformance/enqueue/helpers.h Co-authored-by: aarongreig --- test/conformance/enqueue/helpers.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/conformance/enqueue/helpers.h b/test/conformance/enqueue/helpers.h index 714e002ea9..275a13e458 100644 --- a/test/conformance/enqueue/helpers.h +++ b/test/conformance/enqueue/helpers.h @@ -110,7 +110,7 @@ struct mem_buffer_map_write_test_parameters_t { template inline std::string printMemBufferTestString( const testing::TestParamInfo &info) { - // ParamType will be std::tuple + // ParamType will be std::tuple const auto device_handle = std::get<0>(info.param); const auto platform_device_name = GetPlatformAndDeviceName(device_handle); From 21015afb92a09b8ad42831bac4e3d8a5e97e47f9 Mon Sep 17 00:00:00 2001 From: Martin Morrison-Grant Date: Wed, 27 Mar 2024 16:05:13 +0000 Subject: [PATCH 3/3] [CTS] Move duplicated mem buffer parameters values into helpers header. --- test/conformance/enqueue/helpers.h | 19 ++++++++++++++++ .../enqueue/urEnqueueMemBufferMap.cpp | 22 ++----------------- .../enqueue/urEnqueueMemBufferRead.cpp | 22 ++----------------- .../enqueue/urEnqueueMemBufferWrite.cpp | 22 ++----------------- .../conformance/enqueue/urEnqueueMemUnmap.cpp | 21 +----------------- 5 files changed, 26 insertions(+), 80 deletions(-) diff --git a/test/conformance/enqueue/helpers.h b/test/conformance/enqueue/helpers.h index 275a13e458..03b34135a7 100644 --- a/test/conformance/enqueue/helpers.h +++ b/test/conformance/enqueue/helpers.h @@ -101,6 +101,25 @@ struct mem_buffer_test_parameters_t { ur_mem_flag_t mem_flag; }; +static std::vector mem_buffer_test_parameters{ + {1024, UR_MEM_FLAG_READ_WRITE}, + {2500, UR_MEM_FLAG_READ_WRITE}, + {4096, UR_MEM_FLAG_READ_WRITE}, + {6000, UR_MEM_FLAG_READ_WRITE}, + {1024, UR_MEM_FLAG_WRITE_ONLY}, + {2500, UR_MEM_FLAG_WRITE_ONLY}, + {4096, UR_MEM_FLAG_WRITE_ONLY}, + {6000, UR_MEM_FLAG_WRITE_ONLY}, + {1024, UR_MEM_FLAG_READ_ONLY}, + {2500, UR_MEM_FLAG_READ_ONLY}, + {4096, UR_MEM_FLAG_READ_ONLY}, + {6000, UR_MEM_FLAG_READ_ONLY}, + {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, + {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, +}; + struct mem_buffer_map_write_test_parameters_t { size_t count; ur_mem_flag_t mem_flag; diff --git a/test/conformance/enqueue/urEnqueueMemBufferMap.cpp b/test/conformance/enqueue/urEnqueueMemBufferMap.cpp index 7fc848a0ef..06b348e218 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferMap.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferMap.cpp @@ -8,27 +8,9 @@ using urEnqueueMemBufferMapTestWithParam = uur::urMemBufferQueueTestWithParam; -static std::vector test_parameters{ - {1024, UR_MEM_FLAG_READ_WRITE}, - {2500, UR_MEM_FLAG_READ_WRITE}, - {4096, UR_MEM_FLAG_READ_WRITE}, - {6000, UR_MEM_FLAG_READ_WRITE}, - {1024, UR_MEM_FLAG_WRITE_ONLY}, - {2500, UR_MEM_FLAG_WRITE_ONLY}, - {4096, UR_MEM_FLAG_WRITE_ONLY}, - {6000, UR_MEM_FLAG_WRITE_ONLY}, - {1024, UR_MEM_FLAG_READ_ONLY}, - {2500, UR_MEM_FLAG_READ_ONLY}, - {4096, UR_MEM_FLAG_READ_ONLY}, - {6000, UR_MEM_FLAG_READ_ONLY}, - {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, -}; - UUR_TEST_SUITE_P( - urEnqueueMemBufferMapTestWithParam, ::testing::ValuesIn(test_parameters), + urEnqueueMemBufferMapTestWithParam, + ::testing::ValuesIn(uur::mem_buffer_test_parameters), uur::printMemBufferTestString); TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessRead) { diff --git a/test/conformance/enqueue/urEnqueueMemBufferRead.cpp b/test/conformance/enqueue/urEnqueueMemBufferRead.cpp index 70f4b5370b..5c36ffc11c 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferRead.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferRead.cpp @@ -8,27 +8,9 @@ using urEnqueueMemBufferReadTestWithParam = uur::urMemBufferQueueTestWithParam; -static std::vector test_parameters{ - {1024, UR_MEM_FLAG_READ_WRITE}, - {2500, UR_MEM_FLAG_READ_WRITE}, - {4096, UR_MEM_FLAG_READ_WRITE}, - {6000, UR_MEM_FLAG_READ_WRITE}, - {1024, UR_MEM_FLAG_WRITE_ONLY}, - {2500, UR_MEM_FLAG_WRITE_ONLY}, - {4096, UR_MEM_FLAG_WRITE_ONLY}, - {6000, UR_MEM_FLAG_WRITE_ONLY}, - {1024, UR_MEM_FLAG_READ_ONLY}, - {2500, UR_MEM_FLAG_READ_ONLY}, - {4096, UR_MEM_FLAG_READ_ONLY}, - {6000, UR_MEM_FLAG_READ_ONLY}, - {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, -}; - UUR_TEST_SUITE_P( - urEnqueueMemBufferReadTestWithParam, ::testing::ValuesIn(test_parameters), + urEnqueueMemBufferReadTestWithParam, + ::testing::ValuesIn(uur::mem_buffer_test_parameters), uur::printMemBufferTestString); TEST_P(urEnqueueMemBufferReadTestWithParam, Success) { diff --git a/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp b/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp index c64be4c5db..c5ac53f14a 100644 --- a/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp +++ b/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp @@ -8,27 +8,9 @@ using urEnqueueMemBufferWriteTestWithParam = uur::urMemBufferQueueTestWithParam; -static std::vector test_parameters{ - {1024, UR_MEM_FLAG_READ_WRITE}, - {2500, UR_MEM_FLAG_READ_WRITE}, - {4096, UR_MEM_FLAG_READ_WRITE}, - {6000, UR_MEM_FLAG_READ_WRITE}, - {1024, UR_MEM_FLAG_WRITE_ONLY}, - {2500, UR_MEM_FLAG_WRITE_ONLY}, - {4096, UR_MEM_FLAG_WRITE_ONLY}, - {6000, UR_MEM_FLAG_WRITE_ONLY}, - {1024, UR_MEM_FLAG_READ_ONLY}, - {2500, UR_MEM_FLAG_READ_ONLY}, - {4096, UR_MEM_FLAG_READ_ONLY}, - {6000, UR_MEM_FLAG_READ_ONLY}, - {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, -}; - UUR_TEST_SUITE_P( - urEnqueueMemBufferWriteTestWithParam, ::testing::ValuesIn(test_parameters), + urEnqueueMemBufferWriteTestWithParam, + ::testing::ValuesIn(uur::mem_buffer_test_parameters), uur::printMemBufferTestString); TEST_P(urEnqueueMemBufferWriteTestWithParam, Success) { diff --git a/test/conformance/enqueue/urEnqueueMemUnmap.cpp b/test/conformance/enqueue/urEnqueueMemUnmap.cpp index bf6ed77b85..41b604abeb 100644 --- a/test/conformance/enqueue/urEnqueueMemUnmap.cpp +++ b/test/conformance/enqueue/urEnqueueMemUnmap.cpp @@ -24,27 +24,8 @@ struct urEnqueueMemUnmapTestWithParam uint32_t *map = nullptr; }; -static std::vector test_parameters{ - {1024, UR_MEM_FLAG_READ_WRITE}, - {2500, UR_MEM_FLAG_READ_WRITE}, - {4096, UR_MEM_FLAG_READ_WRITE}, - {6000, UR_MEM_FLAG_READ_WRITE}, - {1024, UR_MEM_FLAG_WRITE_ONLY}, - {2500, UR_MEM_FLAG_WRITE_ONLY}, - {4096, UR_MEM_FLAG_WRITE_ONLY}, - {6000, UR_MEM_FLAG_WRITE_ONLY}, - {1024, UR_MEM_FLAG_READ_ONLY}, - {2500, UR_MEM_FLAG_READ_ONLY}, - {4096, UR_MEM_FLAG_READ_ONLY}, - {6000, UR_MEM_FLAG_READ_ONLY}, - {1024, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {2500, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {4096, UR_MEM_FLAG_ALLOC_HOST_POINTER}, - {6000, UR_MEM_FLAG_ALLOC_HOST_POINTER}, -}; - UUR_TEST_SUITE_P(urEnqueueMemUnmapTestWithParam, - ::testing::ValuesIn(test_parameters), + ::testing::ValuesIn(uur::mem_buffer_test_parameters), uur::printMemBufferTestString); TEST_P(urEnqueueMemUnmapTestWithParam, Success) {