fix: correct shared cross device alloc capabilities

allow for access in case of multiple exposed devices when
there is only one root device

Related-To: HSD-18042639532
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
Source: 645de5a

Author: JablonskiMateusz

level_zero/core/source/context/context_imp.h

@@ -194,6 +194,9 @@ struct ContextImp : Context, NEO::NonCopyableAndNonMovableClass {
     ContextExt *getContextExt() override {
         return contextExt;
     }
+    uint32_t getNumDevices() const {
+        return numDevices;
+    }
 
   protected:
     ze_result_t getIpcMemHandlesImpl(const void *ptr, uint32_t *numIpcHandles, ze_ipc_mem_handle_t *pIpcHandles);

level_zero/core/source/device/device_imp.cpp

@@ -837,10 +837,13 @@ ze_result_t DeviceImp::getMemoryAccessProperties(ze_device_memory_access_propert
     pMemAccessProperties->sharedSingleDeviceAllocCapabilities =
         static_cast<ze_memory_access_cap_flags_t>(productHelper.getSingleDeviceSharedMemCapabilities(isKmdMigrationAvailable));
 
+    auto defaultContext = static_cast<ContextImp *>(getDriverHandle()->getDefaultContext());
+    auto multiDeviceWithSingleRoot = defaultContext->getNumDevices() > 1 && defaultContext->rootDeviceIndices.size() == 1;
+
     pMemAccessProperties->sharedCrossDeviceAllocCapabilities = {};
-    if (isKmdMigrationAvailable &&
-        memoryManager->hasPageFaultsEnabled(*this->getNEODevice()) &&
-        NEO::debugManager.flags.EnableConcurrentSharedCrossP2PDeviceAccess.get() == 1) {
+    if (multiDeviceWithSingleRoot || (isKmdMigrationAvailable &&
+                                      memoryManager->hasPageFaultsEnabled(*this->getNEODevice()) &&
+                                      NEO::debugManager.flags.EnableConcurrentSharedCrossP2PDeviceAccess.get() == 1)) {
         pMemAccessProperties->sharedCrossDeviceAllocCapabilities = ZE_MEMORY_ACCESS_CAP_FLAG_RW |
                                                                    ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT |
                                                                    ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC |

level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp

@@ -3036,6 +3036,62 @@ TEST_F(MemoryAccessPropertiesSharedCrossDeviceCapsTest,
     EXPECT_EQ(expectedSharedCrossDeviceAllocCapabilities, properties.sharedCrossDeviceAllocCapabilities);
 }
 
+struct MemoryAccessPropertiesMultiDevicesSingleRootDeviceTest : public Test<MultiDeviceFixtureHierarchy> {
+    void SetUp() override {
+        this->deviceHierarchyMode = NEO::DeviceHierarchyMode::flat;
+        this->numRootDevices = 1;
+        MultiDeviceFixtureHierarchy::setUp();
+    }
+};
+TEST_F(MemoryAccessPropertiesMultiDevicesSingleRootDeviceTest,
+       givenSingleRootAndMultiDevicesWhenCallingGetMemoryAccessPropertiesThenSharedCrossDeviceAccessSupportIsReturned) {
+    L0::Device *device = driverHandle->devices[0];
+    ze_device_memory_access_properties_t properties;
+    auto result = device->getMemoryAccessProperties(&properties);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_memory_access_cap_flags_t expectedSharedCrossDeviceAllocCapabilities =
+        ZE_MEMORY_ACCESS_CAP_FLAG_RW | ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT |
+        ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC | ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT_ATOMIC;
+    EXPECT_EQ(expectedSharedCrossDeviceAllocCapabilities, properties.sharedCrossDeviceAllocCapabilities);
+}
+
+struct MemoryAccessPropertiesMultiDevicesMultiRootDeviceTest : public Test<MultiDeviceFixtureHierarchy> {
+    void SetUp() override {
+        this->deviceHierarchyMode = NEO::DeviceHierarchyMode::flat;
+        this->numRootDevices = 2;
+        MultiDeviceFixtureHierarchy::setUp();
+    }
+};
+TEST_F(MemoryAccessPropertiesMultiDevicesMultiRootDeviceTest,
+       givenMultiRootAndMultiSubDevicesWhenCallingGetMemoryAccessPropertiesThenSharedCrossDeviceAccessSupportIsNotExposed) {
+    L0::Device *device = driverHandle->devices[0];
+    ze_device_memory_access_properties_t properties;
+    auto result = device->getMemoryAccessProperties(&properties);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_memory_access_cap_flags_t expectedSharedCrossDeviceAllocCapabilities = 0;
+    EXPECT_EQ(expectedSharedCrossDeviceAllocCapabilities, properties.sharedCrossDeviceAllocCapabilities);
+}
+
+struct MemoryAccessPropertiesSingleExposedDeviceTest : public Test<MultiDeviceFixtureHierarchy> {
+    void SetUp() override {
+        this->deviceHierarchyMode = NEO::DeviceHierarchyMode::composite;
+        this->numRootDevices = 1;
+        MultiDeviceFixtureHierarchy::setUp();
+    }
+};
+TEST_F(MemoryAccessPropertiesSingleExposedDeviceTest,
+       givenSingleExposedDevicesWhenCallingGetMemoryAccessPropertiesThenSharedCrossDeviceAccessSupportIsNotExposed) {
+    L0::Device *device = driverHandle->devices[0];
+    ze_device_memory_access_properties_t properties;
+    auto result = device->getMemoryAccessProperties(&properties);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    ze_memory_access_cap_flags_t expectedSharedCrossDeviceAllocCapabilities = 0;
+    EXPECT_EQ(expectedSharedCrossDeviceAllocCapabilities, properties.sharedCrossDeviceAllocCapabilities);
+}
+
 using MultipleDevicesP2PDevice0Access0Atomic0Device1Access0Atomic0Test = MultipleDevicesP2PFixture<0, 0>;
 TEST_F(MultipleDevicesP2PDevice0Access0Atomic0Device1Access0Atomic0Test, WhenCallingGetP2PPropertiesWithBothDevicesHavingNoAccessSupportThenNoSupportIsReturned) {
     L0::Device *device0 = driverHandle->devices[0];