intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-22 01:48:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add local memory usage selector in memory manager

Browse Source 
Related-To: NEO-2906

Change-Id: I3172e9551b8d06437c273b122dc6e9d529155b5c
Signed-off-by: Pawel Wilma <pawel.wilma@intel.com>
This commit is contained in:
Pawel Wilma
2019-05-10 11:30:07 +02:00
committed by sys_ocldev
parent a90270c1de
commit b64210d3db
17 changed files with 205 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/memory_manager/CMakeLists.txt
View File

@@ -33,6 +33,7 @@ set(RUNTIME_SRCS_MEMORY_MANAGER
${CMAKE_CURRENT_SOURCE_DIR}/memory_constants.h ${CMAKE_CURRENT_SOURCE_DIR}/memory_constants.h
${CMAKE_CURRENT_SOURCE_DIR}/memory_manager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/memory_manager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/memory_manager.h ${CMAKE_CURRENT_SOURCE_DIR}/memory_manager.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/memory_manager_banks_count.cpp
${CMAKE_CURRENT_SOURCE_DIR}/memory_pool.h ${CMAKE_CURRENT_SOURCE_DIR}/memory_pool.h
${CMAKE_CURRENT_SOURCE_DIR}/os_agnostic_memory_manager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/os_agnostic_memory_manager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_agnostic_memory_manager.h ${CMAKE_CURRENT_SOURCE_DIR}/os_agnostic_memory_manager.h

1
runtime/memory_manager/definitions/storage_info.h
View File

@@ -10,5 +10,6 @@
namespace NEO { namespace NEO {
struct StorageInfo { struct StorageInfo {
uint32_t getNumHandles() const; uint32_t getNumHandles() const;
uint32_t getMemoryBanks() const { return 0u; }
}; };
} // namespace NEO } // namespace NEO

14
runtime/memory_manager/local_memory_usage.cpp
View File

@@ -8,6 +8,7 @@
#include "runtime/memory_manager/local_memory_usage.h" #include "runtime/memory_manager/local_memory_usage.h"
#include <algorithm> #include <algorithm>
#include <bitset>
#include <iterator> #include <iterator>
namespace NEO { namespace NEO {
@@ -35,4 +36,17 @@ void LocalMemoryUsageBankSelector::reserveOnBank(uint32_t bankIndex, uint64_t al
memorySizes[bankIndex] += allocationSize; memorySizes[bankIndex] += allocationSize;
} }
void LocalMemoryUsageBankSelector::updateUsageInfo(uint32_t memoryBanks, uint64_t allocationSize, bool reserve) {
auto banks = std::bitset<32>(memoryBanks);
for (uint32_t bankIndex = 0; bankIndex < banks.size() && bankIndex < banksCount; bankIndex++) {
if (banks.test(bankIndex)) {
if (reserve) {
reserveOnBank(bankIndex, allocationSize);
} else {
freeOnBank(bankIndex, allocationSize);
}
}
}
}
} // namespace NEO } // namespace NEO

13
runtime/memory_manager/local_memory_usage.h
View File

@@ -19,10 +19,14 @@ class LocalMemoryUsageBankSelector : public NonCopyableOrMovableClass {
LocalMemoryUsageBankSelector() = delete; LocalMemoryUsageBankSelector() = delete;
LocalMemoryUsageBankSelector(uint32_t banksCount); LocalMemoryUsageBankSelector(uint32_t banksCount);
uint32_t getLeastOccupiedBank(); uint32_t getLeastOccupiedBank();
void freeOnBank(uint32_t bankIndex, uint64_t allocationSize); void reserveOnBanks(uint32_t memoryBanks, uint64_t allocationSize) {
void reserveOnBank(uint32_t bankIndex, uint64_t allocationSize); updateUsageInfo(memoryBanks, allocationSize, true);
}
void freeOnBanks(uint32_t memoryBanks, uint64_t allocationSize) {
updateUsageInfo(memoryBanks, allocationSize, false);
}
MOCKABLE_VIRTUAL uint64_t getOccupiedMemorySizeForBank(uint32_t bankIndex) { uint64_t getOccupiedMemorySizeForBank(uint32_t bankIndex) {
UNRECOVERABLE_IF(bankIndex >= banksCount); UNRECOVERABLE_IF(bankIndex >= banksCount);
return memorySizes[bankIndex].load(); return memorySizes[bankIndex].load();
} }
@@ -30,5 +34,8 @@ class LocalMemoryUsageBankSelector : public NonCopyableOrMovableClass {
protected: protected:
uint32_t banksCount = 0; uint32_t banksCount = 0;
std::unique_ptr<std::atomic<uint64_t>[]> memorySizes = nullptr; std::unique_ptr<std::atomic<uint64_t>[]> memorySizes = nullptr;
void updateUsageInfo(uint32_t memoryBanks, uint64_t allocationSize, bool reserve);
void freeOnBank(uint32_t bankIndex, uint64_t allocationSize);
void reserveOnBank(uint32_t bankIndex, uint64_t allocationSize);
}; };
} // namespace NEO } // namespace NEO

13
runtime/memory_manager/memory_manager.cpp
View File

@@ -25,6 +25,7 @@
#include "runtime/memory_manager/deferred_deleter.h" #include "runtime/memory_manager/deferred_deleter.h"
#include "runtime/memory_manager/host_ptr_manager.h" #include "runtime/memory_manager/host_ptr_manager.h"
#include "runtime/memory_manager/internal_allocation_storage.h" #include "runtime/memory_manager/internal_allocation_storage.h"
#include "runtime/memory_manager/local_memory_usage.h"
#include "runtime/os_interface/os_context.h" #include "runtime/os_interface/os_context.h"
#include "runtime/os_interface/os_interface.h" #include "runtime/os_interface/os_interface.h"
#include "runtime/utilities/stackvec.h" #include "runtime/utilities/stackvec.h"
@@ -40,6 +41,7 @@ MemoryManager::MemoryManager(ExecutionEnvironment &executionEnvironment) : execu
if (DebugManager.flags.Enable64kbpages.get() > -1) { if (DebugManager.flags.Enable64kbpages.get() > -1) {
this->enable64kbpages = DebugManager.flags.Enable64kbpages.get() != 0; this->enable64kbpages = DebugManager.flags.Enable64kbpages.get() != 0;
} }
localMemoryUsageBankSelector.reset(new LocalMemoryUsageBankSelector(getBanksCount()));
} }
MemoryManager::~MemoryManager() { MemoryManager::~MemoryManager() {
@@ -147,6 +149,8 @@ void MemoryManager::freeGraphicsMemory(GraphicsAllocation *gfxAllocation) {
if (isLocked) { if (isLocked) {
freeAssociatedResourceImpl(*gfxAllocation); freeAssociatedResourceImpl(*gfxAllocation);
} }
localMemoryUsageBankSelector->freeOnBanks(gfxAllocation->storageInfo.getMemoryBanks(), gfxAllocation->getUnderlyingBufferSize());
freeGraphicsMemoryImpl(gfxAllocation); freeGraphicsMemoryImpl(gfxAllocation);
} }
//if not in use destroy in place //if not in use destroy in place
@@ -201,7 +205,7 @@ OsContext *MemoryManager::createAndRegisterOsContext(CommandStreamReceiver *comm
return osContext; return osContext;
} }
bool MemoryManager::getAllocationData(AllocationData &allocationData, const AllocationProperties &properties, const void *hostPtr) { bool MemoryManager::getAllocationData(AllocationData &allocationData, const AllocationProperties &properties, const void *hostPtr, const StorageInfo &storageInfo) {
UNRECOVERABLE_IF(hostPtr == nullptr && !properties.flags.allocateMemory); UNRECOVERABLE_IF(hostPtr == nullptr && !properties.flags.allocateMemory);
UNRECOVERABLE_IF(properties.allocationType == GraphicsAllocation::AllocationType::UNKNOWN); UNRECOVERABLE_IF(properties.allocationType == GraphicsAllocation::AllocationType::UNKNOWN);
@@ -298,7 +302,7 @@ bool MemoryManager::getAllocationData(AllocationData &allocationData, const Allo
allocationData.hostPtr = hostPtr; allocationData.hostPtr = hostPtr;
allocationData.size = properties.size; allocationData.size = properties.size;
allocationData.type = properties.allocationType; allocationData.type = properties.allocationType;
allocationData.storageInfo = MemoryManager::createStorageInfoFromProperties(properties); allocationData.storageInfo = storageInfo;
allocationData.alignment = properties.alignment ? properties.alignment : MemoryConstants::preferredAlignment; allocationData.alignment = properties.alignment ? properties.alignment : MemoryConstants::preferredAlignment;
allocationData.imgInfo = properties.imgInfo; allocationData.imgInfo = properties.imgInfo;
@@ -310,10 +314,13 @@ bool MemoryManager::getAllocationData(AllocationData &allocationData, const Allo
GraphicsAllocation *MemoryManager::allocateGraphicsMemoryInPreferredPool(const AllocationProperties &properties, const void *hostPtr) { GraphicsAllocation *MemoryManager::allocateGraphicsMemoryInPreferredPool(const AllocationProperties &properties, const void *hostPtr) {
AllocationData allocationData; AllocationData allocationData;
getAllocationData(allocationData, properties, hostPtr); getAllocationData(allocationData, properties, hostPtr, createStorageInfoFromProperties(properties));
AllocationStatus status = AllocationStatus::Error; AllocationStatus status = AllocationStatus::Error;
GraphicsAllocation *allocation = allocateGraphicsMemoryInDevicePool(allocationData, status); GraphicsAllocation *allocation = allocateGraphicsMemoryInDevicePool(allocationData, status);
if (allocation) {
localMemoryUsageBankSelector->reserveOnBanks(allocationData.storageInfo.getMemoryBanks(), allocation->getUnderlyingBufferSize());
}
if (!allocation && status == AllocationStatus::RetryInNonDevicePool) { if (!allocation && status == AllocationStatus::RetryInNonDevicePool) {
allocation = allocateGraphicsMemory(allocationData); allocation = allocateGraphicsMemory(allocationData);
} }

7
runtime/memory_manager/memory_manager.h
View File

@@ -15,6 +15,7 @@
#include "runtime/memory_manager/gfx_partition.h" #include "runtime/memory_manager/gfx_partition.h"
#include "runtime/memory_manager/graphics_allocation.h" #include "runtime/memory_manager/graphics_allocation.h"
#include "runtime/memory_manager/host_ptr_defines.h" #include "runtime/memory_manager/host_ptr_defines.h"
#include "runtime/memory_manager/local_memory_usage.h"
#include "runtime/os_interface/32bit_memory.h" #include "runtime/os_interface/32bit_memory.h"
#include "engine_node.h" #include "engine_node.h"
@@ -183,12 +184,12 @@ class MemoryManager {
ImageInfo *imgInfo = nullptr; ImageInfo *imgInfo = nullptr;
}; };
static bool getAllocationData(AllocationData &allocationData, const AllocationProperties &properties, const void *hostPtr); static bool getAllocationData(AllocationData &allocationData, const AllocationProperties &properties, const void *hostPtr, const StorageInfo &storageInfo);
static bool useInternal32BitAllocator(GraphicsAllocation::AllocationType allocationType) { static bool useInternal32BitAllocator(GraphicsAllocation::AllocationType allocationType) {
return allocationType == GraphicsAllocation::AllocationType::KERNEL_ISA || return allocationType == GraphicsAllocation::AllocationType::KERNEL_ISA ||
allocationType == GraphicsAllocation::AllocationType::INTERNAL_HEAP; allocationType == GraphicsAllocation::AllocationType::INTERNAL_HEAP;
} }
static StorageInfo createStorageInfoFromProperties(const AllocationProperties &properties); StorageInfo createStorageInfoFromProperties(const AllocationProperties &properties);
virtual GraphicsAllocation *createGraphicsAllocation(OsHandleStorage &handleStorage, const AllocationData &allocationData) = 0; virtual GraphicsAllocation *createGraphicsAllocation(OsHandleStorage &handleStorage, const AllocationData &allocationData) = 0;
virtual GraphicsAllocation *allocateGraphicsMemoryForNonSvmHostPtr(const AllocationData &allocationData) = 0; virtual GraphicsAllocation *allocateGraphicsMemoryForNonSvmHostPtr(const AllocationData &allocationData) = 0;
@@ -243,6 +244,7 @@ class MemoryManager {
virtual void *lockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0; virtual void *lockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0;
virtual void unlockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0; virtual void unlockResourceImpl(GraphicsAllocation &graphicsAllocation) = 0;
virtual void freeAssociatedResourceImpl(GraphicsAllocation &graphicsAllocation) { return unlockResourceImpl(graphicsAllocation); }; virtual void freeAssociatedResourceImpl(GraphicsAllocation &graphicsAllocation) { return unlockResourceImpl(graphicsAllocation); };
uint32_t getBanksCount();
bool force32bitAllocations = false; bool force32bitAllocations = false;
bool virtualPaddingAvailable = false; bool virtualPaddingAvailable = false;
@@ -260,6 +262,7 @@ class MemoryManager {
std::unique_ptr<DeferredDeleter> multiContextResourceDestructor; std::unique_ptr<DeferredDeleter> multiContextResourceDestructor;
std::unique_ptr<Allocator32bit> allocator32Bit; std::unique_ptr<Allocator32bit> allocator32Bit;
GfxPartition gfxPartition; GfxPartition gfxPartition;
std::unique_ptr<LocalMemoryUsageBankSelector> localMemoryUsageBankSelector;
}; };
std::unique_ptr<DeferredDeleter> createDeferredDeleter(); std::unique_ptr<DeferredDeleter> createDeferredDeleter();

14
runtime/memory_manager/memory_manager_banks_count.cpp Normal file
View File

@@ -0,0 +1,14 @@
/*
* Copyright (C) 2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/memory_manager/memory_manager.h"
namespace NEO {
uint32_t MemoryManager::getBanksCount() {
return 1u;
}
} // namespace NEO

8
unit_tests/helpers/hw_helper_tests.cpp
View File

@@ -26,14 +26,6 @@
using namespace NEO; using namespace NEO;
void HwHelperFixture::SetUp() {
hardwareInfo = *platformDevices[0];
DeviceFixture::SetUp();
}
void HwHelperFixture::TearDown() {
DeviceFixture::TearDown();
}
TEST(HwHelperSimpleTest, givenDebugVariableWhenAskingForRenderCompressionThenReturnCorrectValue) { TEST(HwHelperSimpleTest, givenDebugVariableWhenAskingForRenderCompressionThenReturnCorrectValue) {
DebugManagerStateRestore restore; DebugManagerStateRestore restore;
HardwareInfo localHwInfo = **platformDevices; HardwareInfo localHwInfo = **platformDevices;

9
unit_tests/helpers/hw_helper_tests.h
View File

@@ -14,13 +14,6 @@
using namespace NEO; using namespace NEO;
class HwHelperFixture : public DeviceFixture { using HwHelperTest = Test<DeviceFixture>;
protected:
void SetUp();
void TearDown();
HardwareInfo hardwareInfo;
};
using HwHelperTest = Test<HwHelperFixture>;
void testDefaultImplementationOfSetupHardwareCapabilities(HwHelper &hwHelper, const HardwareInfo &hwInfo); void testDefaultImplementationOfSetupHardwareCapabilities(HwHelper &hwHelper, const HardwareInfo &hwInfo);

57
unit_tests/memory_manager/local_memory_usage_tests.cpp
View File

@@ -14,7 +14,10 @@ namespace NEO {
struct MockLocalMemoryUsageBankSelector : public LocalMemoryUsageBankSelector { struct MockLocalMemoryUsageBankSelector : public LocalMemoryUsageBankSelector {
using LocalMemoryUsageBankSelector::banksCount; using LocalMemoryUsageBankSelector::banksCount;
using LocalMemoryUsageBankSelector::freeOnBank;
using LocalMemoryUsageBankSelector::LocalMemoryUsageBankSelector; using LocalMemoryUsageBankSelector::LocalMemoryUsageBankSelector;
using LocalMemoryUsageBankSelector::reserveOnBank;
using LocalMemoryUsageBankSelector::updateUsageInfo;
std::atomic<uint64_t> *getMemorySizes() { return memorySizes.get(); } std::atomic<uint64_t> *getMemorySizes() { return memorySizes.get(); }
}; };
@@ -27,7 +30,7 @@ TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenItsCreatedAllVal
} }
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryIsReservedOnGivenBankThenValueStoredInTheArrayIsCorrect) { TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryIsReservedOnGivenBankThenValueStoredInTheArrayIsCorrect) {
LocalMemoryUsageBankSelector selector(4u); MockLocalMemoryUsageBankSelector selector(4u);
uint64_t allocationSize = 1024u; uint64_t allocationSize = 1024u;
auto bankIndex = selector.getLeastOccupiedBank(); auto bankIndex = selector.getLeastOccupiedBank();
@@ -37,7 +40,7 @@ TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryIsReserved
} }
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryIsReleasedThenValueIsCorrectlyAllocated) { TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryIsReleasedThenValueIsCorrectlyAllocated) {
LocalMemoryUsageBankSelector selector(1u); MockLocalMemoryUsageBankSelector selector(1u);
uint64_t allocationSize = 1024u; uint64_t allocationSize = 1024u;
auto bankIndex = selector.getLeastOccupiedBank(); auto bankIndex = selector.getLeastOccupiedBank();
@@ -75,7 +78,7 @@ TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMemoryAllocatedS
} }
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenIndexIsInvalidThenErrorIsReturned) { TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenIndexIsInvalidThenErrorIsReturned) {
LocalMemoryUsageBankSelector selector(3u); MockLocalMemoryUsageBankSelector selector(3u);
EXPECT_THROW(selector.reserveOnBank(8u, 1024u), std::exception); EXPECT_THROW(selector.reserveOnBank(8u, 1024u), std::exception);
EXPECT_THROW(selector.freeOnBank(8u, 1024u), std::exception); EXPECT_THROW(selector.freeOnBank(8u, 1024u), std::exception);
EXPECT_THROW(selector.getOccupiedMemorySizeForBank(8u), std::exception); EXPECT_THROW(selector.getOccupiedMemorySizeForBank(8u), std::exception);
@@ -84,4 +87,52 @@ TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenIndexIsInvalidTh
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenItsCreatedWithZeroBanksThenErrorIsReturned) { TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenItsCreatedWithZeroBanksThenErrorIsReturned) {
EXPECT_THROW(LocalMemoryUsageBankSelector(0u), std::exception); EXPECT_THROW(LocalMemoryUsageBankSelector(0u), std::exception);
} }
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMultipleBanksAreUsedThenMemoryIsReservedOnEachOfThem) {
MockLocalMemoryUsageBankSelector selector(6u);
uint32_t banks = 5u;
uint64_t allocationSize = 1024u;
selector.reserveOnBanks(banks, allocationSize);
EXPECT_EQ(allocationSize, selector.getOccupiedMemorySizeForBank(0u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(1u));
EXPECT_EQ(allocationSize, selector.getOccupiedMemorySizeForBank(2u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(3u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(4u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(5u));
}
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenMultipleBanksAreUsedThenMemoryIsReleasedOnEachOfThem) {
MockLocalMemoryUsageBankSelector selector(6u);
uint32_t banks = 5u;
uint64_t allocationSize = 1024u;
selector.reserveOnBanks(banks, allocationSize);
selector.reserveOnBanks(banks, allocationSize);
EXPECT_EQ(2 * allocationSize, selector.getOccupiedMemorySizeForBank(0u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(1u));
EXPECT_EQ(2 * allocationSize, selector.getOccupiedMemorySizeForBank(2u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(3));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(4));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(5));
selector.freeOnBanks(banks, allocationSize);
EXPECT_EQ(allocationSize, selector.getOccupiedMemorySizeForBank(0u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(1u));
EXPECT_EQ(allocationSize, selector.getOccupiedMemorySizeForBank(2u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(3u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(4u));
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(5u));
}
TEST(localMemoryUsageTest, givenLocalMemoryUsageBankSelectorWhenThereAreMoreThan32BanksThenOnly32AreUpdated) {
MockLocalMemoryUsageBankSelector selector(33u);
uint32_t banks = ~0u;
uint64_t allocationSize = 1024u;
selector.reserveOnBanks(banks, allocationSize);
EXPECT_EQ(0u, selector.getOccupiedMemorySizeForBank(32));
}
} // namespace NEO } // namespace NEO

127
unit_tests/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl
View File

@@ -24,7 +24,8 @@ class MemoryManagerGetAlloctionDataTest : public testing::TestWithParam<Graphics
TEST(MemoryManagerGetAlloctionDataTest, givenHostMemoryAllocationTypeAndAllocateMemoryFlagAndNullptrWhenAllocationDataIsQueriedThenCorrectFlagsAndSizeAreSet) { TEST(MemoryManagerGetAlloctionDataTest, givenHostMemoryAllocationTypeAndAllocateMemoryFlagAndNullptrWhenAllocationDataIsQueriedThenCorrectFlagsAndSizeAreSet) {
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
EXPECT_EQ(10u, allocData.size); EXPECT_EQ(10u, allocData.size);
@@ -35,7 +36,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenNonHostMemoryAllocatoinTypeWhenAllo
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_EQ(10u, allocData.size); EXPECT_EQ(10u, allocData.size);
@@ -47,7 +49,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenAllocateMemoryFlagTrueWhenHostPtrIs
char memory = 0; char memory = 0;
AllocationProperties properties(true, sizeof(memory), GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, sizeof(memory), GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, &memory); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, &memory, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_EQ(sizeof(memory), allocData.size); EXPECT_EQ(sizeof(memory), allocData.size);
EXPECT_EQ(nullptr, allocData.hostPtr); EXPECT_EQ(nullptr, allocData.hostPtr);
@@ -57,7 +60,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferTypeWhenAllocationDataIsQueri
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -66,7 +70,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferHostMemoryTypeWhenAllocationD
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -75,7 +80,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenBufferCompressedTypeWhenAllocationD
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.forcePin); EXPECT_TRUE(allocData.flags.forcePin);
} }
@@ -84,7 +90,8 @@ TEST(MemoryManagerGetAlloctionDataTest, givenDefaultAllocationFlagsWhenAllocatio
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(false, 0, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); AllocationProperties properties(false, 0, GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
char memory; char memory;
MockMemoryManager::getAllocationData(allocData, properties, &memory); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, &memory, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.allocateMemory); EXPECT_FALSE(allocData.flags.allocateMemory);
} }
@@ -96,7 +103,8 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, givenAllocatio
auto allocType = GetParam(); auto allocType = GetParam();
AllocationProperties properties(true, 0, allocType); AllocationProperties properties(true, 0, allocType);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.allow32Bit); EXPECT_TRUE(allocData.flags.allow32Bit);
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
@@ -108,10 +116,10 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesAllowedTest, given64kbAllow
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, allocType); AllocationProperties properties(true, 10, allocType);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager(true, false);
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
bool bufferCompressedType = (allocType == GraphicsAllocation::AllocationType::BUFFER_COMPRESSED); bool bufferCompressedType = (allocType == GraphicsAllocation::AllocationType::BUFFER_COMPRESSED);
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
MockMemoryManager mockMemoryManager(true, false);
auto allocation = mockMemoryManager.allocateGraphicsMemory(allocData); auto allocation = mockMemoryManager.allocateGraphicsMemory(allocData);
EXPECT_TRUE(mockMemoryManager.allocation64kbPageCreated); EXPECT_TRUE(mockMemoryManager.allocation64kbPageCreated);
@@ -127,7 +135,8 @@ TEST_P(MemoryManagerGetAlloctionData32BitAnd64kbPagesNotAllowedTest, givenAlloca
auto allocType = GetParam(); auto allocType = GetParam();
AllocationProperties properties(true, 0, allocType); AllocationProperties properties(true, 0, allocType);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager mockMemoryManager;
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.allow32Bit); EXPECT_FALSE(allocData.flags.allow32Bit);
EXPECT_FALSE(allocData.flags.allow64kbPages); EXPECT_FALSE(allocData.flags.allow64kbPages);
@@ -161,13 +170,13 @@ INSTANTIATE_TEST_CASE_P(Disallow32BitAnd64kbPagesTypes,
TEST(MemoryManagerTest, givenForced32BitSetWhenGraphicsMemoryFor32BitAllowedTypeIsAllocatedThen32BitAllocationIsReturned) { TEST(MemoryManagerTest, givenForced32BitSetWhenGraphicsMemoryFor32BitAllowedTypeIsAllocatedThen32BitAllocationIsReturned) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(false, false, executionEnvironment); MockMemoryManager memoryManager(false, false, executionEnvironment);
memoryManager.setForce32BitAllocations(true); memoryManager.setForce32BitAllocations(true);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -184,13 +193,13 @@ TEST(MemoryManagerTest, givenForced32BitSetWhenGraphicsMemoryFor32BitAllowedType
TEST(MemoryManagerTest, givenForced32BitEnabledWhenGraphicsMemoryWihtoutAllow32BitFlagIsAllocatedThenNon32BitAllocationIsReturned) { TEST(MemoryManagerTest, givenForced32BitEnabledWhenGraphicsMemoryWihtoutAllow32BitFlagIsAllocatedThenNon32BitAllocationIsReturned) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(executionEnvironment); MockMemoryManager memoryManager(executionEnvironment);
memoryManager.setForce32BitAllocations(true); memoryManager.setForce32BitAllocations(true);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
allocData.flags.allow32Bit = false; allocData.flags.allow32Bit = false;
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
@@ -202,13 +211,13 @@ TEST(MemoryManagerTest, givenForced32BitEnabledWhenGraphicsMemoryWihtoutAllow32B
TEST(MemoryManagerTest, givenForced32BitDisabledWhenGraphicsMemoryWith32BitFlagFor32BitAllowedTypeIsAllocatedThenNon32BitAllocationIsReturned) { TEST(MemoryManagerTest, givenForced32BitDisabledWhenGraphicsMemoryWith32BitFlagFor32BitAllowedTypeIsAllocatedThenNon32BitAllocationIsReturned) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(executionEnvironment); MockMemoryManager memoryManager(executionEnvironment);
memoryManager.setForce32BitAllocations(false); memoryManager.setForce32BitAllocations(false);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -219,11 +228,11 @@ TEST(MemoryManagerTest, givenForced32BitDisabledWhenGraphicsMemoryWith32BitFlagF
TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryAndIsAllocatedWithNullptrForBufferThen64kbAllocationIsReturned) { TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryAndIsAllocatedWithNullptrForBufferThen64kbAllocationIsReturned) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(true, false, executionEnvironment); MockMemoryManager memoryManager(true, false, executionEnvironment);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -241,7 +250,7 @@ TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryWithoutAllow64kbP
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
allocData.flags.allow64kbPages = false; allocData.flags.allow64kbPages = false;
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
@@ -258,7 +267,7 @@ TEST(MemoryManagerTest, givenDisabled64kbPagesWhenGraphicsMemoryMustBeHostMemory
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -271,13 +280,13 @@ TEST(MemoryManagerTest, givenDisabled64kbPagesWhenGraphicsMemoryMustBeHostMemory
TEST(MemoryManagerTest, givenForced32BitAndEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryAndIsAllocatedWithNullptrForBufferThen32BitAllocationOver64kbIsChosen) { TEST(MemoryManagerTest, givenForced32BitAndEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryAndIsAllocatedWithNullptrForBufferThen32BitAllocationOver64kbIsChosen) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(false, false, executionEnvironment); MockMemoryManager memoryManager(false, false, executionEnvironment);
memoryManager.setForce32BitAllocations(true); memoryManager.setForce32BitAllocations(true);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(true, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -292,12 +301,12 @@ TEST(MemoryManagerTest, givenForced32BitAndEnabled64kbPagesWhenGraphicsMemoryMus
TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryIsAllocatedWithHostPtrForBufferThenExistingMemoryIsUsedForAllocation) { TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryIsAllocatedWithHostPtrForBufferThenExistingMemoryIsUsedForAllocation) {
MockExecutionEnvironment executionEnvironment(*platformDevices); MockExecutionEnvironment executionEnvironment(*platformDevices);
MemoryManagerCreate<OsAgnosticMemoryManager> memoryManager(true, false, executionEnvironment); MockMemoryManager memoryManager(true, false, executionEnvironment);
AllocationData allocData; AllocationData allocData;
AllocationProperties properties(false, 1, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY); AllocationProperties properties(false, 1, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
char memory[1]; char memory[1];
MockMemoryManager::getAllocationData(allocData, properties, &memory); MockMemoryManager::getAllocationData(allocData, properties, &memory, memoryManager.createStorageInfoFromProperties(properties));
auto allocation = memoryManager.allocateGraphicsMemory(allocData); auto allocation = memoryManager.allocateGraphicsMemory(allocData);
ASSERT_NE(nullptr, allocation); ASSERT_NE(nullptr, allocation);
@@ -345,76 +354,100 @@ TEST(MemoryManagerTest, givenMemoryManagerWhenBufferTypeIsPassedAndAllocateInDev
TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThenAllocatingMemoryIsRequested) { TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThenAllocatingMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM_ZERO_COPY}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::SVM_ZERO_COPY};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.allocateMemory); EXPECT_TRUE(allocData.flags.allocateMemory);
} }
TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThen64kbPagesAreAllowedAnd32BitAllocationIsDisallowed) { TEST(MemoryManagerTest, givenSvmAllocationTypeWhenGetAllocationDataIsCalledThen64kbPagesAreAllowedAnd32BitAllocationIsDisallowed) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SVM_ZERO_COPY}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::SVM_ZERO_COPY};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.allow64kbPages); EXPECT_TRUE(allocData.flags.allow64kbPages);
EXPECT_FALSE(allocData.flags.allow32Bit); EXPECT_FALSE(allocData.flags.allow32Bit);
} }
TEST(MemoryManagerTest, givenTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::TAG_BUFFER}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::TAG_BUFFER};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenPreemptionTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenPreemptionTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::PREEMPTION}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::PREEMPTION};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenSharedContextImageTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenSharedContextImageTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::SHARED_CONTEXT_IMAGE}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::SHARED_CONTEXT_IMAGE};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenMCSTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenMCSTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::MCS}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::MCS};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenDeviceQueueBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenDeviceQueueBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenInternalHostMemoryTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenInternalHostMemoryTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenFillPatternTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenFillPatternTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::FILL_PATTERN}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::FILL_PATTERN};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenLinearStreamTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenLinearStreamTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::LINEAR_STREAM};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenTimestampPacketTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequestedAndRequireCpuAccess) { TEST(MemoryManagerTest, givenTimestampPacketTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequestedAndRequireCpuAccess) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER};
mockMemoryManager.getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenProfilingTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) { TEST(MemoryManagerTest, givenProfilingTagBufferTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::PROFILING_TAG_BUFFER}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::PROFILING_TAG_BUFFER};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
EXPECT_FALSE(allocData.flags.requiresCpuAccess); EXPECT_FALSE(allocData.flags.requiresCpuAccess);
} }
@@ -426,7 +459,7 @@ TEST(MemoryManagerTest, givenAllocationPropertiesWithMultiOsContextCapableFlagEn
properties.flags.multiOsContextCapable = true; properties.flags.multiOsContextCapable = true;
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.multiOsContextCapable); EXPECT_TRUE(allocData.flags.multiOsContextCapable);
auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties); auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties);
@@ -441,7 +474,7 @@ TEST(MemoryManagerTest, givenAllocationPropertiesWithMultiOsContextCapableFlagDi
properties.flags.multiOsContextCapable = false; properties.flags.multiOsContextCapable = false;
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, memoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.multiOsContextCapable); EXPECT_FALSE(allocData.flags.multiOsContextCapable);
auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties); auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties);
@@ -455,20 +488,26 @@ TEST(MemoryManagerTest, givenInternalHeapTypeThenUseInternal32BitAllocator) {
TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenInternalHeapTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::INTERNAL_HEAP}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::INTERNAL_HEAP};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenKernelIsaTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::KERNEL_ISA}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::KERNEL_ISA};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
} }
TEST(MemoryManagerTest, givenLinearStreamWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) { TEST(MemoryManagerTest, givenLinearStreamWhenGetAllocationDataIsCalledThenSystemMemoryIsNotRequested) {
AllocationData allocData; AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, {1, GraphicsAllocation::AllocationType::LINEAR_STREAM}, nullptr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{1, GraphicsAllocation::AllocationType::LINEAR_STREAM};
MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.useSystemMemory); EXPECT_FALSE(allocData.flags.useSystemMemory);
EXPECT_TRUE(allocData.flags.requiresCpuAccess); EXPECT_TRUE(allocData.flags.requiresCpuAccess);
} }
@@ -480,7 +519,9 @@ TEST(MemoryManagerTest, givenKernelIsaTypeThenUseInternal32BitAllocator) {
TEST(MemoryManagerTest, givenExternalHostMemoryWhenGetAllocationDataIsCalledThenItHasProperFieldsSet) { TEST(MemoryManagerTest, givenExternalHostMemoryWhenGetAllocationDataIsCalledThenItHasProperFieldsSet) {
AllocationData allocData; AllocationData allocData;
auto hostPtr = reinterpret_cast<void *>(0x1234); auto hostPtr = reinterpret_cast<void *>(0x1234);
MockMemoryManager::getAllocationData(allocData, {false, 1, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR}, hostPtr); MockMemoryManager mockMemoryManager;
AllocationProperties properties{false, 1, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR};
MockMemoryManager::getAllocationData(allocData, properties, hostPtr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.useSystemMemory); EXPECT_TRUE(allocData.flags.useSystemMemory);
EXPECT_FALSE(allocData.flags.allocateMemory); EXPECT_FALSE(allocData.flags.allocateMemory);
EXPECT_FALSE(allocData.flags.allow32Bit); EXPECT_FALSE(allocData.flags.allow32Bit);

5
unit_tests/memory_manager/memory_manager_tests.cpp
View File

@@ -1660,9 +1660,10 @@ TEST(MemoryManagerTest, givenAllocationTypesThatMayNeedL3FlushWhenCallingGetAllo
GraphicsAllocation::AllocationType::SVM_ZERO_COPY, GraphicsAllocation::AllocationType::SVM_GPU, GraphicsAllocation::AllocationType::SVM_ZERO_COPY, GraphicsAllocation::AllocationType::SVM_GPU,
GraphicsAllocation::AllocationType::SVM_CPU}; GraphicsAllocation::AllocationType::SVM_CPU};
MockMemoryManager mockMemoryManager;
for (auto allocationType : allocationTypesThatMayNeedL3Flush) { for (auto allocationType : allocationTypesThatMayNeedL3Flush) {
properties.allocationType = allocationType; properties.allocationType = allocationType;
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_TRUE(allocData.flags.flushL3); EXPECT_TRUE(allocData.flags.flushL3);
} }
@@ -1671,7 +1672,7 @@ TEST(MemoryManagerTest, givenAllocationTypesThatMayNeedL3FlushWhenCallingGetAllo
for (auto allocationType : allocationTypesThatMayNeedL3Flush) { for (auto allocationType : allocationTypesThatMayNeedL3Flush) {
properties.allocationType = allocationType; properties.allocationType = allocationType;
MockMemoryManager::getAllocationData(allocData, properties, nullptr); MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
EXPECT_FALSE(allocData.flags.flushL3); EXPECT_FALSE(allocData.flags.flushL3);
} }
} }

3
unit_tests/mocks/linux/mock_drm_memory_manager.h
View File

@@ -108,7 +108,8 @@ class TestedDrmMemoryManager : public MemoryManagerCreate<DrmMemoryManager> {
DrmAllocation *allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) { DrmAllocation *allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) {
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
getAllocationData(allocationData, MockAllocationProperties(allocateMemory, size, allocationType), ptr); MockAllocationProperties properties(allocateMemory, size, allocationType);
getAllocationData(allocationData, properties, ptr, createStorageInfoFromProperties(properties));
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }
}; };

1
unit_tests/mocks/mock_allocation_properties.h
View File

@@ -10,7 +10,6 @@
namespace NEO { namespace NEO {
struct MockAllocationProperties : public AllocationProperties { struct MockAllocationProperties : public AllocationProperties {
public:
MockAllocationProperties(size_t size, GraphicsAllocation::AllocationType allocationType) : AllocationProperties(size, allocationType) {} MockAllocationProperties(size_t size, GraphicsAllocation::AllocationType allocationType) : AllocationProperties(size, allocationType) {}
MockAllocationProperties(size_t size) : AllocationProperties(size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY) {} MockAllocationProperties(size_t size) : AllocationProperties(size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY) {}
MockAllocationProperties(bool allocateMemory, size_t size) : AllocationProperties(allocateMemory, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY) {} MockAllocationProperties(bool allocateMemory, size_t size) : AllocationProperties(allocateMemory, size, GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY) {}

3
unit_tests/mocks/mock_memory_manager.cpp
View File

@@ -93,7 +93,8 @@ GraphicsAllocation *MockMemoryManager::allocateGraphicsMemoryWithAlignment(const
GraphicsAllocation *MockMemoryManager::allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) { GraphicsAllocation *MockMemoryManager::allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) {
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
getAllocationData(allocationData, MockAllocationProperties(allocateMemory, size, allocationType), ptr); MockAllocationProperties properties(allocateMemory, size, allocationType);
getAllocationData(allocationData, properties, ptr, createStorageInfoFromProperties(properties));
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }

2
unit_tests/mocks/mock_memory_manager.h
View File

@@ -37,6 +37,8 @@ class MockMemoryManager : public MemoryManagerCreate<OsAgnosticMemoryManager> {
using MemoryManager::createGraphicsAllocation; using MemoryManager::createGraphicsAllocation;
using MemoryManager::createStorageInfoFromProperties; using MemoryManager::createStorageInfoFromProperties;
using MemoryManager::getAllocationData; using MemoryManager::getAllocationData;
using MemoryManager::getBanksCount;
using MemoryManager::localMemoryUsageBankSelector;
using MemoryManager::multiContextResourceDestructor; using MemoryManager::multiContextResourceDestructor;
using MemoryManager::registeredEngines; using MemoryManager::registeredEngines;
using MemoryManager::useInternal32BitAllocator; using MemoryManager::useInternal32BitAllocator;

3
unit_tests/os_interface/windows/mock_wddm_memory_manager.h
View File

@@ -41,7 +41,8 @@ class MockWddmMemoryManager : public MemoryManagerCreate<WddmMemoryManager> {
GraphicsAllocation *allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) { GraphicsAllocation *allocate32BitGraphicsMemory(size_t size, const void *ptr, GraphicsAllocation::AllocationType allocationType) {
bool allocateMemory = ptr == nullptr; bool allocateMemory = ptr == nullptr;
AllocationData allocationData; AllocationData allocationData;
getAllocationData(allocationData, MockAllocationProperties(allocateMemory, size, allocationType), ptr); MockAllocationProperties properties(allocateMemory, size, allocationType);
getAllocationData(allocationData, properties, ptr, createStorageInfoFromProperties(properties));
return allocate32BitGraphicsMemoryImpl(allocationData); return allocate32BitGraphicsMemoryImpl(allocationData);
} }