intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-02-08 18:43:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add localMemorySupported member to MemoryManager

Browse Source 
- extend constructor to take new flag
- extend ExecutionEnvironment createMemoryManager with new flag
- only OsAgnosticMemoryManager changes in this step

Change-Id: I1dae4fd79fe28fd87e42b237600dc216c94b597e
This commit is contained in:
Hoppe, Mateusz
2018-09-06 10:53:35 +02:00
committed by sys_ocldev
parent 05b93ef221
commit cfa8035836
39 changed files with 96 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
runtime/command_stream/aub_command_stream_receiver_hw.h
View File

@@ -77,8 +77,8 @@ class AUBCommandStreamReceiverHw : public CommandStreamReceiverHw<GfxFamily> {
void initializeEngine(EngineType engineType);
void freeEngineInfoTable();
MemoryManager *createMemoryManager(bool enable64kbPages) override {
this->memoryManager = new OsAgnosticMemoryManager(enable64kbPages);
MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override {
this->memoryManager = new OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory);
this->flatBatchBufferHelper->setMemoryManager(this->memoryManager);
return this->memoryManager;
}

2
runtime/command_stream/command_stream_receiver.h
View File

@@ -86,7 +86,7 @@ class CommandStreamReceiver {
virtual void addPipeControl(LinearStream &commandStream, bool dcFlush) = 0;
MemoryManager *getMemoryManager();
virtual MemoryManager *createMemoryManager(bool enable64kbPages) { return nullptr; }
virtual MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) { return nullptr; }
void setMemoryManager(MemoryManager *mm);
virtual GmmPageTableMngr *createPageTableManager() { return nullptr; }

2
runtime/command_stream/command_stream_receiver_with_aub_dump.h
View File

@@ -39,7 +39,7 @@ class CommandStreamReceiverWithAUBDump : public BaseCSR {
void activateAubSubCapture(const MultiDispatchInfo &dispatchInfo) override;
MemoryManager *createMemoryManager(bool enable64kbPages) override;
MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override;
CommandStreamReceiver *aubCSR = nullptr;
};

4
runtime/command_stream/command_stream_receiver_with_aub_dump.inl
View File

@@ -64,8 +64,8 @@ void CommandStreamReceiverWithAUBDump<BaseCSR>::activateAubSubCapture(const Mult
}
template <typename BaseCSR>
MemoryManager *CommandStreamReceiverWithAUBDump<BaseCSR>::createMemoryManager(bool enable64kbPages) {
auto memoryManager = BaseCSR::createMemoryManager(enable64kbPages);
MemoryManager *CommandStreamReceiverWithAUBDump<BaseCSR>::createMemoryManager(bool enable64kbPages, bool enableLocalMemory) {
auto memoryManager = BaseCSR::createMemoryManager(enable64kbPages, enableLocalMemory);
if (aubCSR) {
aubCSR->setMemoryManager(memoryManager);
}

5
runtime/command_stream/tbx_command_stream_receiver_hw.h
View File

@@ -32,6 +32,7 @@ namespace OCLRT {
class TbxMemoryManager : public OsAgnosticMemoryManager {
public:
TbxMemoryManager(bool enable64kbPages, bool enableLocalMemory) : OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory) {}
uint64_t getSystemSharedMemory() override {
return 1 * GB;
}
@@ -78,8 +79,8 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverHw<GfxFamily> {
uint32_t tailRCS;
} engineInfoTable[EngineType::NUM_ENGINES];
MemoryManager *createMemoryManager(bool enable64kbPages) override {
memoryManager = new TbxMemoryManager;
MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override {
memoryManager = new TbxMemoryManager(enable64kbPages, enableLocalMemory);
return memoryManager;
}
TbxMemoryManager *getMemoryManager() {

2
runtime/device/device.cpp
View File

@@ -129,7 +129,7 @@ bool Device::createDeviceImpl(const HardwareInfo *pHwInfo, Device &outDevice) {
if (!executionEnvironment->initializeCommandStreamReceiver(pHwInfo)) {
return false;
}
executionEnvironment->initializeMemoryManager(outDevice.getEnabled64kbPages());
executionEnvironment->initializeMemoryManager(outDevice.getEnabled64kbPages(), outDevice.getHardwareCapabilities().localMemorySupported);
outDevice.osContext = new OsContext(executionEnvironment->osInterface.get());
executionEnvironment->memoryManager->registerOsContext(outDevice.osContext);

4
runtime/execution_environment/execution_environment.cpp
View File

@@ -55,13 +55,13 @@ bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *p
this->commandStreamReceiver.reset(commandStreamReceiver);
return true;
}
void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages) {
void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory) {
if (this->memoryManager) {
commandStreamReceiver->setMemoryManager(this->memoryManager.get());
return;
}
memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages));
memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages, enableLocalMemory));
commandStreamReceiver->setMemoryManager(memoryManager.get());
DEBUG_BREAK_IF(!this->memoryManager);

2
runtime/execution_environment/execution_environment.h
View File

@@ -49,7 +49,7 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
void initGmm(const HardwareInfo *hwInfo);
bool initializeCommandStreamReceiver(const HardwareInfo *pHwInfo);
void initializeMemoryManager(bool enable64KBpages);
void initializeMemoryManager(bool enable64KBpages, bool enableLocalMemory);
void initSourceLevelDebugger(const HardwareInfo &hwInfo);
GmmHelper *getGmmHelper() const;

5
runtime/memory_manager/memory_manager.cpp
View File

@@ -71,9 +71,12 @@ GraphicsAllocation *AllocationsList::detachAllocationImpl(GraphicsAllocation *,
}
return nullptr;
}
MemoryManager::MemoryManager(bool enable64kbpages) : allocator32Bit(nullptr), enable64kbpages(enable64kbpages) {
MemoryManager::MemoryManager(bool enable64kbpages, bool enableLocalMemory) : allocator32Bit(nullptr), enable64kbpages(enable64kbpages),
localMemorySupported(enableLocalMemory) {
residencyAllocations.reserve(20);
};
MemoryManager::~MemoryManager() {
freeAllocationsList(-1, graphicsAllocations);
freeAllocationsList(-1, allocationsForReuse);

3
runtime/memory_manager/memory_manager.h
View File

@@ -108,7 +108,7 @@ class MemoryManager {
RetryInNonDevicePool
};
MemoryManager(bool enable64kbpages);
MemoryManager(bool enable64kbpages, bool enableLocalMemory);
virtual ~MemoryManager();
MOCKABLE_VIRTUAL void *allocateSystemMemory(size_t size, size_t alignment);
@@ -271,6 +271,7 @@ class MemoryManager {
std::unique_ptr<DeferredDeleter> deferredDeleter;
bool asyncDeleterEnabled = false;
bool enable64kbpages = false;
bool localMemorySupported = false;
std::vector<OsContext *> registeredOsContexts;
};

3
runtime/memory_manager/os_agnostic_memory_manager.h
View File

@@ -54,7 +54,8 @@ class OsAgnosticMemoryManager : public MemoryManager {
using MemoryManager::allocateGraphicsMemory;
using MemoryManager::createGraphicsAllocationFromSharedHandle;
OsAgnosticMemoryManager(bool enable64kbPages = false) : MemoryManager(enable64kbPages) {
OsAgnosticMemoryManager() : OsAgnosticMemoryManager(false, false){};
OsAgnosticMemoryManager(bool enable64kbPages, bool enableLocalMemory) : MemoryManager(enable64kbPages, enableLocalMemory) {
uint64_t heap32Base = 0x80000000000ul;
if (sizeof(uintptr_t) == 4) {
heap32Base = 0x0;

2
runtime/os_interface/linux/drm_command_stream.h
View File

@@ -59,7 +59,7 @@ class DrmCommandStreamReceiver : public DeviceCommandStreamReceiver<GfxFamily> {
void overrideMediaVFEStateDirty(bool dirty) override;
DrmMemoryManager *getMemoryManager();
MemoryManager *createMemoryManager(bool enable64kbPages) override;
MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override;
gemCloseWorkerMode peekGemCloseWorkerOperationMode() {
return this->gemCloseWorkerOperationMode;

2
runtime/os_interface/linux/drm_command_stream.inl
View File

@@ -167,7 +167,7 @@ DrmMemoryManager *DrmCommandStreamReceiver<GfxFamily>::getMemoryManager() {
}
template <typename GfxFamily>
MemoryManager *DrmCommandStreamReceiver<GfxFamily>::createMemoryManager(bool enable64kbPages) {
MemoryManager *DrmCommandStreamReceiver<GfxFamily>::createMemoryManager(bool enable64kbPages, bool enableLocalMemory) {
memoryManager = new DrmMemoryManager(this->drm, this->gemCloseWorkerOperationMode, DebugManager.flags.EnableForcePin.get(), true);
return memoryManager;
}

2
runtime/os_interface/linux/drm_memory_manager.cpp
View File

@@ -40,7 +40,7 @@
namespace OCLRT {
DrmMemoryManager::DrmMemoryManager(Drm *drm, gemCloseWorkerMode mode, bool forcePinAllowed, bool validateHostPtrMemory) : MemoryManager(false),
DrmMemoryManager::DrmMemoryManager(Drm *drm, gemCloseWorkerMode mode, bool forcePinAllowed, bool validateHostPtrMemory) : MemoryManager(false, false),
drm(drm),
pinBB(nullptr),
forcePinEnabled(forcePinAllowed),

2
runtime/os_interface/windows/wddm_device_command_stream.h
View File

@@ -47,7 +47,7 @@ class WddmCommandStreamReceiver : public DeviceCommandStreamReceiver<GfxFamily>
bool waitForFlushStamp(FlushStamp &flushStampToWait, OsContext &osContext) override;
WddmMemoryManager *getMemoryManager();
MemoryManager *createMemoryManager(bool enable64kbPages);
MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory);
Wddm *peekWddm() {
return wddm;
}

2
runtime/os_interface/windows/wddm_device_command_stream.inl
View File

@@ -169,7 +169,7 @@ WddmMemoryManager *WddmCommandStreamReceiver<GfxFamily>::getMemoryManager() {
}
template <typename GfxFamily>
MemoryManager *WddmCommandStreamReceiver<GfxFamily>::createMemoryManager(bool enable64kbPages) {
MemoryManager *WddmCommandStreamReceiver<GfxFamily>::createMemoryManager(bool enable64kbPages, bool enableLocalMemory) {
return memoryManager = new WddmMemoryManager(enable64kbPages, this->wddm);
}

2
runtime/os_interface/windows/wddm_memory_manager.cpp
View File

@@ -43,7 +43,7 @@ WddmMemoryManager::~WddmMemoryManager() {
applyCommonCleanup();
}
WddmMemoryManager::WddmMemoryManager(bool enable64kbPages, Wddm *wddm) : MemoryManager(enable64kbPages), residencyLock(false) {
WddmMemoryManager::WddmMemoryManager(bool enable64kbPages, Wddm *wddm) : MemoryManager(enable64kbPages, false), residencyLock(false) {
DEBUG_BREAK_IF(wddm == nullptr);
this->wddm = wddm;
allocator32Bit = std::unique_ptr<Allocator32bit>(new Allocator32bit(wddm->getHeap32Base(), wddm->getHeap32Size()));

32
unit_tests/command_stream/aub_command_stream_receiver_tests.cpp
View File

@@ -137,7 +137,7 @@ template <typename CsrType>
std::unique_ptr<AubExecutionEnvironment> getEnvironment(bool createTagAllocation, bool allocateCommandBuffer, bool standalone) {
std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
executionEnvironment->commandStreamReceiver.reset(new CsrType(*platformDevices[0], "", standalone, *executionEnvironment));
executionEnvironment->memoryManager.reset(executionEnvironment->commandStreamReceiver->createMemoryManager(false));
executionEnvironment->memoryManager.reset(executionEnvironment->commandStreamReceiver->createMemoryManager(false, false));
executionEnvironment->commandStreamReceiver->setMemoryManager(executionEnvironment->memoryManager.get());
if (createTagAllocation) {
executionEnvironment->commandStreamReceiver->initializeTagAllocation();
@@ -207,7 +207,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCsrWhenItIsCreatedWithDebugSetti
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenItIsCreatedThenMemoryManagerIsNotNull) {
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(**platformDevices, "", true, *pDevice->executionEnvironment));
std::unique_ptr<MemoryManager> memoryManager(aubCsr->createMemoryManager(false));
std::unique_ptr<MemoryManager> memoryManager(aubCsr->createMemoryManager(false, false));
EXPECT_NE(nullptr, memoryManager.get());
aubCsr->setMemoryManager(nullptr);
}
@@ -267,7 +267,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenInitFil
HWTEST_F(AubCommandStreamReceiverTests, givenGraphicsAllocationWhenMakeResidentCalledMultipleTimesAffectsResidencyOnce) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
// First makeResident marks the allocation resident
@@ -641,7 +641,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenProcess
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledOnBufferAndImageTypeAllocationsThenAllocationsHaveAubWritableSetToFalse) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
@@ -664,7 +664,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenWriteMe
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenProcessResidencyIsCalledOnBufferAndImageAllocationsThenAllocationsTypesShouldBeMadeNonAubWritable) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxBufferAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
gfxBufferAllocation->setAllocationType(GraphicsAllocation::AllocationType::BUFFER);
@@ -686,7 +686,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInSubCaptur
DebugManagerStateRestore stateRestore;
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<MockAubCsrToTestDumpAubNonWritable<FamilyType>> aubCsr(new MockAubCsrToTestDumpAubNonWritable<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxBufferAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
gfxBufferAllocation->setAllocationType(GraphicsAllocation::AllocationType::BUFFER);
@@ -712,7 +712,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenProcess
DebugManagerStateRestore stateRestore;
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<MockAubCsrToTestDumpAubNonWritable<FamilyType>> aubCsr(new MockAubCsrToTestDumpAubNonWritable<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxBufferAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
gfxBufferAllocation->setAllocationType(GraphicsAllocation::AllocationType::BUFFER);
@@ -737,7 +737,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenProcess
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenGraphicsAllocationTypeIsntNonAubWritableThenWriteMemoryIsAllowed) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
@@ -749,7 +749,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenGraphic
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenGraphicsAllocationTypeIsNonAubWritableThenWriteMemoryIsNotAllowed) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto gfxAllocation = memoryManager->allocateGraphicsMemory(sizeof(uint32_t), sizeof(uint32_t), false, false);
@@ -1051,7 +1051,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverInStandalon
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenForcedBatchBufferFlatteningInImmediateDispatchModeThenNewCombinedBatchBufferIsCreated) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto flatBatchBufferHelper = new FlatBatchBufferHelperHw<FamilyType>(memoryManager.get());
aubCsr->overwriteFlatBatchBufferHelper(flatBatchBufferHelper);
@@ -1081,7 +1081,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenForcedB
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenForcedBatchBufferInImmediateDispatchModeAndNoChainedBatchBufferThenCombinedBatchBufferIsNotCreated) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto flatBatchBufferHelper = new FlatBatchBufferHelperHw<FamilyType>(memoryManager.get());
aubCsr->overwriteFlatBatchBufferHelper(flatBatchBufferHelper);
@@ -1105,7 +1105,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenForcedB
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenForcedBatchBufferAndNotImmediateOrBatchedDispatchModeThenCombinedBatchBufferIsNotCreated) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
auto flatBatchBufferHelper = new FlatBatchBufferHelperHw<FamilyType>(memoryManager.get());
aubCsr->overwriteFlatBatchBufferHelper(flatBatchBufferHelper);
@@ -1660,7 +1660,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenGetIndi
typedef typename FamilyType::MI_STORE_DATA_IMM MI_STORE_DATA_IMM;
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
PatchInfoData patchInfo1(0xA000, 0u, PatchInfoAllocationType::KernelArg, 0x6000, 0x100, PatchInfoAllocationType::IndirectObjectHeap);
PatchInfoData patchInfo2(0xB000, 0u, PatchInfoAllocationType::KernelArg, 0x6000, 0x200, PatchInfoAllocationType::IndirectObjectHeap);
@@ -1687,7 +1687,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenAddBatc
std::unique_ptr<MemoryManager> memoryManager(nullptr);
std::unique_ptr<AUBCommandStreamReceiverHw<FamilyType>> aubCsr(new AUBCommandStreamReceiverHw<FamilyType>(*platformDevices[0], "", true, *pDevice->executionEnvironment));
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
MI_BATCH_BUFFER_START bbStart;
@@ -1702,6 +1702,8 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenAddBatc
class OsAgnosticMemoryManagerForImagesWithNoHostPtr : public OsAgnosticMemoryManager {
public:
OsAgnosticMemoryManagerForImagesWithNoHostPtr() : OsAgnosticMemoryManager(false, false) {}
GraphicsAllocation *allocateGraphicsMemoryForImage(ImageInfo &imgInfo, Gmm *gmm) override {
auto imageAllocation = OsAgnosticMemoryManager::allocateGraphicsMemoryForImage(imgInfo, gmm);
cpuPtr = imageAllocation->getUnderlyingBuffer();
@@ -1900,7 +1902,7 @@ HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenProcess
HWTEST_F(AubCommandStreamReceiverTests, givenAubCommandStreamReceiverWhenWriteMemoryIsCalledThenGraphicsAllocationSizeIsReadCorrectly) {
std::unique_ptr<MemoryManager> memoryManager(nullptr);
auto aubCsr = std::make_unique<AUBCommandStreamReceiverHw<FamilyType>>(*platformDevices[0], "", false, *pDevice->executionEnvironment);
memoryManager.reset(aubCsr->createMemoryManager(false));
memoryManager.reset(aubCsr->createMemoryManager(false, false));
struct PpgttMock : TypeSelector<PML4, PDPE, sizeof(void *) == 8>::type {
void pageWalk(uintptr_t vm, size_t size, size_t offset, PageWalker &pageWalker) override {

3
unit_tests/command_stream/command_stream_receiver_flush_task_tests.cpp
View File

@@ -1375,7 +1375,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, CreateCommandStreamReceiverHw) {
auto csrHw = CommandStreamReceiverHw<FamilyType>::create(hwInfo, executionEnvironment);
EXPECT_NE(nullptr, csrHw);
MemoryManager *mm = csrHw->createMemoryManager(false);
MemoryManager *mm = csrHw->createMemoryManager(false, false);
EXPECT_EQ(nullptr, mm);
GmmPageTableMngr *ptm = csrHw->createPageTableManager();
EXPECT_EQ(nullptr, ptm);
@@ -2596,6 +2596,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenSusbsequ
}
struct MockedMemoryManager : public OsAgnosticMemoryManager {
MockedMemoryManager() : OsAgnosticMemoryManager(false, false) {}
bool isMemoryBudgetExhausted() const override { return budgetExhausted; }
bool budgetExhausted = false;
};

6
unit_tests/command_stream/command_stream_receiver_tests.cpp
View File

@@ -334,7 +334,7 @@ TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenItIsDestroye
auto mockGraphicsAllocation = new MockGraphicsAllocation(nullptr, 1u);
mockGraphicsAllocation->destructorCalled = &destructorCalled;
std::unique_ptr<MockCommandStreamReceiver> csr(new MockCommandStreamReceiver);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager(false, false));
csr->setMemoryManager(memoryManager.get());
csr->setTagAllocation(mockGraphicsAllocation);
EXPECT_FALSE(destructorCalled);
@@ -343,7 +343,7 @@ TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenItIsDestroye
}
TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenInitializeTagAllocationIsCalledThenTagAllocationIsBeingAllocated) {
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager(false, false));
std::unique_ptr<MockCommandStreamReceiver> csr(new MockCommandStreamReceiver);
csr->setMemoryManager(memoryManager.get());
EXPECT_EQ(nullptr, csr->getTagAllocation());
@@ -357,7 +357,7 @@ TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenInitializeTa
TEST(CommandStreamReceiverSimpleTest, givenNullHardwareDebugModeWhenInitializeTagAllocationIsCalledThenTagAllocationIsBeingAllocatedAndinitialValueIsMinusOne) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableNullHardware.set(true);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager(false, false));
std::unique_ptr<MockCommandStreamReceiver> csr(new MockCommandStreamReceiver);
csr->setMemoryManager(memoryManager.get());
EXPECT_EQ(nullptr, csr->getTagAllocation());

2
unit_tests/command_stream/command_stream_receiver_with_aub_dump_tests.cpp
View File

@@ -117,7 +117,7 @@ struct CommandStreamReceiverWithAubDumpTest : public ::testing::TestWithParam<bo
csrWithAubDump = new MyMockCsrWithAubDump<MyMockCsr>(DEFAULT_TEST_PLATFORM::hwInfo, createAubCSR, executionEnvironment);
ASSERT_NE(nullptr, csrWithAubDump);
memoryManager = csrWithAubDump->createMemoryManager(false);
memoryManager = csrWithAubDump->createMemoryManager(false, false);
ASSERT_NE(nullptr, memoryManager);
}

2
unit_tests/command_stream/create_command_stream_receiver_tests.cpp
View File

@@ -59,7 +59,7 @@ HWTEST_P(CreateCommandStreamReceiverTest, givenCreateCommandStreamWhenCsrIsSetTo
executionEnvironment.commandStreamReceiver.reset(createCommandStream(&hwInfo, executionEnvironment));
if (csrType < CommandStreamReceiverType::CSR_TYPES_NUM) {
EXPECT_NE(nullptr, executionEnvironment.commandStreamReceiver.get());
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false));
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false, false));
EXPECT_NE(nullptr, executionEnvironment.memoryManager.get());
} else {
EXPECT_EQ(nullptr, executionEnvironment.commandStreamReceiver.get());

2
unit_tests/command_stream/tbx_command_stream_fixture.cpp
View File

@@ -35,7 +35,7 @@ void TbxCommandStreamFixture::SetUp(MockDevice *pDevice) {
const auto &hwInfo = pDevice->getHardwareInfo();
pCommandStreamReceiver = TbxCommandStreamReceiver::create(hwInfo, false, *pDevice->executionEnvironment);
ASSERT_NE(nullptr, pCommandStreamReceiver);
mmTbx = pCommandStreamReceiver->createMemoryManager(false);
mmTbx = pCommandStreamReceiver->createMemoryManager(false, false);
pDevice->resetCommandStreamReceiver(pCommandStreamReceiver);
}

2
unit_tests/command_stream/tbx_command_stream_tests.cpp
View File

@@ -298,7 +298,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledTh
}
TEST(TbxMemoryManagerTest, givenTbxMemoryManagerWhenItIsQueriedForSystemSharedMemoryThen1GBIsReturned) {
TbxMemoryManager memoryManager;
TbxMemoryManager memoryManager(false, false);
EXPECT_EQ(1 * GB, memoryManager.getSystemSharedMemory());
}

2
unit_tests/execution_environment/execution_environment_tests.cpp
View File

@@ -112,7 +112,7 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeCommandStreamR
TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
executionEnvironment->initializeCommandStreamReceiver(platformDevices[0]);
executionEnvironment->initializeMemoryManager(false);
executionEnvironment->initializeMemoryManager(false, false);
EXPECT_NE(nullptr, executionEnvironment->memoryManager);
}

4
unit_tests/fixtures/memory_allocator_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, Intel Corporation
* Copyright (c) 2017 - 2018, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -34,7 +34,7 @@ class MemoryAllocatorFixture : public MemoryManagementFixture {
public:
void SetUp() override {
MemoryManagementFixture::SetUp();
memoryManager = new OsAgnosticMemoryManager;
memoryManager = new OsAgnosticMemoryManager(false, false);
}
void TearDown() override {

8
unit_tests/gmm_helper/gmm_helper_tests.cpp
View File

@@ -44,7 +44,7 @@ class GmmTests : public ::testing::Test {
};
TEST_F(GmmTests, resourceCreation) {
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager);
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager(false, false));
void *pSysMem = mm->allocateSystemMemory(4096, 4096);
std::unique_ptr<Gmm> gmm(new Gmm(pSysMem, 4096, false));
@@ -58,7 +58,7 @@ TEST_F(GmmTests, resourceCreation) {
}
TEST_F(GmmTests, resourceCreationUncacheable) {
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager);
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager(false, false));
void *pSysMem = mm->allocateSystemMemory(4096, 4096);
std::unique_ptr<Gmm> gmm(new Gmm(pSysMem, 4096, true));
@@ -74,7 +74,7 @@ TEST_F(GmmTests, resourceCreationUncacheable) {
}
TEST_F(GmmTests, resourceCleanupOnDelete) {
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager);
std::unique_ptr<MemoryManager> mm(new OsAgnosticMemoryManager(false, false));
void *pSysMem = mm->allocateSystemMemory(4096, 4096);
std::unique_ptr<Gmm> gmm(new Gmm(pSysMem, 4096, false));
@@ -87,7 +87,7 @@ TEST_F(GmmTests, resourceCleanupOnDelete) {
TEST_F(GmmTests, GivenBufferSizeLargerThenMaxPitchWhenAskedForGmmCreationThenGMMResourceIsCreatedWithNoRestrictionsFlag) {
auto maxSize = GmmHelper::maxPossiblePitch;
MemoryManager *mm = new OsAgnosticMemoryManager;
MemoryManager *mm = new OsAgnosticMemoryManager(false, false);
void *pSysMem = mm->allocateSystemMemory(4096, 4096);
auto gmmRes = new Gmm(pSysMem, maxSize, false);

2
unit_tests/kernel/kernel_image_arg_tests.cpp
View File

@@ -205,7 +205,7 @@ HWTEST_F(KernelImageArgTest, givenImgWithMcsAllocWhenMakeResidentThenMakeMcsAllo
cl_mem memObj = img;
pKernel->setArg(0, sizeof(memObj), &memObj);
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager());
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager(false, false));
std::unique_ptr<MockCsr<FamilyType>> csr(new MockCsr<FamilyType>(execStamp, *pDevice->executionEnvironment));
csr->setMemoryManager(memoryManager.get());

2
unit_tests/kernel/kernel_tests.cpp
View File

@@ -500,7 +500,7 @@ TEST_F(KernelPrivateSurfaceTest, testPrivateSurface) {
ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
// Test it
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager());
std::unique_ptr<OsAgnosticMemoryManager> memoryManager(new OsAgnosticMemoryManager(false, false));
std::unique_ptr<CommandStreamReceiverMock> csr(new CommandStreamReceiverMock());
csr->setMemoryManager(memoryManager.get());
csr->residency.clear();

4
unit_tests/libult/ult_command_stream_receiver.h
View File

@@ -78,8 +78,8 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily> {
}
}
virtual MemoryManager *createMemoryManager(bool enable64kbPages) override {
memoryManager = new OsAgnosticMemoryManager(enable64kbPages);
virtual MemoryManager *createMemoryManager(bool enable64kbPages, bool enableLocalMemory) override {
memoryManager = new OsAgnosticMemoryManager(enable64kbPages, enableLocalMemory);
return memoryManager;
}

4
unit_tests/memory_manager/memory_manager_allocate_in_preferred_pool_tests.cpp
View File

@@ -202,7 +202,7 @@ TEST(MemoryManagerTest, givenForced32BitDisabledWhenGraphicsMemoryWith32BitFlagF
}
TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryMustBeHostMemoryAndIsAllocatedWithNullptrForBufferThen64kbAllocationIsReturned) {
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
AllocationData allocData;
MockMemoryManager::getAllocationData(allocData, true, nullptr, 10, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
@@ -263,7 +263,7 @@ TEST(MemoryManagerTest, givenForced32BitAndEnabled64kbPagesWhenGraphicsMemoryMus
}
TEST(MemoryManagerTest, givenEnabled64kbPagesWhenGraphicsMemoryIsAllocatedWithHostPtrForBufferThenExistingMemoryIsUsedForAllocation) {
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
AllocationData allocData;
char memory[1];
MockMemoryManager::getAllocationData(allocData, false, &memory, 1, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);

22
unit_tests/memory_manager/memory_manager_tests.cpp
View File

@@ -585,7 +585,7 @@ TEST_F(MemoryAllocatorTest, givenTimestampPacketAllocatorWhenAskingForTagThenRet
class MyMockMemoryManager : public OsAgnosticMemoryManager {
public:
using OsAgnosticMemoryManager::timestampPacketAllocator;
MyMockMemoryManager() : OsAgnosticMemoryManager(false){};
MyMockMemoryManager() : OsAgnosticMemoryManager(false, false){};
} myMockMemoryManager;
EXPECT_EQ(nullptr, myMockMemoryManager.timestampPacketAllocator.get());
@@ -837,7 +837,7 @@ TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerAndUnifiedAuxCapableAlloc
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocateGraphicsMemoryIsCalledThenMemoryPoolIsSystem4KBPages) {
OsAgnosticMemoryManager memoryManager(false);
OsAgnosticMemoryManager memoryManager(false, false);
auto size = 4096u;
auto allocation = memoryManager.allocateGraphicsMemory(size);
@@ -852,7 +852,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocateGraphicsMemoryIsCall
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemory64kbIsCalledThenMemoryPoolIsSystem64KBPages) {
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
auto size = 4096u;
auto allocation = memoryManager.allocateGraphicsMemory64kb(size, MemoryConstants::preferredAlignment, false, false);
@@ -864,7 +864,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocate
TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemoryFailsThenNullptrIsReturned) {
class MockOsAgnosticManagerWithFailingAllocate : public OsAgnosticMemoryManager {
public:
MockOsAgnosticManagerWithFailingAllocate(bool enable64kbPages) : OsAgnosticMemoryManager(enable64kbPages) {}
MockOsAgnosticManagerWithFailingAllocate(bool enable64kbPages) : OsAgnosticMemoryManager(enable64kbPages, false) {}
GraphicsAllocation *allocateGraphicsMemory(size_t size, size_t alignment, bool forcePin, bool uncacheable) override {
return nullptr;
@@ -879,7 +879,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocate
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocateGraphicsMemoryWithPtrIsCalledThenMemoryPoolIsSystem4KBPages) {
OsAgnosticMemoryManager memoryManager(false);
OsAgnosticMemoryManager memoryManager(false, false);
void *ptr = reinterpret_cast<void *>(0x1001);
auto size = MemoryConstants::pageSize;
@@ -892,7 +892,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocateGraphicsMemoryWithPt
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryWithPtrIsCalledThenMemoryPoolIsSystem4KBPagesWith32BitGpuAddressing) {
OsAgnosticMemoryManager memoryManager(false);
OsAgnosticMemoryManager memoryManager(false, false);
void *ptr = reinterpret_cast<void *>(0x1001);
auto size = MemoryConstants::pageSize;
@@ -905,7 +905,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryW
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryWithoutPtrIsCalledThenMemoryPoolIsSystem4KBPagesWith32BitGpuAddressing) {
OsAgnosticMemoryManager memoryManager(false);
OsAgnosticMemoryManager memoryManager(false, false);
void *ptr = nullptr;
auto size = MemoryConstants::pageSize;
@@ -917,7 +917,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryW
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemoryForSVMIsCalledThenMemoryPoolIsSystem64KBPages) {
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
auto size = 4096u;
auto svmAllocation = memoryManager.allocateGraphicsMemoryForSVM(size, false);
@@ -927,7 +927,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocate
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesDisabledWhenAllocateGraphicsMemoryForSVMIsCalledThen4KBGraphicsAllocationIsReturned) {
OsAgnosticMemoryManager memoryManager(false);
OsAgnosticMemoryManager memoryManager(false, false);
auto size = 4096u;
auto isCoherent = true;
@@ -964,7 +964,7 @@ TEST(OsAgnosticMemoryManager, givenDeviceWith64kbPagesDisbledWhenCreatingMemoryM
}
TEST(OsAgnosticMemoryManager, givenMemoryManagerWith64KBPagesEnabledWhenAllocateGraphicsMemoryForSVMIsCalledThen64KBGraphicsAllocationIsReturned) {
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
auto size = 4096u;
auto isCoherent = true;
@@ -1224,7 +1224,7 @@ TEST(OsAgnosticMemoryManager, givenDisabledAsyncDeleterFlagWhenMemoryManagerIsCr
TEST(OsAgnosticMemoryManager, GivenEnabled64kbPagesWhenHostMemoryAllocationIsCreatedThenAlignedto64KbAllocationIsReturned) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.Enable64kbpages.set(true);
OsAgnosticMemoryManager memoryManager(true);
OsAgnosticMemoryManager memoryManager(true, false);
GraphicsAllocation *galloc = memoryManager.allocateGraphicsMemoryInPreferredPool(true, nullptr, 64 * 1024, GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY);
EXPECT_NE(nullptr, galloc);

2
unit_tests/memory_manager/surface_tests.cpp
View File

@@ -74,7 +74,7 @@ HWTEST_TYPED_TEST(SurfaceTest, GivenSurfaceWhenInterfaceIsUsedThenSurfaceBehaves
ExecutionEnvironment executionEnvironment;
MockCsr<FamilyType> *csr = new MockCsr<FamilyType>(execStamp, executionEnvironment);
auto memManager = csr->createMemoryManager(false);
auto memManager = csr->createMemoryManager(false, false);
Surface *surface = createSurface::Create<TypeParam>(this->data,
&this->buffer,

4
unit_tests/mocks/mock_device.cpp
View File

@@ -40,7 +40,7 @@ MockDevice::MockDevice(const HardwareInfo &hwInfo)
OCLRT::MockDevice::MockDevice(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment)
: Device(hwInfo, executionEnvironment) {
this->mockMemoryManager.reset(new OsAgnosticMemoryManager);
this->mockMemoryManager.reset(new OsAgnosticMemoryManager(false, this->getHardwareCapabilities().localMemorySupported));
this->osTime = MockOSTime::create();
mockWaTable = *hwInfo.pWaTable;
}
@@ -86,7 +86,7 @@ OCLRT::FailMemoryManager::FailMemoryManager() : MockMemoryManager() {
OCLRT::FailMemoryManager::FailMemoryManager(int32_t fail) : MockMemoryManager() {
allocations.reserve(fail);
agnostic = new OsAgnosticMemoryManager(false);
agnostic = new OsAgnosticMemoryManager(false, false);
this->fail = fail;
}

6
unit_tests/mocks/mock_memory_manager.h
View File

@@ -34,8 +34,8 @@ class MockMemoryManager : public OsAgnosticMemoryManager {
using MemoryManager::getAllocationData;
using MemoryManager::timestampPacketAllocator;
MockMemoryManager() = default;
MockMemoryManager(bool enable64pages) : OsAgnosticMemoryManager(enable64pages) {}
MockMemoryManager() : OsAgnosticMemoryManager(false, false){};
MockMemoryManager(bool enable64pages) : OsAgnosticMemoryManager(enable64pages, false) {}
GraphicsAllocation *allocateGraphicsMemory64kb(size_t size, size_t alignment, bool forcePin, bool preferRenderCompressed) override;
void setDeferredDeleter(DeferredDeleter *deleter);
void overrideAsyncDeleterFlag(bool newValue);
@@ -71,7 +71,7 @@ class GMockMemoryManager : public MockMemoryManager {
class MockAllocSysMemAgnosticMemoryManager : public OsAgnosticMemoryManager {
public:
MockAllocSysMemAgnosticMemoryManager() : OsAgnosticMemoryManager() {
MockAllocSysMemAgnosticMemoryManager() : OsAgnosticMemoryManager(false, false) {
ptrRestrictions = nullptr;
testRestrictions.minAddress = 0;
}

4
unit_tests/os_interface/linux/drm_command_stream_mm_tests.cpp
View File

@@ -48,7 +48,7 @@ HWTEST_F(DrmCommandStreamMMTest, MMwithPinBB) {
DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], executionEnvironment,
gemCloseWorkerMode::gemCloseWorkerInactive);
auto mm = (DrmMemoryManager *)csr.createMemoryManager(false);
auto mm = (DrmMemoryManager *)csr.createMemoryManager(false, false);
ASSERT_NE(nullptr, mm);
EXPECT_NE(nullptr, mm->getPinBB());
csr.setMemoryManager(nullptr);
@@ -72,7 +72,7 @@ HWTEST_F(DrmCommandStreamMMTest, givenForcePinDisabledWhenMemoryManagerIsCreated
DrmCommandStreamReceiver<FamilyType> csr(*platformDevices[0], executionEnvironment,
gemCloseWorkerMode::gemCloseWorkerInactive);
auto mm = (DrmMemoryManager *)csr.createMemoryManager(false);
auto mm = (DrmMemoryManager *)csr.createMemoryManager(false, false);
csr.setMemoryManager(nullptr);
ASSERT_NE(nullptr, mm);

4
unit_tests/os_interface/linux/drm_command_stream_tests.cpp
View File

@@ -74,7 +74,7 @@ class DrmCommandStreamFixture {
// Memory manager creates pinBB with ioctl, expect one call
EXPECT_CALL(*mock, ioctl(::testing::_, ::testing::_))
.Times(1);
mm = static_cast<DrmMemoryManager *>(csr->createMemoryManager(false));
mm = static_cast<DrmMemoryManager *>(csr->createMemoryManager(false, false));
::testing::Mock::VerifyAndClearExpectations(mock);
//assert we have memory manager
@@ -699,7 +699,7 @@ class DrmCommandStreamEnhancedFixture
tCsr = new TestedDrmCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME>(*executionEnvironment);
csr = tCsr;
ASSERT_NE(nullptr, csr);
mm = reinterpret_cast<DrmMemoryManager *>(csr->createMemoryManager(false));
mm = reinterpret_cast<DrmMemoryManager *>(csr->createMemoryManager(false, false));
ASSERT_NE(nullptr, mm);
executionEnvironment->memoryManager.reset(mm);
device = Device::create<MockDevice>(platformDevices[0], executionEnvironment);

6
unit_tests/os_interface/windows/device_command_stream_tests.cpp
View File

@@ -149,7 +149,7 @@ class WddmCommandStreamWithMockGdiFixture {
executionEnvironment->commandStreamReceiver = std::make_unique<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME>>(*platformDevices[0],
*executionEnvironment);
this->csr = static_cast<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME> *>(executionEnvironment->commandStreamReceiver.get());
memManager = csr->createMemoryManager(false);
memManager = csr->createMemoryManager(false, false);
ASSERT_NE(nullptr, memManager);
executionEnvironment->memoryManager.reset(memManager);
device = Device::create<MockDevice>(platformDevices[0], executionEnvironment);
@@ -271,7 +271,7 @@ TEST(WddmPreemptionHeaderTests, givenWddmCommandStreamReceiverWhenPreemptionIsOf
executionEnvironment.osInterface->get()->setWddm(wddm);
executionEnvironment.commandStreamReceiver = std::make_unique<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME>>(localHwInfo,
executionEnvironment);
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false));
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false, false));
executionEnvironment.commandStreamReceiver->overrideDispatchPolicy(DispatchMode::ImmediateDispatch);
@@ -299,7 +299,7 @@ TEST(WddmPreemptionHeaderTests, givenWddmCommandStreamReceiverWhenPreemptionIsOn
executionEnvironment.osInterface->get()->setWddm(wddm);
executionEnvironment.commandStreamReceiver = std::make_unique<MockWddmCsr<DEFAULT_TEST_FAMILY_NAME>>(localHwInfo,
executionEnvironment);
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false));
executionEnvironment.memoryManager.reset(executionEnvironment.commandStreamReceiver->createMemoryManager(false, false));
executionEnvironment.commandStreamReceiver->overrideDispatchPolicy(DispatchMode::ImmediateDispatch);
auto commandBuffer = executionEnvironment.memoryManager->allocateGraphicsMemory(4096);

12
unit_tests/os_interface/windows/wddm20_tests.cpp
View File

@@ -180,7 +180,7 @@ TEST_F(Wddm20Tests, whenInitializeWddmThenContextIsCreated) {
}
TEST_F(Wddm20Tests, allocation) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(mm.allocateSystemMemory(100, 0), 100, nullptr, MemoryPool::MemoryNull);
Gmm *gmm = GmmHelperFunctions::getGmm(allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize());
@@ -328,7 +328,7 @@ TEST_F(Wddm20WithMockGdiDllTests, GivenThreeOsHandlesWhenAskedForDestroyAllocati
}
TEST_F(Wddm20Tests, mapAndFreeGpuVa) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(mm.allocateSystemMemory(100, 0), 100, nullptr, MemoryPool::MemoryNull);
Gmm *gmm = GmmHelperFunctions::getGmm(allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize());
@@ -353,7 +353,7 @@ TEST_F(Wddm20Tests, mapAndFreeGpuVa) {
}
TEST_F(Wddm20Tests, givenNullAllocationWhenCreateThenAllocateAndMap) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(nullptr, 100, nullptr, MemoryPool::MemoryNull);
Gmm *gmm = GmmHelperFunctions::getGmm(allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize());
@@ -373,7 +373,7 @@ TEST_F(Wddm20Tests, givenNullAllocationWhenCreateThenAllocateAndMap) {
}
TEST_F(Wddm20Tests, makeResidentNonResident) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(mm.allocateSystemMemory(100, 0), 100, nullptr, MemoryPool::MemoryNull);
Gmm *gmm = GmmHelperFunctions::getGmm(allocation.getUnderlyingBuffer(), allocation.getUnderlyingBufferSize());
@@ -578,7 +578,7 @@ TEST(DebugFlagTest, givenDebugManagerWhenGetForUseNoRingFlushesKmdModeIsCalledTh
}
TEST_F(Wddm20Tests, makeResidentMultipleHandles) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(mm.allocateSystemMemory(100, 0), 100, nullptr, MemoryPool::MemoryNull);
allocation.handle = ALLOCATION_HANDLE;
@@ -600,7 +600,7 @@ TEST_F(Wddm20Tests, makeResidentMultipleHandles) {
}
TEST_F(Wddm20Tests, makeResidentMultipleHandlesWithReturnBytesToTrim) {
OsAgnosticMemoryManager mm(false);
OsAgnosticMemoryManager mm(false, false);
WddmAllocation allocation(mm.allocateSystemMemory(100, 0), 100, nullptr, MemoryPool::MemoryNull);
allocation.handle = ALLOCATION_HANDLE;