Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Initialize root command stream receiver

Browse Source 
Change-Id: I90c4ee9c0e24b1f9182f100213bf6a1ec70df3a8
Signed-off-by: Jobczyk, Lukasz <lukasz.jobczyk@intel.com>
This commit is contained in:
Jobczyk, Lukasz
2020-01-20 07:02:07 +01:00
committed by sys_ocldev
parent 79630bb5ac
commit 39cb48024a
8 changed files with 42 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/device/CMakeLists.txt
View File

@ -18,7 +18,6 @@ set(RUNTIME_SRCS_DEVICE
${CMAKE_CURRENT_SOURCE_DIR}/driver_info.h
${CMAKE_CURRENT_SOURCE_DIR}/root_device.cpp
${CMAKE_CURRENT_SOURCE_DIR}/root_device.h
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/root_device_initialize.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sub_device.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sub_device.h
)

26
runtime/device/root_device.cpp
View File

@ -7,11 +7,16 @@
#include "runtime/device/root_device.h"
#include "core/command_stream/preemption.h"
#include "core/debug_settings/debug_settings_manager.h"
#include "core/helpers/hw_helper.h"
#include "runtime/command_stream/command_stream_receiver.h"
#include "runtime/device/sub_device.h"
#include "runtime/memory_manager/memory_manager.h"
namespace NEO {
extern CommandStreamReceiver *createCommandStream(ExecutionEnvironment &executionEnvironment, uint32_t rootDeviceIndex);
RootDevice::RootDevice(ExecutionEnvironment *executionEnvironment, uint32_t rootDeviceIndex) : Device(executionEnvironment), rootDeviceIndex(rootDeviceIndex) {}
RootDevice::~RootDevice() {
@ -80,9 +85,28 @@ DeviceBitfield RootDevice::getDeviceBitfield() const {
}
bool RootDevice::createEngines() {
if (!initializeRootCommandStreamReceiver()) {
if (getNumSubDevices() < 2) {
return Device::createEngines();
} else {
initializeRootCommandStreamReceiver();
}
return true;
}
void RootDevice::initializeRootCommandStreamReceiver() {
std::unique_ptr<CommandStreamReceiver> rootCommandStreamReceiver(createCommandStream(*executionEnvironment, rootDeviceIndex));
auto &hwInfo = getHardwareInfo();
auto defaultEngineType = getChosenEngineType(hwInfo);
auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(hwInfo);
auto osContext = getMemoryManager()->createAndRegisterOsContext(rootCommandStreamReceiver.get(), defaultEngineType,
getDeviceBitfield(), preemptionMode, false);
rootCommandStreamReceiver->setupContext(*osContext);
rootCommandStreamReceiver->initializeTagAllocation();
commandStreamReceivers.push_back(std::move(rootCommandStreamReceiver));
engines.emplace_back(commandStreamReceivers.back().get(), osContext);
}
} // namespace NEO

2
runtime/device/root_device.h
View File

@ -28,7 +28,7 @@ class RootDevice : public Device {
DeviceBitfield getDeviceBitfield() const override;
bool createEngines() override;
MOCKABLE_VIRTUAL bool initializeRootCommandStreamReceiver();
void initializeRootCommandStreamReceiver();
MOCKABLE_VIRTUAL SubDevice *createSubDevice(uint32_t subDeviceIndex);
std::vector<SubDevice *> subdevices;

15
runtime/device/root_device_initialize.cpp
View File

@ -1,15 +0,0 @@
/*
* Copyright (C) 2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/device/root_device.h"
namespace NEO {
bool RootDevice::initializeRootCommandStreamReceiver() {
return false;
}
} // namespace NEO

3
runtime/execution_environment/execution_environment.cpp
View File

@ -77,9 +77,10 @@ void ExecutionEnvironment::calculateMaxOsContextCount() {
auto &hwHelper = HwHelper::get(this->hwInfo->platform.eRenderCoreFamily);
auto osContextCount = hwHelper.getGpgpuEngineInstances().size();
auto subDevicesCount = HwHelper::getSubDevicesCount(this->getHardwareInfo());
auto rootDevicesCount = this->rootDeviceEnvironments.size();
bool hasRootCsr = subDevicesCount > 1;
MemoryManager::maxOsContextCount = static_cast<uint32_t>(osContextCount * subDevicesCount * this->rootDeviceEnvironments.size() + hasRootCsr);
MemoryManager::maxOsContextCount = static_cast<uint32_t>(rootDevicesCount * (osContextCount * subDevicesCount + hasRootCsr));
}
GmmHelper *ExecutionEnvironment::getGmmHelper() const {

21
unit_tests/device/sub_device_tests.cpp
View File

@ -156,21 +156,26 @@ TEST(SubDevicesTest, givenSubDevicesWhenGettingDeviceByIdZeroThenGetThisSubDevic
EXPECT_THROW(subDevice->getDeviceById(1), std::exception);
}
TEST(RootDevicesTest, givenRootDeviceWhenInitializeRootCommandStreamReceiverReturnsTrueThenDeviceDoesntCreateExtraEngines) {
TEST(RootDevicesTest, givenRootDeviceWithoutSubdevicesWhenCreateEnginesThenDeviceCreatesCorrectNumberOfEngines) {
auto hwInfo = *platformDevices[0];
auto &gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances();
auto executionEnvironment = new MockExecutionEnvironment;
MockDevice device(executionEnvironment, 0);
device.callBaseInitializeRootCommandStreamReceiver = false;
device.initializeRootCommandStreamReceiverReturnValue = true;
EXPECT_EQ(0u, device.engines.size());
device.createEngines();
EXPECT_EQ(0u, device.engines.size());
EXPECT_EQ(gpgpuEngines.size(), device.engines.size());
}
TEST(RootDevicesTest, givenRootDeviceWhenInitializeRootCommandStreamReceiverReturnsFalseThenDeviceCreatesExtraEngines) {
TEST(RootDevicesTest, givenRootDeviceWithSubdevicesWhenCreateEnginesThenDeviceCreatesSpecialEngine) {
DebugManagerStateRestore restorer;
DebugManager.flags.CreateMultipleSubDevices.set(2);
VariableBackup<bool> mockDeviceFlagBackup(&MockDevice::createSingleDevice, false);
auto executionEnvironment = new MockExecutionEnvironment;
MockDevice device(executionEnvironment, 0);
device.callBaseInitializeRootCommandStreamReceiver = false;
device.initializeRootCommandStreamReceiverReturnValue = false;
device.subdevices.resize(2u);
EXPECT_EQ(0u, device.engines.size());
device.createEngines();
EXPECT_LT(0u, device.engines.size());
EXPECT_EQ(1u, device.engines.size());
}

2
unit_tests/mocks/mock_device.cpp
View File

@ -26,8 +26,6 @@ decltype(&createCommandStream) &MockClDevice::createCommandStreamReceiverFunc =
MockClDevice::MockClDevice(MockDevice *pMockDevice)
: ClDevice(*pMockDevice), device(*pMockDevice), deviceInfo(pMockDevice->deviceInfo),
executionEnvironment(pMockDevice->executionEnvironment),
callBaseInitializeRootCommandStreamReceiver(pMockDevice->callBaseInitializeRootCommandStreamReceiver),
initializeRootCommandStreamReceiverReturnValue(pMockDevice->initializeRootCommandStreamReceiverReturnValue),
subdevices(pMockDevice->subdevices), mockMemoryManager(pMockDevice->mockMemoryManager), engines(pMockDevice->engines) {
platform()->clDeviceMap.emplace(pMockDevice, this);

14
unit_tests/mocks/mock_device.h
View File

@ -107,12 +107,6 @@ class MockDevice : public RootDevice {
executionEnvironment->setHwInfo(pHwInfo);
return createWithExecutionEnvironment<T>(pHwInfo, executionEnvironment, rootDeviceIndex);
}
bool initializeRootCommandStreamReceiver() override {
if (callBaseInitializeRootCommandStreamReceiver) {
return RootDevice::initializeRootCommandStreamReceiver();
}
return initializeRootCommandStreamReceiverReturnValue;
}
SubDevice *createSubDevice(uint32_t subDeviceIndex) override {
return Device::create<MockSubDevice>(executionEnvironment, subDeviceIndex, *this);
@ -121,11 +115,8 @@ class MockDevice : public RootDevice {
std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const override {
return std::unique_ptr<CommandStreamReceiver>(createCommandStreamReceiverFunc(*executionEnvironment, getRootDeviceIndex()));
}
static decltype(&createCommandStream) createCommandStreamReceiverFunc;
bool callBaseInitializeRootCommandStreamReceiver = true;
bool initializeRootCommandStreamReceiverReturnValue = false;
std::unique_ptr<MemoryManager> mockMemoryManager;
};
@ -163,7 +154,6 @@ class MockClDevice : public ClDevice {
static T *createWithNewExecutionEnvironment(const HardwareInfo *pHwInfo, uint32_t rootDeviceIndex = 0) {
return MockDevice::createWithNewExecutionEnvironment<T>(pHwInfo, rootDeviceIndex);
}
bool initializeRootCommandStreamReceiver() { return device.initializeRootCommandStreamReceiver(); }
SubDevice *createSubDevice(uint32_t subDeviceIndex) { return device.createSubDevice(subDeviceIndex); }
std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const { return device.createCommandStreamReceiver(); }
@ -172,8 +162,6 @@ class MockClDevice : public ClDevice {
ExecutionEnvironment *&executionEnvironment;
static bool &createSingleDevice;
static decltype(&createCommandStream) &createCommandStreamReceiverFunc;
bool &callBaseInitializeRootCommandStreamReceiver;
bool &initializeRootCommandStreamReceiverReturnValue;
std::vector<SubDevice *> &subdevices;
std::unique_ptr<MemoryManager> &mockMemoryManager;
std::vector<EngineControl> &engines;