Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move setting external memory managers to mock layers.

Browse Source 
Change-Id: I335fd35269da9093c9e744c2735215e8d561098c
This commit is contained in:
Mrozek, Michal
2018-07-20 09:01:58 +02:00
committed by sys_ocldev
parent 239ebf9eab
commit 366a12e3ce
7 changed files with 45 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
runtime/device/device.cpp
View File

@ -132,7 +132,7 @@ bool Device::createDeviceImpl(const HardwareInfo *pHwInfo, Device &outDevice) {
return false;
}
executionEnvironment->initializeMemoryManager(outDevice.executionEnvironment->memoryManager.get(), outDevice.getEnabled64kbPages());
executionEnvironment->initializeMemoryManager(outDevice.getEnabled64kbPages());
CommandStreamReceiver *commandStreamReceiver = executionEnvironment->commandStreamReceiver.get();
if (!commandStreamReceiver->initializeTagAllocation()) {

15
runtime/device/device.h
View File

@ -53,11 +53,7 @@ class Device : public BaseObject<_cl_device_id> {
static T *create(const HardwareInfo *pHwInfo, ExecutionEnvironment *execEnv) {
pHwInfo = getDeviceInitHwInfo(pHwInfo);
T *device = new T(*pHwInfo, execEnv);
if (false == createDeviceImpl(pHwInfo, *device)) {
delete device;
return nullptr;
}
return device;
return createDeviceInternals(pHwInfo, device);
}
Device &operator=(const Device &) = delete;
@ -139,6 +135,15 @@ class Device : public BaseObject<_cl_device_id> {
Device() = delete;
Device(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment);
template <typename T>
static T *createDeviceInternals(const HardwareInfo *pHwInfo, T *device) {
if (false == createDeviceImpl(pHwInfo, *device)) {
delete device;
return nullptr;
}
return device;
}
static bool createDeviceImpl(const HardwareInfo *pHwInfo, Device &outDevice);
static const HardwareInfo *getDeviceInitHwInfo(const HardwareInfo *pHwInfoIn);
MOCKABLE_VIRTUAL void initializeCaps();

12
runtime/execution_environment/execution_environment.cpp
View File

@ -45,17 +45,15 @@ bool ExecutionEnvironment::initializeCommandStreamReceiver(const HardwareInfo *p
this->commandStreamReceiver.reset(commandStreamReceiver);
return true;
}
void ExecutionEnvironment::initializeMemoryManager(MemoryManager *externalMemoryManager, bool enable64KBpages) {
void ExecutionEnvironment::initializeMemoryManager(bool enable64KBpages) {
if (this->memoryManager) {
commandStreamReceiver->setMemoryManager(this->memoryManager.get());
return;
}
if (!externalMemoryManager) {
memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages));
commandStreamReceiver->setMemoryManager(memoryManager.get());
} else {
commandStreamReceiver->setMemoryManager(externalMemoryManager);
}
memoryManager.reset(commandStreamReceiver->createMemoryManager(enable64KBpages));
commandStreamReceiver->setMemoryManager(memoryManager.get());
DEBUG_BREAK_IF(!this->memoryManager);
}

2
runtime/execution_environment/execution_environment.h
View File

@ -40,7 +40,7 @@ class ExecutionEnvironment : public ReferenceTrackedObject<ExecutionEnvironment>
~ExecutionEnvironment() override;
void initGmm(const HardwareInfo *hwInfo);
bool initializeCommandStreamReceiver(const HardwareInfo *pHwInfo);
void initializeMemoryManager(MemoryManager *externalMemoryManager, bool enable64KBpages);
void initializeMemoryManager(bool enable64KBpages);
std::unique_ptr<MemoryManager> memoryManager;
std::unique_ptr<CommandStreamReceiver> commandStreamReceiver;
};

10
unit_tests/execution_environment/execution_environment_tests.cpp
View File

@ -106,18 +106,10 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeCommandStreamR
TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenItIsInitalized) {
std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
executionEnvironment->initializeCommandStreamReceiver(platformDevices[0]);
executionEnvironment->initializeMemoryManager(nullptr, false);
executionEnvironment->initializeMemoryManager(false);
EXPECT_NE(nullptr, executionEnvironment->memoryManager);
}
TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerWithExternalMemoryManagerIsCalledThenItIsSetToExternal) {
std::unique_ptr<MemoryManager> memoryManager(new OsAgnosticMemoryManager);
std::unique_ptr<ExecutionEnvironment> executionEnvironment(new ExecutionEnvironment);
executionEnvironment->initializeCommandStreamReceiver(platformDevices[0]);
executionEnvironment->initializeMemoryManager(memoryManager.get(), false);
EXPECT_EQ(memoryManager.get(), executionEnvironment->commandStreamReceiver->getMemoryManager());
}
auto destructorId = 0u;
static_assert(sizeof(ExecutionEnvironment) == (is64bit ? 48 : 28), "New members detected in ExecutionEnvironment, please ensure that destruction sequence of objects is correct");

9
unit_tests/mocks/mock_device.cpp
View File

@ -34,17 +34,22 @@ MockDevice::MockDevice(const HardwareInfo &hwInfo)
: MockDevice(hwInfo, new ExecutionEnvironment) {
CommandStreamReceiver *commandStreamReceiver = createCommandStream(&hwInfo);
executionEnvironment->commandStreamReceiver.reset(commandStreamReceiver);
commandStreamReceiver->setMemoryManager(this->mockMemoryManager.get());
this->executionEnvironment->memoryManager = std::move(this->mockMemoryManager);
}
OCLRT::MockDevice::MockDevice(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment)
: Device(hwInfo, executionEnvironment) {
this->executionEnvironment->memoryManager.reset(new OsAgnosticMemoryManager);
this->mockMemoryManager.reset(new OsAgnosticMemoryManager);
this->osTime = MockOSTime::create();
mockWaTable = *hwInfo.pWaTable;
}
void MockDevice::setMemoryManager(MemoryManager *memoryManager) {
executionEnvironment->memoryManager.reset(memoryManager);
if (executionEnvironment->commandStreamReceiver) {
executionEnvironment->commandStreamReceiver->setMemoryManager(memoryManager);
}
}
void MockDevice::setOSTime(OSTime *osTime) {
@ -87,5 +92,5 @@ OCLRT::FailMemoryManager::FailMemoryManager(int32_t fail) : MockMemoryManager()
}
MockAlignedMallocManagerDevice::MockAlignedMallocManagerDevice(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment) : MockDevice(hwInfo, executionEnvironment) {
executionEnvironment->memoryManager.reset(new MockAllocSysMemAgnosticMemoryManager());
this->mockMemoryManager.reset(new MockAllocSysMemAgnosticMemoryManager());
}

32
unit_tests/mocks/mock_device.h
View File

@ -106,6 +106,7 @@ class MockDevice : public Device {
void setSourceLevelDebuggerActive(bool active) {
this->deviceInfo.sourceLevelDebuggerActive = active;
}
template <typename T>
static T *createWithMemoryManager(const HardwareInfo *pHwInfo,
MemoryManager *memManager) {
@ -114,15 +115,16 @@ class MockDevice : public Device {
if (memManager) {
device->setMemoryManager(memManager);
}
if (false == createDeviceImpl(pHwInfo, *device)) {
delete device;
return nullptr;
}
return device;
return createDeviceInternals(pHwInfo, device);
}
template <typename T>
static T *createWithNewExecutionEnvironment(const HardwareInfo *pHwInfo) {
return Device::create<T>(pHwInfo, new ExecutionEnvironment);
auto executionEnvironment = new ExecutionEnvironment;
pHwInfo = getDeviceInitHwInfo(pHwInfo);
T *device = new T(*pHwInfo, executionEnvironment);
executionEnvironment->memoryManager = std::move(device->mockMemoryManager);
return createDeviceInternals(pHwInfo, device);
}
void allocatePreemptionAllocationIfNotPresent() {
@ -136,6 +138,7 @@ class MockDevice : public Device {
}
}
}
std::unique_ptr<MemoryManager> mockMemoryManager;
private:
bool forceWhitelistedRegs = false;
@ -143,6 +146,11 @@ class MockDevice : public Device {
WorkaroundTable mockWaTable = {};
};
template <>
inline Device *MockDevice::createWithNewExecutionEnvironment<Device>(const HardwareInfo *pHwInfo) {
return Device::create<Device>(pHwInfo, new ExecutionEnvironment);
}
class FailMemoryManager : public MockMemoryManager {
public:
FailMemoryManager();
@ -207,19 +215,19 @@ class FailMemoryManager : public MockMemoryManager {
std::vector<GraphicsAllocation *> allocations;
};
class FailDevice : public Device {
class FailDevice : public MockDevice {
public:
FailDevice(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment)
: Device(hwInfo, executionEnvironment) {
this->executionEnvironment->memoryManager.reset(new FailMemoryManager);
: MockDevice(hwInfo, executionEnvironment) {
this->mockMemoryManager.reset(new FailMemoryManager);
}
};
class FailDeviceAfterOne : public Device {
class FailDeviceAfterOne : public MockDevice {
public:
FailDeviceAfterOne(const HardwareInfo &hwInfo, ExecutionEnvironment *executionEnvironment)
: Device(hwInfo, executionEnvironment) {
this->executionEnvironment->memoryManager.reset(new FailMemoryManager(1));
: MockDevice(hwInfo, executionEnvironment) {
this->mockMemoryManager.reset(new FailMemoryManager(1));
}
};