Block SVMAllocsManager creation in Context when SVM is not supported

- skip SVM tests when SVM is not supported

Related-To: NEO-3157

Change-Id: Ie5d5ef4778749f60537084fc7f388714954a4873
Signed-off-by: Hoppe, Mateusz <[email protected]>

Author: HoppeMateusz

runtime/api/api.cpp

@@ -3621,6 +3621,12 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel,
         return retVal;
     }
 
+    auto svmManager = pKernel->getContext().getSVMAllocsManager();
+    if (!svmManager) {
+        retVal = CL_INVALID_ARG_VALUE;
+        return retVal;
+    }
+
     cl_int kernelArgAddressQualifier = pKernel->getKernelArgAddressQualifier(argIndex);
     if ((kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_GLOBAL) &&
         (kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_CONSTANT)) {
@@ -3630,7 +3636,7 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel,
 
     GraphicsAllocation *pSvmAlloc = nullptr;
     if (argValue != nullptr) {
-        auto svmData = pKernel->getContext().getSVMAllocsManager()->getSVMAlloc(argValue);
+        auto svmData = svmManager->getSVMAlloc(argValue);
         if (svmData == nullptr) {
             retVal = CL_INVALID_ARG_VALUE;
             return retVal;
@@ -3668,6 +3674,10 @@ cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel,
         size_t numPointers = paramValueSize / sizeof(void *);
         size_t *pSvmPtrList = (size_t *)paramValue;
 
+        if (pKernel->getContext().getSVMAllocsManager() == nullptr) {
+            return CL_INVALID_VALUE;
+        }
+
         pKernel->clearKernelExecInfo();
         for (uint32_t i = 0; i < numPointers; i++) {
             auto svmData = pKernel->getContext().getSVMAllocsManager()->getSVMAlloc((const void *)pSvmPtrList[i]);
@@ -4145,9 +4155,14 @@ cl_int CL_API_CALL clEnqueueSVMMigrateMem(cl_command_queue commandQueue,
         retVal = CL_INVALID_VALUE;
         return retVal;
     }
+    auto pSvmAllocMgr = pCommandQueue->getContext().getSVMAllocsManager();
+
+    if (pSvmAllocMgr == nullptr) {
+        retVal = CL_INVALID_VALUE;
+        return retVal;
+    }
 
     for (uint32_t i = 0; i < numSvmPointers; i++) {
-        SVMAllocsManager *pSvmAllocMgr = pCommandQueue->getContext().getSVMAllocsManager();
         auto svmData = pSvmAllocMgr->getSVMAlloc(svmPointers[i]);
         if (svmData == nullptr) {
             retVal = CL_INVALID_VALUE;

runtime/context/context.cpp

@@ -166,7 +166,9 @@ bool Context::createImpl(const cl_context_properties *properties,
     if (devices.size() > 0) {
         auto device = this->getDevice(0);
         this->memoryManager = device->getMemoryManager();
-        this->svmAllocsManager = new SVMAllocsManager(this->memoryManager);
+        if (device->getHardwareInfo().capabilityTable.ftrSvm) {
+            this->svmAllocsManager = new SVMAllocsManager(this->memoryManager);
+        }
         if (memoryManager->isAsyncDeleterEnabled()) {
             memoryManager->getDeferredDeleter()->addClient();
         }

runtime/mem_obj/buffer.cpp

@@ -175,15 +175,18 @@ Buffer *Buffer::create(Context *context,
             allocateMemory = true;
         }
 
-        auto svmData = context->getSVMAllocsManager()->getSVMAlloc(hostPtr);
-        if (svmData) {
-            memory = svmData->gpuAllocation;
-            allocationType = memory->getAllocationType();
-            isHostPtrSVM = true;
-            zeroCopyAllowed = memory->getAllocationType() == GraphicsAllocation::AllocationType::SVM_ZERO_COPY;
-            copyMemoryFromHostPtr = false;
-            allocateMemory = false;
-            mapAllocation = svmData->cpuAllocation;
+        auto svmManager = context->getSVMAllocsManager();
+        if (svmManager) {
+            auto svmData = svmManager->getSVMAlloc(hostPtr);
+            if (svmData) {
+                memory = svmData->gpuAllocation;
+                allocationType = memory->getAllocationType();
+                isHostPtrSVM = true;
+                zeroCopyAllowed = memory->getAllocationType() == GraphicsAllocation::AllocationType::SVM_ZERO_COPY;
+                copyMemoryFromHostPtr = false;
+                allocateMemory = false;
+                mapAllocation = svmData->cpuAllocation;
+            }
         }
     }
 

unit_tests/api/cl_api_tests.cpp

@@ -42,8 +42,12 @@ void api_fixture::SetUp() {
 void api_fixture::TearDown() {
     delete pKernel;
     delete pCommandQueue;
-    pContext->release();
-    pProgram->release();
+    if (pContext) {
+        pContext->release();
+    }
+    if (pProgram) {
+        pProgram->release();
+    }
 
     PlatformFixture::TearDown();
 }

unit_tests/api/cl_set_kernel_arg_svm_pointer_tests.inl

@@ -113,12 +113,15 @@ TEST_F(clSetKernelArgSVMPointer_, SetKernelArgSVMPointer_invalidArgValue) {
 }
 
 TEST_F(clSetKernelArgSVMPointer_, SetKernelArgSVMPointerWithNullArgValue_success) {
-    auto retVal = clSetKernelArgSVMPointer(
-        pMockKernel, // cl_kernel kernel
-        0,           // cl_uint arg_index
-        nullptr      // const void *arg_value
-    );
-    EXPECT_EQ(CL_SUCCESS, retVal);
+    const DeviceInfo &devInfo = pDevice->getDeviceInfo();
+    if (devInfo.svmCapabilities != 0) {
+        auto retVal = clSetKernelArgSVMPointer(
+            pMockKernel, // cl_kernel kernel
+            0,           // cl_uint arg_index
+            nullptr      // const void *arg_value
+        );
+        EXPECT_EQ(CL_SUCCESS, retVal);
+    }
 }
 
 TEST_F(clSetKernelArgSVMPointer_, SetKernelArgSVMPointer_success) {

unit_tests/api/cl_svm_alloc_tests.inl

@@ -21,6 +21,9 @@ class clSVMAllocTemplateTests : public api_fixture,
   public:
     void SetUp() override {
         api_fixture::SetUp();
+        if (!pPlatform->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm) {
+            GTEST_SKIP();
+        }
     }
 
     void TearDown() override {

unit_tests/context/context_tests.cpp

@@ -299,6 +299,21 @@ TEST_F(ContextTest, givenContextWhenSharingTableIsNotEmptyThenReturnsSharingFunc
     EXPECT_EQ(sharingF, sharingFunctions);
 }
 
+TEST(Context, givenFtrSvmFalseWhenContextIsCreatedThenSVMAllocsManagerIsNotCreated) {
+    ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment();
+    auto hwInfo = executionEnvironment->getMutableHardwareInfo();
+    hwInfo->capabilityTable.ftrSvm = false;
+
+    std::unique_ptr<MockDevice> device(MockDevice::createWithExecutionEnvironment<MockDevice>(hwInfo, executionEnvironment, 0));
+
+    cl_device_id clDevice = device.get();
+    cl_int retVal = CL_SUCCESS;
+    auto context = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, DeviceVector(&clDevice, 1), nullptr, nullptr, retVal));
+    ASSERT_NE(nullptr, context);
+    auto svmManager = context->getSVMAllocsManager();
+    EXPECT_EQ(nullptr, svmManager);
+}
+
 class ContextWithAsyncDeleterTest : public ::testing::WithParamInterface<bool>,
                                     public ::testing::Test {
   public:

unit_tests/context/driver_diagnostics_enqueue_tests.cpp

@@ -661,7 +661,9 @@ TEST_P(PerformanceHintEnqueueMapTest, GivenZeroCopyFlagWhenEnqueueUnmapIsCalling
 }
 
 TEST_F(PerformanceHintEnqueueTest, GivenSVMPointerWhenEnqueueSVMMapIsCallingThenContextProvidesProperHint) {
-
+    if (!pPlatform->peekExecutionEnvironment()->getHardwareInfo()->capabilityTable.ftrSvm) {
+        GTEST_SKIP();
+    }
     void *svmPtr = context->getSVMAllocsManager()->createSVMAlloc(256, {});
 
     pCmdQ->enqueueSVMMap(CL_FALSE, 0, svmPtr, 256, 0, nullptr, nullptr);

unit_tests/kernel/clone_kernel_tests.cpp

@@ -509,6 +509,9 @@ TEST_F(CloneKernelTest, cloneKernelWithArgImmediate) {
 }
 
 TEST_F(CloneKernelTest, cloneKernelWithExecInfo) {
+    if (!pDevice->getHardwareInfo().capabilityTable.ftrSvm) {
+        GTEST_SKIP();
+    }
     void *ptrSVM = pContext->getSVMAllocsManager()->createSVMAlloc(256, {});
     ASSERT_NE(nullptr, ptrSVM);
 

unit_tests/mem_obj/buffer_set_arg_tests.cpp

@@ -261,6 +261,9 @@ TEST_F(BufferSetArgTest, clSetKernelArgBuffer) {
 }
 
 TEST_F(BufferSetArgTest, clSetKernelArgSVMPointer) {
+    if (!pDevice->getHardwareInfo().capabilityTable.ftrSvm) {
+        GTEST_SKIP();
+    }
     void *ptrSVM = pContext->getSVMAllocsManager()->createSVMAlloc(256, {});
     EXPECT_NE(nullptr, ptrSVM);