From 469c929b7f81aca5d102cc85a43d17e5f4d2d96c Mon Sep 17 00:00:00 2001
From: Bartosz Dunajski <bartosz.dunajski@intel.com>
Date: Mon, 25 Jan 2021 15:16:20 +0100
Subject: [PATCH] Unrestricted size flag support in clSvmAlloc

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
---
 opencl/source/api/api.cpp                     | 43 +++++++++++--------
 .../test/unit_test/api/cl_svm_alloc_tests.inl | 38 +++++++++++++++-
 2 files changed, 63 insertions(+), 18 deletions(-)

diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp
index bafd8574b4..d6ea83a040 100644
--- a/opencl/source/api/api.cpp
+++ b/opencl/source/api/api.cpp
@@ -4387,27 +4387,36 @@ void *CL_API_CALL clSVMAlloc(cl_context context,
         return pAlloc;
     }
 
-    if (flags == 0) {
-        flags = CL_MEM_READ_WRITE;
-    }
+    {
+        // allow CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL with every combination
+        cl_svm_mem_flags tempFlags = flags & (~CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL);
 
-    if (!((flags == CL_MEM_READ_WRITE) ||
-          (flags == CL_MEM_WRITE_ONLY) ||
-          (flags == CL_MEM_READ_ONLY) ||
-          (flags == CL_MEM_SVM_FINE_GRAIN_BUFFER) ||
-          (flags == (CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
-          (flags == (CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
-          (flags == (CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
-          (flags == (CL_MEM_WRITE_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
-          (flags == (CL_MEM_WRITE_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
-          (flags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
-          (flags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)))) {
-        TRACING_EXIT(clSVMAlloc, &pAlloc);
-        return pAlloc;
+        if (tempFlags == 0) {
+            tempFlags = CL_MEM_READ_WRITE;
+        }
+
+        if (!((tempFlags == CL_MEM_READ_WRITE) ||
+              (tempFlags == CL_MEM_WRITE_ONLY) ||
+              (tempFlags == CL_MEM_READ_ONLY) ||
+              (tempFlags == CL_MEM_SVM_FINE_GRAIN_BUFFER) ||
+              (tempFlags == (CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
+              (tempFlags == (CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
+              (tempFlags == (CL_MEM_READ_WRITE | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
+              (tempFlags == (CL_MEM_WRITE_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
+              (tempFlags == (CL_MEM_WRITE_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)) ||
+              (tempFlags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER)) ||
+              (tempFlags == (CL_MEM_READ_ONLY | CL_MEM_SVM_FINE_GRAIN_BUFFER | CL_MEM_SVM_ATOMICS)))) {
+
+            TRACING_EXIT(clSVMAlloc, &pAlloc);
+            return pAlloc;
+        }
     }
 
     auto pDevice = pContext->getDevice(0);
-    if ((size == 0) || (size > pDevice->getSharedDeviceInfo().maxMemAllocSize)) {
+    bool allowUnrestrictedSize = (flags & CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL);
+
+    if ((size == 0) ||
+        (!allowUnrestrictedSize && (size > pDevice->getSharedDeviceInfo().maxMemAllocSize))) {
         TRACING_EXIT(clSVMAlloc, &pAlloc);
         return pAlloc;
     }
diff --git a/opencl/test/unit_test/api/cl_svm_alloc_tests.inl b/opencl/test/unit_test/api/cl_svm_alloc_tests.inl
index 1f5157d0f2..ce0ce815bc 100644
--- a/opencl/test/unit_test/api/cl_svm_alloc_tests.inl
+++ b/opencl/test/unit_test/api/cl_svm_alloc_tests.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2020 Intel Corporation
+ * Copyright (C) 2017-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -194,6 +194,42 @@ TEST_F(clSVMAllocTests, GivenZeroAlignmentWhenAllocatingSvmThenSvmIsAllocated) {
     }
 }
 
+TEST_F(clSVMAllocTests, givenUnrestrictedFlagWhenCreatingSvmAllocThenAllowSizeBiggerThanMaxMemAllocSize) {
+    REQUIRE_SVM_OR_SKIP(pDevice);
+
+    const size_t maxMemAllocSize = 128;
+
+    static_cast<MockDevice &>(pDevice->getDevice()).deviceInfo.maxMemAllocSize = maxMemAllocSize;
+
+    size_t allowedSize = maxMemAllocSize;
+    size_t notAllowedSize = maxMemAllocSize + 1;
+
+    cl_mem_flags flags = 0;
+    void *svmPtr = nullptr;
+
+    {
+        // no flag + not allowed size
+        svmPtr = clSVMAlloc(pContext, flags, notAllowedSize, 0);
+        EXPECT_EQ(nullptr, svmPtr);
+    }
+
+    flags = CL_MEM_ALLOW_UNRESTRICTED_SIZE_INTEL;
+
+    {
+        // unrestricted size flag + not allowed size
+        svmPtr = clSVMAlloc(pContext, flags, notAllowedSize, 0);
+        EXPECT_NE(nullptr, svmPtr);
+        clSVMFree(pContext, svmPtr);
+    }
+
+    {
+        // unrestricted size flag + allowed size
+        svmPtr = clSVMAlloc(pContext, flags, allowedSize, 0);
+        EXPECT_NE(nullptr, svmPtr);
+        clSVMFree(pContext, svmPtr);
+    }
+}
+
 TEST_F(clSVMAllocTests, GivenUnalignedSizeAndDefaultAlignmentWhenAllocatingSvmThenSvmIsAllocated) {
     const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
     if (devInfo.svmCapabilities != 0) {