Make enableLocalMemory and enable64kbpages flags root device specific

LukaszJobczyk · Compute-Runtime-Automation · commit 70322b858f2e · 2020-02-18T11:22:21.000+01:00
Change-Id: I2f0c601bae83a1c4b69fb2ee04255e1d73c1ab7f
Signed-off-by: Jobczyk, Lukasz &lt;lukasz.jobczyk@intel.com&gt;
diff --git a/core/memory_manager/memory_manager.cpp b/core/memory_manager/memory_manager.cpp
@@ -36,18 +36,23 @@ uint32_t MemoryManager::maxOsContextCount = 0u;
 MemoryManager::MemoryManager(ExecutionEnvironment &executionEnvironment) : executionEnvironment(executionEnvironment), hostPtrManager(std::make_unique<HostPtrManager>()),
                                                                            multiContextResourceDestructor(std::make_unique<DeferredDeleter>()) {
     auto hwInfo = executionEnvironment.getHardwareInfo();
-    this->localMemorySupported = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getEnableLocalMemory(*hwInfo);
-    this->enable64kbpages = OSInterface::osEnabled64kbPages && hwInfo->capabilityTable.ftr64KBpages;
-    if (DebugManager.flags.Enable64kbpages.get() > -1) {
-        this->enable64kbpages = DebugManager.flags.Enable64kbpages.get() != 0;
-    }
     localMemoryUsageBankSelector.reset(new LocalMemoryUsageBankSelector(getBanksCount()));
 
+    bool anyLocalMemorySupported = false;
+
     for (uint32_t rootDeviceIndex = 0; rootDeviceIndex < executionEnvironment.rootDeviceEnvironments.size(); ++rootDeviceIndex) {
+        this->localMemorySupported.push_back(HwHelper::get(hwInfo->platform.eRenderCoreFamily).getEnableLocalMemory(*hwInfo));
+        this->enable64kbpages.push_back(OSInterface::osEnabled64kbPages && hwInfo->capabilityTable.ftr64KBpages);
+        if (DebugManager.flags.Enable64kbpages.get() > -1) {
+            this->enable64kbpages[rootDeviceIndex] = DebugManager.flags.Enable64kbpages.get() != 0;
+        }
+
         gfxPartitions.push_back(std::make_unique<GfxPartition>());
+
+        anyLocalMemorySupported |= this->localMemorySupported[rootDeviceIndex];
     }
 
-    if (this->localMemorySupported) {
+    if (anyLocalMemorySupported) {
         pageFaultManager = PageFaultManager::create();
     }
 }
@@ -181,8 +186,12 @@ bool MemoryManager::isAsyncDeleterEnabled() const {
     return asyncDeleterEnabled;
 }
 
-bool MemoryManager::isLocalMemorySupported() const {
-    return localMemorySupported;
+bool MemoryManager::isLocalMemorySupported(uint32_t rootDeviceIndex) const {
+    return localMemorySupported[rootDeviceIndex];
+}
+
+bool MemoryManager::peek64kbPagesEnabled(uint32_t rootDeviceIndex) const {
+    return enable64kbpages[rootDeviceIndex];
 }
 
 bool MemoryManager::isMemoryBudgetExhausted() const {
@@ -361,7 +370,7 @@ GraphicsAllocation *MemoryManager::allocateGraphicsMemory(const AllocationData &
     if (allocationData.hostPtr) {
         return allocateGraphicsMemoryWithHostPtr(allocationData);
     }
-    if (peek64kbPagesEnabled() && allocationData.flags.allow64kbPages) {
+    if (peek64kbPagesEnabled(allocationData.rootDeviceIndex) && allocationData.flags.allow64kbPages) {
         return allocateGraphicsMemory64kb(allocationData);
     }
     return allocateGraphicsMemoryWithAlignment(allocationData);
diff --git a/core/memory_manager/memory_manager.h b/core/memory_manager/memory_manager.h
@@ -103,7 +103,7 @@ class MemoryManager {
 
     bool isLimitedRange(uint32_t rootDeviceIndex) { return getGfxPartition(rootDeviceIndex)->isLimitedRange(); }
 
-    bool peek64kbPagesEnabled() const { return enable64kbpages; }
+    bool peek64kbPagesEnabled(uint32_t rootDeviceIndex) const;
     bool peekForce32BitAllocations() const { return force32bitAllocations; }
     void setForce32BitAllocations(bool newValue) { force32bitAllocations = newValue; }
 
@@ -123,7 +123,7 @@ class MemoryManager {
     void cleanTemporaryAllocationListOnAllEngines(bool waitForCompletion);
 
     bool isAsyncDeleterEnabled() const;
-    bool isLocalMemorySupported() const;
+    bool isLocalMemorySupported(uint32_t rootDeviceIndex) const;
     virtual bool isMemoryBudgetExhausted() const;
 
     virtual AlignedMallocRestrictions *getAlignedMallocRestrictions() {
@@ -237,8 +237,8 @@ class MemoryManager {
     bool virtualPaddingAvailable = false;
     std::unique_ptr<DeferredDeleter> deferredDeleter;
     bool asyncDeleterEnabled = false;
-    bool enable64kbpages = false;
-    bool localMemorySupported = false;
+    std::vector<bool> enable64kbpages;
+    std::vector<bool> localMemorySupported;
     bool supportsMultiStorageResources = true;
     ExecutionEnvironment &executionEnvironment;
     EngineControlContainer registeredEngines;
diff --git a/core/memory_manager/unified_memory_manager.cpp b/core/memory_manager/unified_memory_manager.cpp
@@ -85,7 +85,7 @@ void *SVMAllocsManager::createSVMAlloc(uint32_t rootDeviceIndex, size_t size, co
         return nullptr;
 
     std::unique_lock<SpinLock> lock(mtx);
-    if (!memoryManager->isLocalMemorySupported()) {
+    if (!memoryManager->isLocalMemorySupported(rootDeviceIndex)) {
         return createZeroCopySvmAllocation(rootDeviceIndex, size, svmProperties);
     } else {
         return createUnifiedAllocationWithDeviceStorage(rootDeviceIndex, size, svmProperties, {});
@@ -132,7 +132,7 @@ void *SVMAllocsManager::createUnifiedMemoryAllocation(uint32_t rootDeviceIndex,
 }
 
 void *SVMAllocsManager::createSharedUnifiedMemoryAllocation(uint32_t rootDeviceIndex, size_t size, const UnifiedMemoryProperties &memoryProperties, void *cmdQ) {
-    auto supportDualStorageSharedMemory = memoryManager->isLocalMemorySupported();
+    auto supportDualStorageSharedMemory = memoryManager->isLocalMemorySupported(rootDeviceIndex);
 
     if (DebugManager.flags.AllocateSharedAllocationsWithCpuAndGpuStorage.get() != -1) {
         supportDualStorageSharedMemory = !!DebugManager.flags.AllocateSharedAllocationsWithCpuAndGpuStorage.get();
diff --git a/runtime/device/device_caps.cpp b/runtime/device/device_caps.cpp
@@ -237,7 +237,7 @@ void Device::initializeCaps() {
     deviceInfo.globalMemCacheSize = systemInfo.L3BankCount * 128 * KB;
     deviceInfo.grfSize = hwInfo.capabilityTable.grfSize;
 
-    deviceInfo.globalMemSize = getMemoryManager()->isLocalMemorySupported()
+    deviceInfo.globalMemSize = getMemoryManager()->isLocalMemorySupported(this->getRootDeviceIndex())
                                    ? getMemoryManager()->getLocalMemorySize(this->getRootDeviceIndex())
                                    : getMemoryManager()->getSystemSharedMemory(this->getRootDeviceIndex());
     deviceInfo.globalMemSize = std::min(deviceInfo.globalMemSize, (cl_ulong)(getMemoryManager()->getMaxApplicationAddress() + 1));
diff --git a/runtime/mem_obj/buffer.cpp b/runtime/mem_obj/buffer.cpp
@@ -149,14 +149,15 @@ Buffer *Buffer::create(Context *context,
     bool alignementSatisfied = true;
     bool allocateMemory = true;
     bool copyMemoryFromHostPtr = false;
+    auto rootDeviceIndex = context->getDevice(0)->getRootDeviceIndex();
     MemoryManager *memoryManager = context->getMemoryManager();
     UNRECOVERABLE_IF(!memoryManager);
 
     GraphicsAllocation::AllocationType allocationType = getGraphicsAllocationType(
         memoryProperties,
         *context,
         HwHelper::renderCompressedBuffersSupported(context->getDevice(0)->getHardwareInfo()),
-        memoryManager->isLocalMemorySupported(),
+        memoryManager->isLocalMemorySupported(rootDeviceIndex),
         HwHelper::get(context->getDevice(0)->getHardwareInfo().platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(context->getDevice(0)->getHardwareInfo(), size));
 
     checkMemory(memoryProperties, size, hostPtr, errcodeRet, alignementSatisfied, copyMemoryFromHostPtr, memoryManager);
@@ -225,7 +226,6 @@ Buffer *Buffer::create(Context *context,
         context->providePerformanceHint(CL_CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL, CL_BUFFER_NEEDS_ALLOCATE_MEMORY);
     }
 
-    auto rootDeviceIndex = context->getDevice(0)->getRootDeviceIndex();
     if (!memory) {
         AllocationProperties allocProperties = MemoryPropertiesParser::getAllocationProperties(rootDeviceIndex, memoryProperties, allocateMemory, size, allocationType, context->areMultiStorageAllocationsPreferred());
         memory = memoryManager->allocateGraphicsMemoryWithProperties(allocProperties, hostPtr);
diff --git a/unit_tests/context/driver_diagnostics_tests.cpp b/unit_tests/context/driver_diagnostics_tests.cpp
@@ -504,7 +504,7 @@ TEST_F(PerformanceHintTest, givenUncompressedBufferWhenItsCreatedThenProperPerfo
                            memoryProperties, *context,
                            HwHelper::get(hwInfo.platform.eRenderCoreFamily).obtainRenderBufferCompressionPreference(hwInfo, size)) &&
                        !is32bit && !context->isSharedContext &&
-                       (!memoryProperties.flags.useHostPtr || context->getMemoryManager()->isLocalMemorySupported()) &&
+                       (!memoryProperties.flags.useHostPtr || context->getMemoryManager()->isLocalMemorySupported(device->getRootDeviceIndex())) &&
                        !memoryProperties.flags.forceSharedPhysicalMemory;
 
         buffer = std::unique_ptr<Buffer>(Buffer::create(context.get(), memoryProperties, CL_MEM_READ_WRITE, 0, size, static_cast<void *>(NULL), retVal));
diff --git a/unit_tests/device/device_caps_tests.cpp b/unit_tests/device/device_caps_tests.cpp
@@ -1024,30 +1024,30 @@ TEST_F(DeviceGetCapsTest, GivenFlagEnabled64kbPagesWhenSetThenReturnCorrectValue
     capabilityTable.ftr64KBpages = false;
     OSInterface::osEnabled64kbPages = false;
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled(0u));
 
     capabilityTable.ftr64KBpages = false;
     OSInterface::osEnabled64kbPages = true;
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled(0u));
 
     capabilityTable.ftr64KBpages = true;
     OSInterface::osEnabled64kbPages = false;
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled(0u));
 
     capabilityTable.ftr64KBpages = true;
     OSInterface::osEnabled64kbPages = true;
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_TRUE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_TRUE(memoryManager->peek64kbPagesEnabled(0u));
 
     DebugManager.flags.Enable64kbpages.set(0); // force false
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_FALSE(memoryManager->peek64kbPagesEnabled(0u));
 
     DebugManager.flags.Enable64kbpages.set(1); // force true
     memoryManager.reset(new OsAgnosticMemoryManager(executionEnvironment));
-    EXPECT_TRUE(memoryManager->peek64kbPagesEnabled());
+    EXPECT_TRUE(memoryManager->peek64kbPagesEnabled(0u));
 }
 
 TEST_F(DeviceGetCapsTest, givenUnifiedMemoryShardeSystemFlagWhenDeviceIsCreatedItContainsProperSystemMemorySetting) {
diff --git a/unit_tests/execution_environment/execution_environment_tests.cpp b/unit_tests/execution_environment/execution_environment_tests.cpp
@@ -141,7 +141,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerI
     auto executionEnvironment = device->getExecutionEnvironment();
     auto enableLocalMemory = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getEnableLocalMemory(*hwInfo);
     executionEnvironment->initializeMemoryManager();
-    EXPECT_EQ(enableLocalMemory, executionEnvironment->memoryManager->isLocalMemorySupported());
+    EXPECT_EQ(enableLocalMemory, executionEnvironment->memoryManager->isLocalMemorySupported(device->getRootDeviceIndex()));
 }
 
 TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
diff --git a/unit_tests/mocks/mock_memory_manager.cpp b/unit_tests/mocks/mock_memory_manager.cpp
@@ -80,7 +80,7 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemoryInDevicePool(const
     auto allocation = OsAgnosticMemoryManager::allocateGraphicsMemoryInDevicePool(allocationData, status);
     if (allocation) {
         allocationInDevicePoolCreated = true;
-        if (localMemorySupported) {
+        if (localMemorySupported[allocation->getRootDeviceIndex()]) {
             static_cast<MemoryAllocation *>(allocation)->overrideMemoryPool(MemoryPool::LocalMemory);
         }
     }
diff --git a/unit_tests/mocks/mock_memory_manager.h b/unit_tests/mocks/mock_memory_manager.h
@@ -23,8 +23,8 @@ class MemoryManagerCreate : public T {
 
     template <class... U>
     MemoryManagerCreate(bool enable64kbPages, bool enableLocalMemory, U &&... args) : T(std::forward<U>(args)...) {
-        this->enable64kbpages = enable64kbPages;
-        this->localMemorySupported = enableLocalMemory;
+        std::fill(this->enable64kbpages.begin(), this->enable64kbpages.end(), enable64kbPages);
+        std::fill(this->localMemorySupported.begin(), this->localMemorySupported.end(), enableLocalMemory);
     }
 };
 

Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerI`
`141`	`141`	`auto executionEnvironment = device->getExecutionEnvironment();`
`142`	`142`	`auto enableLocalMemory = HwHelper::get(hwInfo->platform.eRenderCoreFamily).getEnableLocalMemory(*hwInfo);`
`143`	`143`	`executionEnvironment->initializeMemoryManager();`
`144`		`- EXPECT_EQ(enableLocalMemory, executionEnvironment->memoryManager->isLocalMemorySupported());`
	`144`	`+ EXPECT_EQ(enableLocalMemory, executionEnvironment->memoryManager->isLocalMemorySupported(device->getRootDeviceIndex()));`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemoryInDevicePool(const`
`80`	`80`	`auto allocation = OsAgnosticMemoryManager::allocateGraphicsMemoryInDevicePool(allocationData, status);`
`81`	`81`	`if (allocation) {`
`82`	`82`	`allocationInDevicePoolCreated = true;`
`83`		`- if (localMemorySupported) {`
	`83`	`+ if (localMemorySupported[allocation->getRootDeviceIndex()]) {`
`84`	`84`	`static_cast<MemoryAllocation *>(allocation)->overrideMemoryPool(MemoryPool::LocalMemory);`
`85`	`85`	`}`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,8 @@ class MemoryManagerCreate : public T {`
`23`	`23`
`24`	`24`	`template <class... U>`
`25`	`25`	`MemoryManagerCreate(bool enable64kbPages, bool enableLocalMemory, U &&... args) : T(std::forward<U>(args)...) {`
`26`		`- this->enable64kbpages = enable64kbPages;`
`27`		`- this->localMemorySupported = enableLocalMemory;`
	`26`	`+ std::fill(this->enable64kbpages.begin(), this->enable64kbpages.end(), enable64kbPages);`
	`27`	`+ std::fill(this->localMemorySupported.begin(), this->localMemorySupported.end(), enableLocalMemory);`
`28`	`28`	`}`
`29`	`29`	`};`
`30`	`30`