Create resource with given address

LukaszJobczyk · Compute-Runtime-Automation · commit 0634aa3f1b40 · 2022-02-24T17:06:19.000+01:00
Signed-off-by: Lukasz Jobczyk &lt;lukasz.jobczyk@intel.com&gt;
diff --git a/opencl/extensions/public/cl_ext_private.h b/opencl/extensions/public/cl_ext_private.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -99,6 +99,7 @@ using cl_unified_shared_memory_capabilities_intel = cl_bitfield;
 
 /* cl_mem_properties_intel */
 #define CL_MEM_ALLOC_FLAGS_INTEL 0x4195
+#define CL_MEM_ALLOC_USE_HOST_PTR_INTEL 0x1000F
 
 /* cl_mem_alloc_flags_intel - bitfield */
 #define CL_MEM_ALLOC_DEFAULT_INTEL 0
diff --git a/opencl/source/helpers/cl_memory_properties_helpers.cpp b/opencl/source/helpers/cl_memory_properties_helpers.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,7 +16,7 @@ bool ClMemoryPropertiesHelper::parseMemoryProperties(const cl_mem_properties_int
                                                      cl_mem_flags &flags, cl_mem_flags_intel &flagsIntel,
                                                      cl_mem_alloc_flags_intel &allocflags, MemoryPropertiesHelper::ObjType objectType, Context &context) {
     Device *pDevice = &context.getDevice(0)->getDevice();
-
+    uintptr_t hostptr = 0;
     if (properties != nullptr) {
         for (int i = 0; properties[i] != 0; i += 2) {
             switch (properties[i]) {
@@ -29,13 +29,17 @@ bool ClMemoryPropertiesHelper::parseMemoryProperties(const cl_mem_properties_int
             case CL_MEM_ALLOC_FLAGS_INTEL:
                 allocflags |= static_cast<cl_mem_alloc_flags_intel>(properties[i + 1]);
                 break;
+            case CL_MEM_ALLOC_USE_HOST_PTR_INTEL:
+                hostptr = static_cast<uintptr_t>(properties[i + 1]);
+                break;
             default:
                 return false;
             }
         }
     }
 
     memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(flags, flagsIntel, allocflags, pDevice);
+    memoryProperties.hostptr = hostptr;
 
     switch (objectType) {
     case MemoryPropertiesHelper::ObjType::BUFFER:
diff --git a/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp b/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
@@ -4792,6 +4792,19 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWithoutLocalMemoryAndCpuPtrWhe
     memoryManager.freeGraphicsMemory(allocation);
 }
 
+TEST_F(DrmMemoryManagerTest, givenNullDefaultAllocWhenCreateGraphicsAllocationFromExistingStorageThenDoNotImportHandle) {
+    TestedDrmMemoryManager memoryManager(false, false, false, *executionEnvironment);
+    mock->ioctl_expected.primeFdToHandle = 0;
+
+    MockAllocationProperties properties(0u, 1u);
+    MultiGraphicsAllocation allocation(0u);
+    auto alloc = memoryManager.createGraphicsAllocationFromExistingStorage(properties, nullptr, allocation);
+
+    EXPECT_NE(alloc, nullptr);
+
+    memoryManager.freeGraphicsMemory(alloc);
+}
+
 TEST(DrmMemoryManagerSimpleTest, givenDrmMemoryManagerWhenAllocateInDevicePoolIsCalledThenNullptrAndStatusRetryIsReturned) {
     MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
     executionEnvironment.rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
diff --git a/shared/source/memory_manager/memory_manager.cpp b/shared/source/memory_manager/memory_manager.cpp
@@ -147,9 +147,7 @@ GraphicsAllocation *MemoryManager::createPaddedAllocation(GraphicsAllocation *in
     return allocateGraphicsMemoryWithProperties({inputGraphicsAllocation->getRootDeviceIndex(), sizeWithPadding, AllocationType::INTERNAL_HOST_MEMORY, systemMemoryBitfield});
 }
 
-void *MemoryManager::createMultiGraphicsAllocationInSystemMemoryPool(std::vector<uint32_t> &rootDeviceIndices, AllocationProperties &properties, MultiGraphicsAllocation &multiGraphicsAllocation) {
-    void *ptr = nullptr;
-
+void *MemoryManager::createMultiGraphicsAllocationInSystemMemoryPool(std::vector<uint32_t> &rootDeviceIndices, AllocationProperties &properties, MultiGraphicsAllocation &multiGraphicsAllocation, void *ptr) {
     properties.flags.forceSystemMemory = true;
     for (auto &rootDeviceIndex : rootDeviceIndices) {
         if (multiGraphicsAllocation.getGraphicsAllocation(rootDeviceIndex)) {
@@ -528,7 +526,8 @@ GraphicsAllocation *MemoryManager::allocateGraphicsMemory(const AllocationData &
     if (allocationData.flags.shareable || allocationData.flags.isUSMDeviceMemory) {
         return allocateMemoryByKMD(allocationData);
     }
-    if (useNonSvmHostPtrAlloc(allocationData.type, allocationData.rootDeviceIndex) || isNonSvmBuffer(allocationData.hostPtr, allocationData.type, allocationData.rootDeviceIndex)) {
+    if (((false == allocationData.flags.isUSMHostAllocation) || (nullptr == allocationData.hostPtr)) &&
+        (useNonSvmHostPtrAlloc(allocationData.type, allocationData.rootDeviceIndex) || isNonSvmBuffer(allocationData.hostPtr, allocationData.type, allocationData.rootDeviceIndex))) {
         auto allocation = allocateGraphicsMemoryForNonSvmHostPtr(allocationData);
         if (allocation) {
             allocation->setFlushL3Required(allocationData.flags.flushL3);
diff --git a/shared/source/memory_manager/memory_manager.h b/shared/source/memory_manager/memory_manager.h
@@ -116,7 +116,10 @@ class MemoryManager {
     GraphicsAllocation *createGraphicsAllocationWithPadding(GraphicsAllocation *inputGraphicsAllocation, size_t sizeWithPadding);
     virtual GraphicsAllocation *createPaddedAllocation(GraphicsAllocation *inputGraphicsAllocation, size_t sizeWithPadding);
 
-    MOCKABLE_VIRTUAL void *createMultiGraphicsAllocationInSystemMemoryPool(std::vector<uint32_t> &rootDeviceIndices, AllocationProperties &properties, MultiGraphicsAllocation &multiGraphicsAllocation);
+    MOCKABLE_VIRTUAL void *createMultiGraphicsAllocationInSystemMemoryPool(std::vector<uint32_t> &rootDeviceIndices, AllocationProperties &properties, MultiGraphicsAllocation &multiGraphicsAllocation, void *ptr);
+    MOCKABLE_VIRTUAL void *createMultiGraphicsAllocationInSystemMemoryPool(std::vector<uint32_t> &rootDeviceIndices, AllocationProperties &properties, MultiGraphicsAllocation &multiGraphicsAllocation) {
+        return createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndices, properties, multiGraphicsAllocation, nullptr);
+    }
     virtual GraphicsAllocation *createGraphicsAllocationFromExistingStorage(AllocationProperties &properties, void *ptr, MultiGraphicsAllocation &multiGraphicsAllocation);
 
     virtual AllocationStatus populateOsHandles(OsHandleStorage &handleStorage, uint32_t rootDeviceIndex) = 0;
diff --git a/shared/source/memory_manager/unified_memory_manager.cpp b/shared/source/memory_manager/unified_memory_manager.cpp
@@ -149,8 +149,9 @@ void *SVMAllocsManager::createHostUnifiedMemoryAllocation(size_t size,
 
     auto maxRootDeviceIndex = *std::max_element(rootDeviceIndicesVector.begin(), rootDeviceIndicesVector.end(), std::less<uint32_t const>());
     SvmAllocationData allocData(maxRootDeviceIndex);
+    void *externalHostPointer = reinterpret_cast<void *>(memoryProperties.allocationFlags.hostptr);
 
-    void *usmPtr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndicesVector, unifiedMemoryProperties, allocData.gpuAllocations);
+    void *usmPtr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndicesVector, unifiedMemoryProperties, allocData.gpuAllocations, externalHostPointer);
     if (!usmPtr) {
         return nullptr;
     }
diff --git a/shared/source/memory_properties/memory_properties_flags.h b/shared/source/memory_properties/memory_properties_flags.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -22,6 +22,7 @@ struct MemoryProperties {
         MemoryAllocFlags allocFlags;
         uint32_t allAllocFlags = 0;
     };
+    uintptr_t hostptr = 0;
     static_assert(sizeof(MemoryProperties::flags) == sizeof(MemoryProperties::allFlags) && sizeof(MemoryProperties::allocFlags) == sizeof(MemoryProperties::allAllocFlags), "");
 };
 } // namespace NEO
diff --git a/shared/source/os_interface/linux/drm_memory_manager.cpp b/shared/source/os_interface/linux/drm_memory_manager.cpp
@@ -826,7 +826,7 @@ void DrmMemoryManager::handleFenceCompletion(GraphicsAllocation *allocation) {
 
 GraphicsAllocation *DrmMemoryManager::createGraphicsAllocationFromExistingStorage(AllocationProperties &properties, void *ptr, MultiGraphicsAllocation &multiGraphicsAllocation) {
     auto defaultAlloc = multiGraphicsAllocation.getDefaultGraphicsAllocation();
-    if (static_cast<DrmAllocation *>(defaultAlloc)->getMmapPtr()) {
+    if (defaultAlloc && static_cast<DrmAllocation *>(defaultAlloc)->getMmapPtr()) {
         properties.size = defaultAlloc->getUnderlyingBufferSize();
         properties.gpuAddress = castToUint64(ptr);
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2018-2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2018-2022 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -99,6 +99,7 @@ using cl_unified_shared_memory_capabilities_intel = cl_bitfield;`
`99`	`99`
`100`	`100`	`/* cl_mem_properties_intel */`
`101`	`101`	`#define CL_MEM_ALLOC_FLAGS_INTEL 0x4195`
	`102`	`+#define CL_MEM_ALLOC_USE_HOST_PTR_INTEL 0x1000F`
`102`	`103`
`103`	`104`	`/* cl_mem_alloc_flags_intel - bitfield */`
`104`	`105`	`#define CL_MEM_ALLOC_DEFAULT_INTEL 0`
Original file line number	Diff line number	Diff line change
`@@ -149,8 +149,9 @@ void *SVMAllocsManager::createHostUnifiedMemoryAllocation(size_t size,`
`149`	`149`
`150`	`150`	`auto maxRootDeviceIndex = *std::max_element(rootDeviceIndicesVector.begin(), rootDeviceIndicesVector.end(), std::less<uint32_t const>());`
`151`	`151`	`SvmAllocationData allocData(maxRootDeviceIndex);`
	`152`	`+ void externalHostPointer = reinterpret_cast<void >(memoryProperties.allocationFlags.hostptr);`
`152`	`153`
`153`		`- void *usmPtr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndicesVector, unifiedMemoryProperties, allocData.gpuAllocations);`
	`154`	`+ void *usmPtr = memoryManager->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndicesVector, unifiedMemoryProperties, allocData.gpuAllocations, externalHostPointer);`
`154`	`155`	`if (!usmPtr) {`
`155`	`156`	`return nullptr;`
`156`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2019-2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2019-2022 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -22,6 +22,7 @@ struct MemoryProperties {`
`22`	`22`	`MemoryAllocFlags allocFlags;`
`23`	`23`	`uint32_t allAllocFlags = 0;`
`24`	`24`	`};`
	`25`	`+ uintptr_t hostptr = 0;`
`25`	`26`	`static_assert(sizeof(MemoryProperties::flags) == sizeof(MemoryProperties::allFlags) && sizeof(MemoryProperties::allocFlags) == sizeof(MemoryProperties::allAllocFlags), "");`
`26`	`27`	`};`
`27`	`28`	`} // namespace NEO`