Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Return CL_INVALID_OPERATION error for enqueuing SVM operations

Browse Source 
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 <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2020-03-11 16:15:34 +01:00
committed by sys_ocldev
parent f2e24797ae
commit 6ce9402fc2
8 changed files with 277 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
opencl/test/unit_test/api/cl_enqueue_svm_free_tests.inl
View File

@ -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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(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

49
opencl/test/unit_test/api/cl_enqueue_svm_map_tests.inl
View File

@ -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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(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

49
opencl/test/unit_test/api/cl_enqueue_svm_mem_fill_tests.inl
View File

@ -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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(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

24
opencl/test/unit_test/api/cl_enqueue_svm_memcpy_tests.inl
View File

@ -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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(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

55
opencl/test/unit_test/api/cl_enqueue_svm_migrate_mem_tests.cpp
View File

@ -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 <memory>
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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(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

21
opencl/test/unit_test/api/cl_enqueue_svm_unmap_tests.inl
View File

@ -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<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0));
cl_device_id deviceId = pDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto pCommandQueue = std::make_unique<MockCommandQueue>(pContext.get(), pDevice.get(), nullptr);
retVal = clEnqueueSVMUnmap(
pCommandQueue.get(), // cl_command_queue command_queue
reinterpret_cast<void *>(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

33
opencl/test/unit_test/api/cl_unified_shared_memory_tests.inl
View File

@ -581,11 +581,16 @@ TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemsetINTELisCalledWithoutIncorrec
TEST(clUnifiedSharedMemoryTests, whenclEnqueueMemsetINTELisCalledWithProperParametersThenParametersArePassedCorrectly) {
auto mockContext = std::make_unique<MockContext>();
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<MockContext>();
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<MockContext>();
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);