diff --git a/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp b/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp index 825c14c69e..efdf2b0106 100644 --- a/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp +++ b/test/conformance/enqueue/urEnqueueUSMMemAdvise.cpp @@ -11,7 +11,7 @@ UUR_TEST_SUITE_P(urEnqueueUSMMemAdviseWithParamTest, TEST_P(urEnqueueUSMMemAdviseWithParamTest, Success) { ur_event_handle_t advise_event = nullptr; - ASSERT_SUCCESS(urEnqueueUSMMemAdvise(queue, ptr, sizeof(int), + ASSERT_SUCCESS(urEnqueueUSMMemAdvise(queue, ptr, allocation_size, getParam(), &advise_event)); ASSERT_NE(advise_event, nullptr); @@ -31,19 +31,19 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMMemAdviseTest); TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullHandleQueue) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urEnqueueUSMMemAdvise(nullptr, ptr, sizeof(int), + urEnqueueUSMMemAdvise(nullptr, ptr, allocation_size, UR_MEM_ADVICE_DEFAULT, nullptr)); } TEST_P(urEnqueueUSMMemAdviseTest, InvalidNullPointerMem) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, - urEnqueueUSMMemAdvise(queue, nullptr, sizeof(int), + urEnqueueUSMMemAdvise(queue, nullptr, allocation_size, UR_MEM_ADVICE_DEFAULT, nullptr)); } TEST_P(urEnqueueUSMMemAdviseTest, InvalidEnumeration) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, - urEnqueueUSMMemAdvise(queue, ptr, sizeof(int), + urEnqueueUSMMemAdvise(queue, ptr, allocation_size, UR_MEM_ADVICE_FORCE_UINT32, nullptr)); } @@ -56,6 +56,6 @@ TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeZero) { TEST_P(urEnqueueUSMMemAdviseTest, InvalidSizeTooLarge) { ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, - urEnqueueUSMMemAdvise(queue, ptr, sizeof(int) * 2, + urEnqueueUSMMemAdvise(queue, ptr, allocation_size * 2, UR_MEM_ADVICE_DEFAULT, nullptr)); } diff --git a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp index 09e5c02adc..0b024af2da 100644 --- a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp +++ b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp @@ -1,2 +1,135 @@ // Copyright (C) 2023 Intel Corporation // SPDX-License-Identifier: MIT + +#include + +using urEnqueueUSMPrefetchWithParamTest = + uur::urUSMDeviceAllocTestWithParam; + +UUR_TEST_SUITE_P(urEnqueueUSMPrefetchWithParamTest, + ::testing::Values(UR_USM_MIGRATION_FLAG_DEFAULT), + uur::deviceTestWithParamPrinter); + +TEST_P(urEnqueueUSMPrefetchWithParamTest, Success) { + ur_event_handle_t prefetch_event = nullptr; + ASSERT_SUCCESS(urEnqueueUSMPrefetch(queue, ptr, allocation_size, + getParam(), 0, nullptr, + &prefetch_event)); + + ASSERT_SUCCESS(urQueueFlush(queue)); + ASSERT_SUCCESS(urEventWait(1, &prefetch_event)); + + const auto event_status = + uur::GetEventInfo(prefetch_event, + UR_EVENT_INFO_COMMAND_EXECUTION_STATUS); + ASSERT_TRUE(event_status.has_value()); + ASSERT_EQ(event_status.value(), UR_EVENT_STATUS_COMPLETE); + ASSERT_SUCCESS(urEventRelease(prefetch_event)); +} + +/** + * Tests that urEnqueueUSMPrefetch() waits for its dependencies to finish before + * executing. + */ +TEST_P(urEnqueueUSMPrefetchWithParamTest, CheckWaitEvent) { + + ur_queue_handle_t memset_queue; + ASSERT_SUCCESS(urQueueCreate(context, device, nullptr, &memset_queue)); + + size_t big_allocation = 65536; + void *memset_ptr = nullptr; + ASSERT_SUCCESS( + urUSMDeviceAlloc(context, device, nullptr, nullptr, + big_allocation, 0, &memset_ptr)); + + ur_event_handle_t memset_event; + ASSERT_SUCCESS( + urEnqueueUSMMemset(memset_queue, memset_ptr, 0, big_allocation, 0, + nullptr, &memset_event)); + + ur_event_handle_t prefetch_event = nullptr; + ASSERT_SUCCESS(urEnqueueUSMPrefetch(queue, ptr, allocation_size, + getParam(), 1, &memset_event, + &prefetch_event)); + + ASSERT_SUCCESS(urQueueFlush(queue)); + ASSERT_SUCCESS(urQueueFlush(memset_queue)); + ASSERT_SUCCESS(urEventWait(1, &prefetch_event)); + + const auto memset_status = + uur::GetEventInfo(memset_event, + UR_EVENT_INFO_COMMAND_EXECUTION_STATUS); + ASSERT_TRUE(memset_status.has_value()); + ASSERT_EQ(memset_status.value(), UR_EVENT_STATUS_COMPLETE); + + const auto event_status = + uur::GetEventInfo(prefetch_event, + UR_EVENT_INFO_COMMAND_EXECUTION_STATUS); + ASSERT_TRUE(event_status.has_value()); + ASSERT_EQ(event_status.value(), UR_EVENT_STATUS_COMPLETE); + + ASSERT_SUCCESS(urEventRelease(prefetch_event)); + ASSERT_SUCCESS(urEventRelease(memset_event)); + + ASSERT_SUCCESS(urUSMFree(context, memset_ptr)); +} + +using urEnqueueUSMPrefetchTest = uur::urUSMDeviceAllocTest; +UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMPrefetchTest); + +TEST_P(urEnqueueUSMPrefetchTest, InvalidNullHandleQueue) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, + urEnqueueUSMPrefetch(nullptr, ptr, allocation_size, + UR_USM_MIGRATION_FLAG_DEFAULT, 0, + nullptr, + nullptr)); +} + +TEST_P(urEnqueueUSMPrefetchTest, InvalidNullPointerMem) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER, + urEnqueueUSMPrefetch(queue, nullptr, allocation_size, + UR_USM_MIGRATION_FLAG_DEFAULT, 0, + nullptr, + nullptr)); +} + +TEST_P(urEnqueueUSMPrefetchTest, InvalidEnumeration) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, + urEnqueueUSMPrefetch(queue, ptr, allocation_size, + UR_USM_MIGRATION_FLAG_FORCE_UINT32, 0, + nullptr, + nullptr)); +} + +TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeZero) { + ASSERT_EQ_RESULT( + UR_RESULT_ERROR_INVALID_SIZE, + urEnqueueUSMPrefetch(queue, ptr, 0, UR_USM_MIGRATION_FLAG_DEFAULT, 0, + nullptr, + nullptr)); +} + +TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeTooLarge) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, + urEnqueueUSMPrefetch(queue, ptr, allocation_size * 2, + UR_USM_MIGRATION_FLAG_DEFAULT, 0, + nullptr, + nullptr)); +} + +TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) { + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST, + urEnqueueUSMPrefetch(queue, ptr, allocation_size, + UR_USM_MIGRATION_FLAG_DEFAULT, 1, + nullptr, + nullptr)); + + ur_event_handle_t validEvent; + ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent)); + + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST, + urEnqueueUSMPrefetch(queue, ptr, allocation_size, + UR_USM_MIGRATION_FLAG_DEFAULT, 0, + &validEvent, + nullptr)); +} diff --git a/test/conformance/testing/uur/fixtures.h b/test/conformance/testing/uur/fixtures.h index 26ea706e20..34db6b2c60 100644 --- a/test/conformance/testing/uur/fixtures.h +++ b/test/conformance/testing/uur/fixtures.h @@ -343,10 +343,12 @@ struct urUSMDeviceAllocTest : urQueueTest { if (!device_usm.value()) { GTEST_SKIP() << "Device USM in not supported"; } - ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr, sizeof(int), 0, &ptr)); + ASSERT_SUCCESS(urUSMDeviceAlloc(context, device, nullptr, nullptr, + allocation_size, 0, &ptr)); ur_event_handle_t event = nullptr; ASSERT_SUCCESS( - urEnqueueUSMMemset(queue, ptr, 0, sizeof(int), 0, nullptr, &event)); + urEnqueueUSMMemset(queue, ptr, 0, allocation_size, 0, nullptr, + &event)); EXPECT_SUCCESS(urQueueFlush(queue)); ASSERT_SUCCESS(urEventWait(1, &event)); EXPECT_SUCCESS(urEventRelease(event)); @@ -357,6 +359,7 @@ struct urUSMDeviceAllocTest : urQueueTest { uur::urQueueTest::TearDown(); } + size_t allocation_size = sizeof(int); void *ptr = nullptr; }; @@ -371,10 +374,13 @@ struct urUSMDeviceAllocTestWithParam : urQueueTestWithParam { if (!device_sum.value()) { GTEST_SKIP() << "Device USM in not supported"; } - ASSERT_SUCCESS(urUSMDeviceAlloc(this->context, this->device, nullptr, nullptr, sizeof(int), 0, &ptr)); + ASSERT_SUCCESS( + urUSMDeviceAlloc(this->context, this->device, nullptr, nullptr, + allocation_size, 0, &ptr)); ur_event_handle_t event = nullptr; - ASSERT_SUCCESS(urEnqueueUSMMemset(this->queue, ptr, 0, sizeof(int), 0, - nullptr, &event)); + ASSERT_SUCCESS( + urEnqueueUSMMemset(this->queue, ptr, 0, allocation_size, 0, + nullptr, &event)); EXPECT_SUCCESS(urQueueFlush(this->queue)); ASSERT_SUCCESS(urEventWait(1, &event)); EXPECT_SUCCESS(urEventRelease(event)); @@ -385,6 +391,7 @@ struct urUSMDeviceAllocTestWithParam : urQueueTestWithParam { uur::urQueueTestWithParam::TearDown(); } + size_t allocation_size = sizeof(int); void *ptr = nullptr; };