diff --git a/Jenkinsfile b/Jenkinsfile
index 63b7759d3f..27f2ecb91b 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -1,5 +1,5 @@
 #!groovy
 neoDependenciesRev='800243-1090'
 strategy='EQUAL'
-allowedCD=272
+allowedCD=274
 allowedF=4
diff --git a/runtime/command_stream/aub_command_stream_receiver_hw.h b/runtime/command_stream/aub_command_stream_receiver_hw.h
index 6601f0f744..b0ce1e2171 100644
--- a/runtime/command_stream/aub_command_stream_receiver_hw.h
+++ b/runtime/command_stream/aub_command_stream_receiver_hw.h
@@ -69,7 +69,7 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw<GfxFa
     void freeEngineInfoTable();
 
     MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override {
-        this->memoryManager = new OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory);
+        this->memoryManager = new OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory, true);
         this->flatBatchBufferHelper->setMemoryManager(this->memoryManager);
         return this->memoryManager;
     }
diff --git a/runtime/memory_manager/os_agnostic_memory_manager.cpp b/runtime/memory_manager/os_agnostic_memory_manager.cpp
index 381194d8e9..78dd61457d 100644
--- a/runtime/memory_manager/os_agnostic_memory_manager.cpp
+++ b/runtime/memory_manager/os_agnostic_memory_manager.cpp
@@ -89,11 +89,12 @@ GraphicsAllocation *OsAgnosticMemoryManager::allocate32BitGraphicsMemory(size_t
 
     auto allocationSize = alignUp(size, MemoryConstants::pageSize);
     void *ptrAlloc = nullptr;
-
-    if (size < 0xfffff000)
-        ptrAlloc = alignedMallocWrapper(allocationSize, MemoryConstants::allocationAlignment);
     auto gpuAddress = allocator32Bit->allocate(allocationSize);
 
+    if (size < 0xfffff000) {
+        ptrAlloc = alignedMallocWrapper(allocationSize, MemoryConstants::allocationAlignment);
+    }
+
     MemoryAllocation *memoryAllocation = nullptr;
     if (ptrAlloc != nullptr) {
         memoryAllocation = new MemoryAllocation(true, ptrAlloc, GmmHelper::canonize(gpuAddress), size, counter, MemoryPool::System4KBPagesWith32BitGpuAddressing);
@@ -227,4 +228,18 @@ GraphicsAllocation *OsAgnosticMemoryManager::allocateGraphicsMemoryForImage(Imag
 
     return alloc;
 }
+
+Allocator32bit *OsAgnosticMemoryManager::create32BitAllocator(bool aubUsage) {
+    uint64_t allocatorSize = MemoryConstants::gigaByte - 2 * 4096;
+    uint64_t heap32Base = 0x80000000000ul;
+
+    if (is64bit && this->localMemorySupported && aubUsage) {
+        heap32Base = 0x40000000000ul;
+    }
+
+    if (is32bit) {
+        heap32Base = 0x0;
+    }
+    return new Allocator32bit(heap32Base, allocatorSize);
+}
 } // namespace OCLRT
diff --git a/runtime/memory_manager/os_agnostic_memory_manager.h b/runtime/memory_manager/os_agnostic_memory_manager.h
index 1459de5cf9..fd2c089bcf 100644
--- a/runtime/memory_manager/os_agnostic_memory_manager.h
+++ b/runtime/memory_manager/os_agnostic_memory_manager.h
@@ -38,13 +38,12 @@ class OsAgnosticMemoryManager : public MemoryManager {
     using MemoryManager::createGraphicsAllocationFromSharedHandle;
 
     OsAgnosticMemoryManager() : OsAgnosticMemoryManager(false, false){};
-    OsAgnosticMemoryManager(bool enable64kbPages, bool enableLocalMemory) : MemoryManager(enable64kbPages, enableLocalMemory) {
-        uint64_t heap32Base = 0x80000000000ul;
-        if (sizeof(uintptr_t) == 4) {
-            heap32Base = 0x0;
-        }
-        allocator32Bit = std::unique_ptr<Allocator32bit>(new Allocator32bit(heap32Base, GB - 2 * 4096));
+    OsAgnosticMemoryManager(bool enable64kbPages, bool enableLocalMemory) : OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory, false){};
+
+    OsAgnosticMemoryManager(bool enable64kbPages, bool enableLocalMemory, bool aubUsage) : MemoryManager(enable64kbPages, enableLocalMemory) {
+        allocator32Bit = std::unique_ptr<Allocator32bit>(create32BitAllocator(aubUsage));
     };
+
     ~OsAgnosticMemoryManager() override;
     GraphicsAllocation *allocateGraphicsMemory(size_t size, size_t alignment, bool forcePin, bool uncacheable) override;
     GraphicsAllocation *allocateGraphicsMemory64kb(size_t size, size_t alignment, bool forcePin, bool preferRenderCompressed) override;
@@ -72,6 +71,8 @@ class OsAgnosticMemoryManager : public MemoryManager {
 
     void turnOnFakingBigAllocations();
 
+    Allocator32bit *create32BitAllocator(bool enableLocalMemory);
+
   private:
     unsigned long long counter = 0;
     bool fakeBigAllocations = false;
diff --git a/unit_tests/memory_manager/memory_manager_tests.cpp b/unit_tests/memory_manager/memory_manager_tests.cpp
index 5d9ccab205..47a0090437 100644
--- a/unit_tests/memory_manager/memory_manager_tests.cpp
+++ b/unit_tests/memory_manager/memory_manager_tests.cpp
@@ -8,6 +8,7 @@
 #include "runtime/event/event.h"
 #include "runtime/helpers/dispatch_info.h"
 #include "runtime/helpers/timestamp_packet.h"
+#include "runtime/memory_manager/memory_constants.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/os_interface/os_context.h"
 #include "runtime/os_interface/os_interface.h"
@@ -1288,6 +1289,48 @@ TEST(OsAgnosticMemoryManager, givenFullGpuAddressSpaceWhenAllocateGraphicsMemory
     memoryManager.freeGraphicsMemory(allocation);
 }
 
+TEST(OsAgnosticMemoryManager, givenLocalMemoryNotSupportedWhenMemoryManagerIsCreatedThenAllocator32BitHasCorrectBaseAddress) {
+    MockMemoryManager memoryManager(false, false, false);
+    uint64_t heap32Base = 0x80000000000ul;
+
+    if (is32bit) {
+        heap32Base = 0;
+    }
+    EXPECT_EQ(heap32Base, memoryManager.allocator32Bit->getBase());
+}
+
+TEST(OsAgnosticMemoryManager, givenLocalMemorySupportedAndNotAubUsageWhenMemoryManagerIsCreatedThenAllocator32BitHasCorrectBaseAddress) {
+    MockMemoryManager memoryManager(false, true, false);
+    uint64_t heap32Base = 0x80000000000ul;
+
+    if (is32bit) {
+        heap32Base = 0;
+    }
+    EXPECT_EQ(heap32Base, memoryManager.allocator32Bit->getBase());
+}
+
+TEST(OsAgnosticMemoryManager, givenLocalMemoryNotSupportedAndAubUsageWhenMemoryManagerIsCreatedThenAllocator32BitHasCorrectBaseAddress) {
+    MockMemoryManager memoryManager(false, false, true);
+    uint64_t heap32Base = 0x80000000000ul;
+
+    if (is32bit) {
+        heap32Base = 0;
+    }
+    EXPECT_EQ(heap32Base, memoryManager.allocator32Bit->getBase());
+}
+
+TEST(OsAgnosticMemoryManager, givenLocalMemorySupportedAndAubUsageWhenMemoryManagerIsCreatedThenAllocator32BitHasCorrectBaseAddress) {
+    MockMemoryManager memoryManager(false, true, true);
+    uint64_t heap32Base = 0x80000000000ul;
+
+    if (is32bit) {
+        heap32Base = 0;
+    } else {
+        heap32Base = 0x40000000000ul;
+    }
+    EXPECT_EQ(heap32Base, memoryManager.allocator32Bit->getBase());
+}
+
 TEST_F(MemoryAllocatorTest, GivenSizeWhenGmmIsCreatedThenSuccess) {
     Gmm *gmm = new Gmm(nullptr, 65536, false);
     EXPECT_NE(nullptr, gmm);
diff --git a/unit_tests/mocks/mock_memory_manager.h b/unit_tests/mocks/mock_memory_manager.h
index a4f224d5e2..6d3f36be7d 100644
--- a/unit_tests/mocks/mock_memory_manager.h
+++ b/unit_tests/mocks/mock_memory_manager.h
@@ -21,6 +21,8 @@ class MockMemoryManager : public OsAgnosticMemoryManager {
 
     MockMemoryManager() : OsAgnosticMemoryManager(false, false){};
     MockMemoryManager(bool enable64pages) : OsAgnosticMemoryManager(enable64pages, false) {}
+    MockMemoryManager(bool enable64kbPages, bool enableLocalMemory, bool aubUsage) : OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory, aubUsage) {}
+
     GraphicsAllocation *allocateGraphicsMemory64kb(size_t size, size_t alignment, bool forcePin, bool preferRenderCompressed) override;
     void setDeferredDeleter(DeferredDeleter *deleter);
     void overrideAsyncDeleterFlag(bool newValue);