Merge pull request #1269 from npmiller/plugins-tests

[CTS] Initial port of old PI tests to UR CTS
oneapi-src · Jan 24, 2024 · 2352ec4 · 2352ec4
2 parents 5b3750d + 6eb886e
commit 2352ec4
Show file tree

Hide file tree

Showing 4 changed files with 140 additions and 21 deletions.
diff --git a/test/conformance/enqueue/urEnqueueMemBufferMap.cpp b/test/conformance/enqueue/urEnqueueMemBufferMap.cpp
@@ -99,6 +99,57 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
  }
 }
 
+TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
+ const size_t memSize = sizeof(int);
+ const int value = 20;
+
+ ur_mem_handle_t memObj;
+ ASSERT_SUCCESS(urMemBufferCreate(
+ context, UR_MEM_FLAG_READ_WRITE | UR_MEM_FLAG_ALLOC_HOST_POINTER,
+ memSize, nullptr, &memObj));
+
+ ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, true, 0, sizeof(int),
+ &value, 0, nullptr, nullptr));
+
+ int *host_ptr = nullptr;
+ ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, memObj, true, UR_MAP_FLAG_READ,
+ 0, sizeof(int), 0, nullptr, nullptr,
+ (void **)&host_ptr));
+
+ ASSERT_EQ(*host_ptr, value);
+ ASSERT_SUCCESS(
+ urEnqueueMemUnmap(queue, memObj, host_ptr, 0, nullptr, nullptr));
+
+ ASSERT_SUCCESS(urMemRelease(memObj));
+}
+
+TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
+ const size_t memSize = sizeof(int);
+ const int value = 30;
+
+ ur_mem_handle_t memObj;
+ ASSERT_SUCCESS(urMemBufferCreate(
+ context, UR_MEM_FLAG_READ_WRITE | UR_MEM_FLAG_ALLOC_HOST_POINTER,
+ memSize, nullptr, &memObj));
+
+ int *host_ptr = nullptr;
+ ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, memObj, true, UR_MAP_FLAG_WRITE,
+ 0, sizeof(int), 0, nullptr, nullptr,
+ (void **)&host_ptr));
+
+ *host_ptr = value;
+
+ ASSERT_SUCCESS(
+ urEnqueueMemUnmap(queue, memObj, host_ptr, 0, nullptr, nullptr));
+
+ int read_value = 0;
+ ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, true, 0, sizeof(int),
+ &read_value, 0, nullptr, nullptr));
+
+ ASSERT_EQ(read_value, value);
+ ASSERT_SUCCESS(urMemRelease(memObj));
+}
+
 TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
  const std::vector<uint32_t> input(count, 0);
  ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,

diff --git a/test/conformance/enqueue/urEnqueueMemBufferRead.cpp b/test/conformance/enqueue/urEnqueueMemBufferRead.cpp
@@ -65,6 +65,63 @@ TEST_P(urEnqueueMemBufferReadTest, InvalidSize) {
  nullptr));
 }
 
+TEST_P(urEnqueueMemBufferReadTest, 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};
+ int output[memSize] = {};
+
+ ur_mem_handle_t memObj;
+ ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, bytes,
+ nullptr, &memObj));
+
+ ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, true, 0, bytes, data,
+ 0, nullptr, nullptr));
+
+ ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, true, 0, bytes, output,
+ 0, nullptr, nullptr));
+
+ bool isSame =
+ std::equal(std::begin(output), std::end(output), std::begin(data));
+ EXPECT_TRUE(isSame);
+ if (!isSame) {
+ std::for_each(std::begin(output), std::end(output),
+ [](int &elem) { std::cout << elem << ","; });
+ std::cout << std::endl;
+ }
+}
+
+TEST_P(urEnqueueMemBufferReadTest, 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};
+ int output[memSize] = {};
+
+ ur_mem_handle_t memObj;
+ ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, bytes,
+ nullptr, &memObj));
+
+ ur_event_handle_t cpIn, cpOut;
+ ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, memObj, false, 0, bytes, data,
+ 0, nullptr, &cpIn));
+ ASSERT_NE(cpIn, nullptr);
+
+ ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, memObj, false, 0, bytes,
+ output, 0, nullptr, &cpOut));
+ ASSERT_NE(cpOut, nullptr);
+
+ ASSERT_SUCCESS(urEventWait(1, &cpOut));
+
+ bool isSame =
+ std::equal(std::begin(output), std::end(output), std::begin(data));
+ EXPECT_TRUE(isSame);
+ if (!isSame) {
+ std::for_each(std::begin(output), std::end(output),
+ [](int &elem) { std::cout << elem << ","; });
+ std::cout << std::endl;
+ }
+}
+
 using urEnqueueMemBufferReadMultiDeviceTest =
  uur::urMultiDeviceMemBufferQueueTest;
 

diff --git a/test/conformance/memory/memory_adapter_level_zero.match b/test/conformance/memory/memory_adapter_level_zero.match
@@ -1,4 +1,7 @@
-urMemBufferCreateTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_READ_WRITE
+urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_WRITE_ONLY
+urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_READ_ONLY
+urMemBufferCreateWithFlagsTest.InvalidBufferSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urMemBufferPartitionTest.InvalidBufferSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemBufferPartitionTest.InvalidValueCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_

diff --git a/test/conformance/memory/urMemBufferCreate.cpp b/test/conformance/memory/urMemBufferCreate.cpp
@@ -4,34 +4,42 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
 
-using urMemBufferCreateTest = uur::urContextTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemBufferCreateTest);
+using urMemBufferCreateTestWithFlagsParam =
+ uur::urContextTestWithParam<ur_mem_flag_t>;
 
-TEST_P(urMemBufferCreateTest, Success) {
+using urMemBufferCreateWithFlagsTest = urMemBufferCreateTestWithFlagsParam;
+UUR_TEST_SUITE_P(urMemBufferCreateWithFlagsTest,
+ ::testing::Values(UR_MEM_FLAG_READ_WRITE,
+ UR_MEM_FLAG_WRITE_ONLY,
+ UR_MEM_FLAG_READ_ONLY,
+ UR_MEM_FLAG_ALLOC_HOST_POINTER),
+ uur::deviceTestWithParamPrinter<ur_mem_flag_t>);
+
+TEST_P(urMemBufferCreateWithFlagsTest, Success) {
  ur_mem_handle_t buffer = nullptr;
- ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 4096,
-   nullptr, &buffer));
+ ASSERT_SUCCESS(
+ urMemBufferCreate(context, getParam(), 4096, nullptr, &buffer));
  ASSERT_NE(nullptr, buffer);
  ASSERT_SUCCESS(urMemRelease(buffer));
 }
 
-TEST_P(urMemBufferCreateTest, InvalidNullHandleContext) {
+TEST_P(urMemBufferCreateWithFlagsTest, InvalidNullHandleContext) {
  ur_mem_handle_t buffer = nullptr;
- ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
-  urMemBufferCreate(nullptr, UR_MEM_FLAG_READ_WRITE, 4096,
-   nullptr, &buffer));
+ ASSERT_EQ_RESULT(
+ UR_RESULT_ERROR_INVALID_NULL_HANDLE,
+ urMemBufferCreate(nullptr, getParam(), 4096, nullptr, &buffer));
 }
 
+using urMemBufferCreateTest = uur::urContextTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemBufferCreateTest);
+
 TEST_P(urMemBufferCreateTest, InvalidEnumerationFlags) {
  ur_mem_handle_t buffer = nullptr;
  ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
  urMemBufferCreate(context, UR_MEM_FLAG_FORCE_UINT32, 4096,
  nullptr, &buffer));
 }
 
-using urMemBufferCreateTestWithFlagsParam =
- uur::urContextTestWithParam<ur_mem_flag_t>;
-
 using urMemBufferCreateWithHostPtrFlagsTest =
  urMemBufferCreateTestWithFlagsParam;
 UUR_TEST_SUITE_P(urMemBufferCreateWithHostPtrFlagsTest,
@@ -46,15 +54,15 @@ TEST_P(urMemBufferCreateWithHostPtrFlagsTest, InvalidHostPtr) {
  urMemBufferCreate(context, getParam(), 4096, nullptr, &buffer));
 }
 
-TEST_P(urMemBufferCreateTest, InvalidNullPointerBuffer) {
- ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
-  urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 4096,
-   nullptr, nullptr));
+TEST_P(urMemBufferCreateWithFlagsTest, InvalidNullPointerBuffer) {
+ ASSERT_EQ_RESULT(
+ UR_RESULT_ERROR_INVALID_NULL_POINTER,
+ urMemBufferCreate(context, getParam(), 4096, nullptr, nullptr));
 }
 
-TEST_P(urMemBufferCreateTest, InvalidBufferSizeZero) {
+TEST_P(urMemBufferCreateWithFlagsTest, InvalidBufferSizeZero) {
  ur_mem_handle_t buffer = nullptr;
- ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_BUFFER_SIZE,
-  urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 0,
-   nullptr, &buffer));
+ ASSERT_EQ_RESULT(
+ UR_RESULT_ERROR_INVALID_BUFFER_SIZE,
+ urMemBufferCreate(context, getParam(), 0, nullptr, &buffer));
 }