Correctly pass descriptors to L0 shared alloc function

Jaime Arteaga · Compute-Runtime-Automation · commit 3f6d1f5ee958 · 2020-11-11T07:04:54.000+01:00
Signed-off-by: Jaime Arteaga &lt;jaime.a.arteaga.molina@intel.com&gt;
diff --git a/level_zero/api/core/ze_memory.cpp b/level_zero/api/core/ze_memory.cpp
@@ -17,7 +17,7 @@ zeMemAllocShared(
     size_t alignment,
     ze_device_handle_t hDevice,
     void **pptr) {
-    return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc->flags, hostDesc->flags, size, alignment, pptr);
+    return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc, hostDesc, size, alignment, pptr);
 }
 
 ZE_APIEXPORT ze_result_t ZE_APICALL
diff --git a/level_zero/core/source/context/context.h b/level_zero/core/source/context/context.h
@@ -32,8 +32,8 @@ struct Context : _ze_context_handle_t {
                                        size_t size,
                                        size_t alignment, void **ptr) = 0;
     virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice,
-                                       ze_device_mem_alloc_flags_t deviceFlags,
-                                       ze_host_mem_alloc_flags_t hostFlags,
+                                       const ze_device_mem_alloc_desc_t *deviceDesc,
+                                       const ze_host_mem_alloc_desc_t *hostDesc,
                                        size_t size,
                                        size_t alignment,
                                        void **ptr) = 0;
diff --git a/level_zero/core/source/context/context_imp.cpp b/level_zero/core/source/context/context_imp.cpp
@@ -64,15 +64,15 @@ ze_result_t ContextImp::allocDeviceMem(ze_device_handle_t hDevice,
 }
 
 ze_result_t ContextImp::allocSharedMem(ze_device_handle_t hDevice,
-                                       ze_device_mem_alloc_flags_t deviceFlags,
-                                       ze_host_mem_alloc_flags_t hostFlags,
+                                       const ze_device_mem_alloc_desc_t *deviceDesc,
+                                       const ze_host_mem_alloc_desc_t *hostDesc,
                                        size_t size,
                                        size_t alignment,
                                        void **ptr) {
     DEBUG_BREAK_IF(nullptr == this->driverHandle);
     return this->driverHandle->allocSharedMem(hDevice,
-                                              deviceFlags,
-                                              hostFlags,
+                                              deviceDesc,
+                                              hostDesc,
                                               size,
                                               alignment,
                                               ptr);
diff --git a/level_zero/core/source/context/context_imp.h b/level_zero/core/source/context/context_imp.h
@@ -27,8 +27,8 @@ struct ContextImp : Context {
                                size_t size,
                                size_t alignment, void **ptr) override;
     ze_result_t allocSharedMem(ze_device_handle_t hDevice,
-                               ze_device_mem_alloc_flags_t deviceFlags,
-                               ze_host_mem_alloc_flags_t hostFlags,
+                               const ze_device_mem_alloc_desc_t *deviceDesc,
+                               const ze_host_mem_alloc_desc_t *hostDesc,
                                size_t size,
                                size_t alignment,
                                void **ptr) override;
diff --git a/level_zero/core/source/driver/driver_handle.h b/level_zero/core/source/driver/driver_handle.h
@@ -41,8 +41,10 @@ struct DriverHandle : _ze_driver_handle_t {
     virtual ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size,
                                        size_t alignment, void **ptr) = 0;
 
-    virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
-                                       ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
+    virtual ze_result_t allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
+                                       const ze_host_mem_alloc_desc_t *hostDesc,
+                                       size_t size,
+                                       size_t alignment,
                                        void **ptr) = 0;
     virtual ze_result_t freeMem(const void *ptr) = 0;
     virtual NEO::MemoryManager *getMemoryManager() = 0;
diff --git a/level_zero/core/source/driver/driver_handle_imp.h b/level_zero/core/source/driver/driver_handle_imp.h
@@ -33,8 +33,11 @@ struct DriverHandleImp : public DriverHandle {
     ze_result_t allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size,
                                size_t alignment, void **ptr) override;
 
-    ze_result_t allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
-                               ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
+    ze_result_t allocSharedMem(ze_device_handle_t hDevice,
+                               const ze_device_mem_alloc_desc_t *deviceDesc,
+                               const ze_host_mem_alloc_desc_t *hostDesc,
+                               size_t size,
+                               size_t alignment,
                                void **ptr) override;
 
     ze_result_t getMemAddressRange(const void *ptr, void **pBase, size_t *pSize) override;
diff --git a/level_zero/core/source/memory/memory.cpp b/level_zero/core/source/memory/memory.cpp
@@ -139,8 +139,10 @@ ze_result_t DriverHandleImp::allocDeviceMem(ze_device_handle_t hDevice, const ze
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flags_t deviceFlags,
-                                            ze_host_mem_alloc_flags_t hostFlags, size_t size, size_t alignment,
+ze_result_t DriverHandleImp::allocSharedMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
+                                            const ze_host_mem_alloc_desc_t *hostDesc,
+                                            size_t size,
+                                            size_t alignment,
                                             void **ptr) {
     ze_device_handle_t device;
     void *unifiedMemoryPropertiesDevice = nullptr;
diff --git a/level_zero/core/test/unit_tests/mocks/mock_context.h b/level_zero/core/test/unit_tests/mocks/mock_context.h
@@ -57,8 +57,8 @@ struct Mock<Context> : public Context {
     MOCK_METHOD(ze_result_t,
                 allocSharedMem,
                 (ze_device_handle_t hDevice,
-                 ze_device_mem_alloc_flags_t deviceFlags,
-                 ze_host_mem_alloc_flags_t hostFlags,
+                 const ze_device_mem_alloc_desc_t *deviceDesc,
+                 const ze_host_mem_alloc_desc_t *hostDesc,
                  size_t size,
                  size_t alignment,
                  void **ptr),
diff --git a/level_zero/core/test/unit_tests/mocks/mock_driver_handle.h b/level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
@@ -115,8 +115,8 @@ struct Mock<DriverHandle> : public DriverHandleImp {
     MOCK_METHOD(ze_result_t,
                 allocSharedMem,
                 (ze_device_handle_t hDevice,
-                 ze_device_mem_alloc_flags_t deviceFlags,
-                 ze_host_mem_alloc_flags_t hostFlags,
+                 const ze_device_mem_alloc_desc_t *deviceDesc,
+                 const ze_host_mem_alloc_desc_t *hostDesc,
                  size_t size,
                  size_t alignment,
                  void **ptr),
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel.cpp
@@ -488,7 +488,9 @@ HWTEST_F(CommandListDualStroage, givenIndirectDispatchWithSharedDualStorageMemor
     std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, returnValue));
 
     void *alloc = nullptr;
-    auto result = device->getDriverHandle()->allocSharedMem(device->toHandle(), 0u, 0u, 16384u, 4096u, &alloc);
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
+    auto result = device->getDriverHandle()->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &alloc);
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 
     ze_group_count_t *pThreadGroupDimensions = static_cast<ze_group_count_t *>(ptrOffset(alloc, sizeof(ze_group_count_t)));
diff --git a/level_zero/core/test/unit_tests/sources/memory/test_memory.cpp b/level_zero/core/test/unit_tests/sources/memory/test_memory.cpp
@@ -61,9 +61,11 @@ TEST_F(MemoryTest, givenSharedPointerThenDriverGetAllocPropertiesReturnsDeviceHa
     size_t alignment = 1u;
     void *ptr = nullptr;
 
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
     ze_result_t result = driverHandle->allocSharedMem(device->toHandle(),
-                                                      0u,
-                                                      0u,
+                                                      &deviceDesc,
+                                                      &hostDesc,
                                                       size, alignment, &ptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_NE(nullptr, ptr);
@@ -125,9 +127,11 @@ TEST_F(MemoryTest, givenSharedPointerAndDeviceHandleAsNullThenDriverReturnsSucce
     void *ptr = nullptr;
 
     ASSERT_NE(nullptr, device->toHandle());
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
     ze_result_t result = driverHandle->allocSharedMem(nullptr,
-                                                      0u,
-                                                      0u,
+                                                      &deviceDesc,
+                                                      &hostDesc,
                                                       size, alignment, &ptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_NE(nullptr, ptr);
@@ -142,9 +146,11 @@ TEST_F(MemoryTest, givenNoDeviceWhenAllocatingSharedMemoryThenDeviceInAllocation
     void *ptr = nullptr;
 
     ASSERT_NE(nullptr, device->toHandle());
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
     ze_result_t result = driverHandle->allocSharedMem(nullptr,
-                                                      0u,
-                                                      0u,
+                                                      &deviceDesc,
+                                                      &hostDesc,
                                                       size, alignment, &ptr);
     auto alloc = driverHandle->svmAllocsManager->getSVMAlloc(ptr);
     EXPECT_EQ(alloc->device, nullptr);
@@ -227,9 +233,11 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
     ASSERT_NE(nullptr, driverHandle->devices[1]->toHandle());
     EXPECT_NE(neoDevice0->getDeviceBitfield(), neoDevice1->getDeviceBitfield());
     EXPECT_NE(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
     auto result = driverHandle->allocSharedMem(nullptr,
-                                               ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD,
-                                               0u,
+                                               &deviceDesc,
+                                               &hostDesc,
                                                size, alignment, &ptr);
     EXPECT_EQ(neoDevice0->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
 
@@ -241,8 +249,8 @@ TEST(MemoryBitfieldTests, givenDeviceWithValidBitfieldWhenAllocatingSharedMemory
     memoryManager->recentlyPassedDeviceBitfield = {};
     EXPECT_NE(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
     result = driverHandle->allocSharedMem(driverHandle->devices[1]->toHandle(),
-                                          ZE_DEVICE_MEMORY_PROPERTY_FLAG_TBD,
-                                          0u,
+                                          &deviceDesc,
+                                          &hostDesc,
                                           size, alignment, &ptr);
     EXPECT_EQ(neoDevice1->getDeviceBitfield(), memoryManager->recentlyPassedDeviceBitfield);
 
@@ -362,9 +370,11 @@ TEST_F(ContextMemoryTest, whenAllocatingSharedAllocationFromContextThenAllocatio
     size_t alignment = 1u;
     void *ptr = nullptr;
 
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_host_mem_alloc_desc_t hostDesc = {};
     ze_result_t result = context->allocSharedMem(device->toHandle(),
-                                                 0u,
-                                                 0u,
+                                                 &deviceDesc,
+                                                 &hostDesc,
                                                  size, alignment, &ptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_NE(nullptr, ptr);

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ zeMemAllocShared(`
`17`	`17`	`size_t alignment,`
`18`	`18`	`ze_device_handle_t hDevice,`
`19`	`19`	`void **pptr) {`
`20`		`- return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc->flags, hostDesc->flags, size, alignment, pptr);`
	`20`	`+ return L0::Context::fromHandle(hContext)->allocSharedMem(hDevice, deviceDesc, hostDesc, size, alignment, pptr);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`ZE_APIEXPORT ze_result_t ZE_APICALL`