From 6ce9402fc243b3e4667861735d0dbe76446346e4 Mon Sep 17 00:00:00 2001 From: Filip Hazubski Date: Wed, 11 Mar 2020 16:15:34 +0100 Subject: [PATCH] Return CL_INVALID_OPERATION error for enqueuing SVM operations The error code is returned if the associated device does not support SVM. Related-To: NEO-4368 Change-Id: I7c2300e05768e4acf541fa92bd94913de9b5eb81 Signed-off-by: Filip Hazubski --- opencl/source/api/api.cpp | 49 +++++++++++++++-- .../api/cl_enqueue_svm_free_tests.inl | 49 +++++++++++++---- .../api/cl_enqueue_svm_map_tests.inl | 49 +++++++++++++---- .../api/cl_enqueue_svm_mem_fill_tests.inl | 49 +++++++++++++---- .../api/cl_enqueue_svm_memcpy_tests.inl | 24 ++++++++ .../api/cl_enqueue_svm_migrate_mem_tests.cpp | 55 +++++++++++++++---- .../api/cl_enqueue_svm_unmap_tests.inl | 21 +++++++ .../api/cl_unified_shared_memory_tests.inl | 33 ++++++++++- 8 files changed, 277 insertions(+), 52 deletions(-) diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp index d6586cd49a..bc7f5ecbf2 100644 --- a/opencl/source/api/api.cpp +++ b/opencl/source/api/api.cpp @@ -4173,6 +4173,13 @@ cl_int CL_API_CALL clEnqueueSVMFree(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMFree, &retVal); + return retVal; + } + if (((svmPointers != nullptr) && (numSvmPointers == 0)) || ((svmPointers == nullptr) && (numSvmPointers != 0))) { retVal = CL_INVALID_VALUE; @@ -4225,6 +4232,13 @@ cl_int CL_API_CALL clEnqueueSVMMemcpy(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMMemcpy, &retVal); + return retVal; + } + if ((dstPtr == nullptr) || (srcPtr == nullptr)) { retVal = CL_INVALID_VALUE; TRACING_EXIT(clEnqueueSVMMemcpy, &retVal); @@ -4276,6 +4290,13 @@ cl_int CL_API_CALL clEnqueueSVMMemFill(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMMemFill, &retVal); + return retVal; + } + if ((svmPtr == nullptr) || (size == 0)) { retVal = CL_INVALID_VALUE; TRACING_EXIT(clEnqueueSVMMemFill, &retVal); @@ -4325,6 +4346,13 @@ cl_int CL_API_CALL clEnqueueSVMMap(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMMap, &retVal); + return retVal; + } + if ((svmPtr == nullptr) || (size == 0)) { retVal = CL_INVALID_VALUE; TRACING_EXIT(clEnqueueSVMMap, &retVal); @@ -4372,6 +4400,13 @@ cl_int CL_API_CALL clEnqueueSVMUnmap(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMUnmap, &retVal); + return retVal; + } + retVal = pCommandQueue->enqueueSVMUnmap( svmPtr, numEventsInWaitList, @@ -5027,6 +5062,13 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, return retVal; } + auto &device = pCommandQueue->getDevice(); + if (!device.getHardwareInfo().capabilityTable.ftrSvm) { + retVal = CL_INVALID_OPERATION; + TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); + return retVal; + } + if (numSvmPointers == 0 || svmPointers == nullptr) { retVal = CL_INVALID_VALUE; TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); @@ -5041,12 +5083,9 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue, TRACING_EXIT(clEnqueueSVMMigrateMem, &retVal); return retVal; } - auto pSvmAllocMgr = pCommandQueue->getContext().getSVMAllocsManager(); - if (pSvmAllocMgr == nullptr) { - retVal = CL_INVALID_VALUE; - return retVal; - } + auto pSvmAllocMgr = pCommandQueue->getContext().getSVMAllocsManager(); + UNRECOVERABLE_IF(pSvmAllocMgr == nullptr); for (uint32_t i = 0; i < numSvmPointers; i++) { auto svmData = pSvmAllocMgr->getSVMAlloc(svmPointers[i]); diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_free_tests.inl b/opencl/test/unit_test/api/cl_enqueue_svm_free_tests.inl index 5f122224e7..2b24f740a0 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_free_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_svm_free_tests.inl @@ -10,6 +10,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" #include "opencl/source/event/user_event.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" @@ -34,17 +35,20 @@ TEST_F(clEnqueueSVMFreeTests, GivenInvalidCommandQueueWhenFreeingSVMThenInvalidC } TEST_F(clEnqueueSVMFreeTests, GivenNonZeroNumOfSVMPointersAndNullSVMPointersWhenFreeingSVMThenInvalidValueErrorIsReturned) { - auto retVal = clEnqueueSVMFree( - pCommandQueue, // cl_command_queue command_queue - 1, // cl_uint num_svm_pointers - nullptr, // void *svm_pointers[] - nullptr, // (CL_CALLBACK *pfn_free_func) ( cl_command_queue queue, cl_uint num_svm_pointers, void *svm_pointers[]) - nullptr, // void *user_data - 0, // cl_uint num_events_in_wait_list - nullptr, // const cl_event *event_wait_list - nullptr // cl_event *event - ); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo(); + if (devInfo.svmCapabilities != 0) { + auto retVal = clEnqueueSVMFree( + pCommandQueue, // cl_command_queue command_queue + 1, // cl_uint num_svm_pointers + nullptr, // void *svm_pointers[] + nullptr, // (CL_CALLBACK *pfn_free_func) ( cl_command_queue queue, cl_uint num_svm_pointers, void *svm_pointers[]) + nullptr, // void *user_data + 0, // cl_uint num_events_in_wait_list + nullptr, // const cl_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + } } TEST_F(clEnqueueSVMFreeTests, GivenZeroNumOfSVMPointersAndNonNullSVMPointersWhenFreeingSVMThenInvalidValueErrorIsReturned) { @@ -139,4 +143,27 @@ TEST_F(clEnqueueSVMFreeTests, GivenZeroNumOfSVMPointersAndNullSVMPointersWhenFre EXPECT_EQ(CL_SUCCESS, retVal); } } + +TEST_F(clEnqueueSVMFreeTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMFreeThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + auto retVal = clEnqueueSVMFree( + pCommandQueue.get(), // cl_command_queue command_queue + 0, // cl_uint num_svm_pointers + nullptr, // void *svm_pointers[] + nullptr, // (CL_CALLBACK *pfn_free_func) ( cl_command_queue queue, cl_uint num_svm_pointers, void *svm_pointers[]) + nullptr, // void *user_data + 0, // cl_uint num_events_in_wait_list + nullptr, // const cl_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_map_tests.inl b/opencl/test/unit_test/api/cl_enqueue_svm_map_tests.inl index 22376f166a..8e022be0b7 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_map_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_svm_map_tests.inl @@ -9,6 +9,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" @@ -33,17 +34,20 @@ TEST_F(clEnqueueSVMMapTests, GivenInvalidCommandQueueWhenMappingSVMThenInvalidCo } TEST_F(clEnqueueSVMMapTests, GivenNullSVMPointerWhenMappingSVMThenInvalidValueErrorIsReturned) { - auto retVal = clEnqueueSVMMap( - pCommandQueue, // cl_command_queue command_queue - CL_FALSE, // cl_bool blocking_map - CL_MAP_READ, // cl_map_flags map_flags - nullptr, // void *svm_ptr - 256, // size_t size - 0, // cl_uint num_events_in_wait_list - nullptr, // const cL_event *event_wait_list - nullptr // cl_event *event - ); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo(); + if (devInfo.svmCapabilities != 0) { + auto retVal = clEnqueueSVMMap( + pCommandQueue, // cl_command_queue command_queue + CL_FALSE, // cl_bool blocking_map + CL_MAP_READ, // cl_map_flags map_flags + nullptr, // void *svm_ptr + 256, // size_t size + 0, // cl_uint num_events_in_wait_list + nullptr, // const cL_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + } } TEST_F(clEnqueueSVMMapTests, GivenRegionSizeZeroWhenMappingSVMThenInvalidValueErrorIsReturned) { @@ -119,4 +123,27 @@ TEST_F(clEnqueueSVMMapTests, GivenValidParametersWhenMappingSVMThenSuccessIsRetu clSVMFree(pContext, ptrSvm); } } + +TEST_F(clEnqueueSVMMapTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMMapThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + auto retVal = clEnqueueSVMMap( + pCommandQueue.get(), // cl_command_queue command_queue + CL_FALSE, // cl_bool blocking_map + CL_MAP_READ, // cl_map_flags map_flags + nullptr, // void *svm_ptr + 256, // size_t size + 0, // cl_uint num_events_in_wait_list + nullptr, // const cL_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_mem_fill_tests.inl b/opencl/test/unit_test/api/cl_enqueue_svm_mem_fill_tests.inl index 3f12757449..3a7baabf74 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_mem_fill_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_svm_mem_fill_tests.inl @@ -9,6 +9,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" @@ -33,17 +34,20 @@ TEST_F(clEnqueueSVMMemFillTests, GivenInvalidCommandQueueWhenFillingSVMMemoryThe } TEST_F(clEnqueueSVMMemFillTests, GivenNullSVMPtrWhenFillingSVMMemoryThenInvalidValueErrorIsReturned) { - auto retVal = clEnqueueSVMMemFill( - pCommandQueue, // cl_command_queue command_queue - nullptr, // void *svm_ptr - nullptr, // const void *pattern - 0, // size_t pattern_size - 256, // size_t size - 0, // cl_uint num_events_in_wait_list - nullptr, // cl_evebt *event_wait_list - nullptr // cL_event *event - ); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo(); + if (devInfo.svmCapabilities != 0) { + auto retVal = clEnqueueSVMMemFill( + pCommandQueue, // cl_command_queue command_queue + nullptr, // void *svm_ptr + nullptr, // const void *pattern + 0, // size_t pattern_size + 256, // size_t size + 0, // cl_uint num_events_in_wait_list + nullptr, // cl_evebt *event_wait_list + nullptr // cL_event *event + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + } } TEST_F(clEnqueueSVMMemFillTests, GivenRegionSizeZeroWhenFillingSVMMemoryThenInvalidValueErrorIsReturned) { @@ -119,4 +123,27 @@ TEST_F(clEnqueueSVMMemFillTests, GivenValidParametersWhenFillingSVMMemoryThenSuc clSVMFree(pContext, ptrSvm); } } + +TEST_F(clEnqueueSVMMemFillTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMMemFillThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + auto retVal = clEnqueueSVMMemFill( + pCommandQueue.get(), // cl_command_queue command_queue + nullptr, // void *svm_ptr + nullptr, // const void *pattern + 0, // size_t pattern_size + 256, // size_t size + 0, // cl_uint num_events_in_wait_list + nullptr, // cl_evebt *event_wait_list + nullptr // cL_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_memcpy_tests.inl b/opencl/test/unit_test/api/cl_enqueue_svm_memcpy_tests.inl index d5aac31579..67717bf718 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_memcpy_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_svm_memcpy_tests.inl @@ -9,6 +9,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" @@ -155,4 +156,27 @@ TEST_F(clEnqueueSVMMemcpyTests, GivenZeroSizeWhenCopyingSVMMemoryThenSuccessIsRe clSVMFree(pContext, pSrcSvm); } } + +TEST_F(clEnqueueSVMMemcpyTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMMemcpyThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + auto retVal = clEnqueueSVMMemcpy( + pCommandQueue.get(), // cl_command_queue command_queue + CL_FALSE, // cl_bool blocking_copy + nullptr, // void *dst_ptr + nullptr, // const void *src_ptr + 0, // size_t size + 0, // cl_uint num_events_in_wait_list + nullptr, // const cl_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_migrate_mem_tests.cpp b/opencl/test/unit_test/api/cl_enqueue_svm_migrate_mem_tests.cpp index 87b7ef91e3..6246266978 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_migrate_mem_tests.cpp +++ b/opencl/test/unit_test/api/cl_enqueue_svm_migrate_mem_tests.cpp @@ -12,9 +12,12 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/event/user_event.h" #include "opencl/test/unit_test/mocks/mock_context.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" +#include + using namespace NEO; typedef api_tests clEnqueueSVMMigrateMemTests; @@ -36,17 +39,20 @@ TEST_F(clEnqueueSVMMigrateMemTests, GivenInvalidCommandQueueWhenMigratingSVMThen } TEST_F(clEnqueueSVMMigrateMemTests, GivenNullSvmPointersWhenMigratingSvmThenInvalidValueErrorIsReturned) { - auto retVal = clEnqueueSVMMigrateMem( - pCommandQueue, // cl_command_queue command_queue - 1, // cl_uint num_svm_pointers - nullptr, // const void **svm_pointers - nullptr, // const size_t *sizes - 0, // const cl_mem_migration_flags flags - 0, // cl_uint num_events_in_wait_list - nullptr, // const cl_event *event_wait_list - nullptr // cl_event *event - ); - EXPECT_EQ(CL_INVALID_VALUE, retVal); + const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo(); + if (devInfo.svmCapabilities != 0) { + auto retVal = clEnqueueSVMMigrateMem( + pCommandQueue, // cl_command_queue command_queue + 1, // cl_uint num_svm_pointers + nullptr, // const void **svm_pointers + nullptr, // const size_t *sizes + 0, // const cl_mem_migration_flags flags + 0, // cl_uint num_events_in_wait_list + nullptr, // const cl_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_VALUE, retVal); + } } TEST_F(clEnqueueSVMMigrateMemTests, GivenNumSvmPointersIsZeroWhenMigratingSvmThenInvalidValueErrorIsReturned) { @@ -73,6 +79,10 @@ TEST_F(clEnqueueSVMMigrateMemTests, GivenNumSvmPointersIsZeroWhenMigratingSvmThe } TEST_F(clEnqueueSVMMigrateMemTests, GivenSvmPointerIsHostPtrWhenMigratingSvmThenInvalidValueErrorIsReturned) { + const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } char *ptrHost = new char[10]; ASSERT_NE(nullptr, ptrHost); @@ -296,4 +306,27 @@ TEST_F(clEnqueueSVMMigrateMemTests, GivenSameContextCommandQueueAndEventsWhenMig clSVMFree(pContext, ptrSvm); } } + +TEST_F(clEnqueueSVMMigrateMemTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMMigrateMemThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + auto retVal = clEnqueueSVMMigrateMem( + pCommandQueue.get(), // cl_command_queue command_queue + 1, // cl_uint num_svm_pointers + nullptr, // const void **svm_pointers + nullptr, // const size_t *sizes + 0, // const cl_mem_migration_flags flags + 0, // cl_uint num_events_in_wait_list + nullptr, // const cl_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_enqueue_svm_unmap_tests.inl b/opencl/test/unit_test/api/cl_enqueue_svm_unmap_tests.inl index 3257943d57..c5e2cf1299 100644 --- a/opencl/test/unit_test/api/cl_enqueue_svm_unmap_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_svm_unmap_tests.inl @@ -9,6 +9,7 @@ #include "opencl/source/command_queue/command_queue.h" #include "opencl/source/context/context.h" +#include "opencl/test/unit_test/mocks/mock_device.h" #include "cl_api_tests.h" @@ -94,4 +95,24 @@ TEST_F(clEnqueueSVMUnmapTests, GivenValidParametersWhenUnmappingSvmThenSuccessIs clSVMFree(pContext, ptrSvm); } } + +TEST_F(clEnqueueSVMUnmapTests, GivenDeviceNotSupportingSvmWhenEnqueuingSVMUnmapThenInvalidOperationErrorIsReturned) { + auto hwInfo = *platformDevices[0]; + hwInfo.capabilityTable.ftrSvm = false; + + auto pDevice = std::make_unique(MockDevice::createWithNewExecutionEnvironment(&hwInfo, 0)); + cl_device_id deviceId = pDevice.get(); + auto pContext = std::unique_ptr(Context::create(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal)); + auto pCommandQueue = std::make_unique(pContext.get(), pDevice.get(), nullptr); + + retVal = clEnqueueSVMUnmap( + pCommandQueue.get(), // cl_command_queue command_queue + reinterpret_cast(0x1234), // void *svm_ptr + 0, // cl_uint num_events_in_wait_list + nullptr, // const cL_event *event_wait_list + nullptr // cl_event *event + ); + EXPECT_EQ(CL_INVALID_OPERATION, retVal); +} + } // namespace ULT diff --git a/opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl b/opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl index 9514d6b080..952a39141e 100644 --- a/opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl +++ b/opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl @@ -581,11 +581,16 @@ TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemsetINTELisCalledWithoutIncorrec TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemsetINTELisCalledWithProperParametersThenParametersArePassedCorrectly) { auto mockContext = std::make_unique(); + const ClDeviceInfo &devInfo = mockContext->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemoryDeviceAllocation = clDeviceMemAllocINTEL(mockContext.get(), mockContext->getDevice(0u), nullptr, 400, 0, &retVal); struct MockedCommandQueue : public MockCommandQueue { + using MockCommandQueue::MockCommandQueue; cl_int enqueueSVMMemFill(void *svmPtr, const void *pattern, size_t patternSize, @@ -606,7 +611,7 @@ TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemsetINTELisCalledWithProperParam void *expectedDstPtr = nullptr; }; - MockedCommandQueue queue; + MockedCommandQueue queue{*mockContext}; queue.expectedDstPtr = unfiedMemoryDeviceAllocation; cl_int setValue = 12u; @@ -623,11 +628,16 @@ TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemFillINTELisCalledWithoutIncorre TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemFillINTELisCalledWithProperParametersThenParametersArePassedCorrectly) { auto mockContext = std::make_unique(); + const ClDeviceInfo &devInfo = mockContext->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemoryDeviceAllocation = clDeviceMemAllocINTEL(mockContext.get(), mockContext->getDevice(0u), nullptr, 400, 0, &retVal); struct MockedCommandQueue : public MockCommandQueue { + using MockCommandQueue::MockCommandQueue; cl_int enqueueSVMMemFill(void *svmPtr, const void *pattern, size_t patternSize, @@ -648,7 +658,7 @@ TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemFillINTELisCalledWithProperPara void *expectedDstPtr = nullptr; }; - MockedCommandQueue queue; + MockedCommandQueue queue{*mockContext}; queue.expectedDstPtr = unfiedMemoryDeviceAllocation; cl_int setValue = 12u; @@ -664,12 +674,17 @@ TEST(clUnifiedSharedMemoryTests, whenClEnqueueMemcpyINTELisCalledWithWrongQueueT TEST(clUnifiedSharedMemoryTests, givenTwoUnifiedMemoryAllocationsWhenTheyAreCopiedThenProperParamtersArePassed) { auto mockContext = std::make_unique(); + const ClDeviceInfo &devInfo = mockContext->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemoryDeviceAllocation = clDeviceMemAllocINTEL(mockContext.get(), mockContext->getDevice(0u), nullptr, 400, 0, &retVal); auto unfiedMemorySharedAllocation = clSharedMemAllocINTEL(mockContext.get(), mockContext->getDevice(0u), nullptr, 400, 0, &retVal); struct MockedCommandQueue : public MockCommandQueue { + using MockCommandQueue::MockCommandQueue; cl_int enqueueSVMMemcpy(cl_bool blockingCopy, void *dstPtr, const void *srcPtr, @@ -689,7 +704,7 @@ TEST(clUnifiedSharedMemoryTests, givenTwoUnifiedMemoryAllocationsWhenTheyAreCopi void *expectedDstPtr = nullptr; const void *expectedSrcPtr = nullptr; }; - MockedCommandQueue queue; + MockedCommandQueue queue{*mockContext}; queue.expectedDstPtr = unfiedMemoryDeviceAllocation; queue.expectedSrcPtr = unfiedMemorySharedAllocation; @@ -762,6 +777,10 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemAdviseINTELIsCalledWithE } TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemcpyINTELIsCalledWithEventThenProperCmdTypeIsSet) { + const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemoryDst = clSharedMemAllocINTEL(this->context, this->context->getDevice(0u), nullptr, 400, 0, &retVal); @@ -779,6 +798,10 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemcpyINTELIsCalledWithEven } TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemsetINTELIsCalledWithEventThenProperCmdTypeIsSet) { + const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemorySharedAllocation = clSharedMemAllocINTEL(this->context, this->context->getDevice(0u), nullptr, 400, 0, &retVal); @@ -794,6 +817,10 @@ TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemsetINTELIsCalledWithEven } TEST_F(clUnifiedSharedMemoryEventTests, whenClEnqueueMemFillINTELIsCalledWithEventThenProperCmdTypeIsSet) { + const ClDeviceInfo &devInfo = this->context->getDevice(0u)->getDeviceInfo(); + if (devInfo.svmCapabilities == 0) { + GTEST_SKIP(); + } cl_int retVal = CL_SUCCESS; auto unfiedMemorySharedAllocation = clSharedMemAllocINTEL(this->context, this->context->getDevice(0u), nullptr, 400, 0, &retVal);