Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +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/source/api/api.cpp
View File

@ -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]);

27
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,6 +35,8 @@ TEST_F(clEnqueueSVMFreeTests, GivenInvalidCommandQueueWhenFreeingSVMThenInvalidC
}
TEST_F(clEnqueueSVMFreeTests, GivenNonZeroNumOfSVMPointersAndNullSVMPointersWhenFreeingSVMThenInvalidValueErrorIsReturned) {
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
@ -46,6 +49,7 @@ TEST_F(clEnqueueSVMFreeTests, GivenNonZeroNumOfSVMPointersAndNullSVMPointersWhen
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
}
TEST_F(clEnqueueSVMFreeTests, GivenZeroNumOfSVMPointersAndNonNullSVMPointersWhenFreeingSVMThenInvalidValueErrorIsReturned) {
const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo();
@ -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

27
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,6 +34,8 @@ TEST_F(clEnqueueSVMMapTests, GivenInvalidCommandQueueWhenMappingSVMThenInvalidCo
}
TEST_F(clEnqueueSVMMapTests, GivenNullSVMPointerWhenMappingSVMThenInvalidValueErrorIsReturned) {
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
@ -45,6 +48,7 @@ TEST_F(clEnqueueSVMMapTests, GivenNullSVMPointerWhenMappingSVMThenInvalidValueEr
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
}
TEST_F(clEnqueueSVMMapTests, GivenRegionSizeZeroWhenMappingSVMThenInvalidValueErrorIsReturned) {
const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo();
@ -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

27
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,6 +34,8 @@ TEST_F(clEnqueueSVMMemFillTests, GivenInvalidCommandQueueWhenFillingSVMMemoryThe
}
TEST_F(clEnqueueSVMMemFillTests, GivenNullSVMPtrWhenFillingSVMMemoryThenInvalidValueErrorIsReturned) {
const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo();
if (devInfo.svmCapabilities != 0) {
auto retVal = clEnqueueSVMMemFill(
pCommandQueue, // cl_command_queue command_queue
nullptr, // void *svm_ptr
@ -45,6 +48,7 @@ TEST_F(clEnqueueSVMMemFillTests, GivenNullSVMPtrWhenFillingSVMMemoryThenInvalidV
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
}
TEST_F(clEnqueueSVMMemFillTests, GivenRegionSizeZeroWhenFillingSVMMemoryThenInvalidValueErrorIsReturned) {
const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo();
@ -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

33
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,6 +39,8 @@ TEST_F(clEnqueueSVMMigrateMemTests, GivenInvalidCommandQueueWhenMigratingSVMThen
}
TEST_F(clEnqueueSVMMigrateMemTests, GivenNullSvmPointersWhenMigratingSvmThenInvalidValueErrorIsReturned) {
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
@ -48,6 +53,7 @@ TEST_F(clEnqueueSVMMigrateMemTests, GivenNullSvmPointersWhenMigratingSvmThenInva
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
}
TEST_F(clEnqueueSVMMigrateMemTests, GivenNumSvmPointersIsZeroWhenMigratingSvmThenInvalidValueErrorIsReturned) {
const ClDeviceInfo &devInfo = pPlatform->getClDevice(0)->getDeviceInfo();
@ -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);