From b93817fe7c0ecd397116f8997221309b9085485e Mon Sep 17 00:00:00 2001 From: Mateusz Jablonski Date: Mon, 7 Oct 2019 12:42:28 +0200 Subject: [PATCH] Use DeviceHelper to calculate number of sub devices Related-To: NEO-3691 Change-Id: I390b7919fe8960b74cf290923f5daf128d824674 Signed-off-by: Mateusz Jablonski --- runtime/device/device.h | 2 +- runtime/device/root_device.cpp | 29 ++++++-- runtime/device/root_device.h | 3 +- .../execution_environment.cpp | 8 --- .../execution_environment.h | 5 +- .../execution_environment_initialize.cpp | 3 +- runtime/helpers/device_helpers.cpp | 2 +- .../windows/device_factory_win.cpp | 6 +- runtime/platform/platform.cpp | 1 - ...te_command_queue_with_properties_tests.cpp | 4 +- unit_tests/aub/aub_helper_tests.inl | 6 +- .../command_queue/command_queue_tests.cpp | 2 + unit_tests/device/device_tests.cpp | 7 +- unit_tests/device/sub_device_tests.cpp | 58 +++++++++++++-- .../execution_environment_tests.cpp | 71 +++++-------------- unit_tests/mocks/mock_device.cpp | 9 +++ unit_tests/mocks/mock_device.h | 3 + unit_tests/mocks/mock_execution_environment.h | 13 ++-- 18 files changed, 141 insertions(+), 91 deletions(-) diff --git a/runtime/device/device.h b/runtime/device/device.h index 870da62390..faa8cba7b8 100644 --- a/runtime/device/device.h +++ b/runtime/device/device.h @@ -116,7 +116,7 @@ class Device : public BaseObject<_cl_device_id> { virtual bool createDeviceImpl(); virtual DeviceBitfield getDeviceBitfieldForOsContext() const = 0; - bool createEngines(); + virtual bool createEngines(); bool createEngine(uint32_t deviceIndex, uint32_t deviceCsrIndex, aub_stream::EngineType engineType); MOCKABLE_VIRTUAL void initializeCaps(); diff --git a/runtime/device/root_device.cpp b/runtime/device/root_device.cpp index bbd59b7c2c..80cb8841c2 100644 --- a/runtime/device/root_device.cpp +++ b/runtime/device/root_device.cpp @@ -8,6 +8,7 @@ #include "runtime/device/root_device.h" #include "runtime/device/sub_device.h" +#include "runtime/helpers/device_helpers.h" #include "runtime/os_interface/debug_settings_manager.h" namespace NEO { @@ -39,13 +40,12 @@ Device *RootDevice::getDeviceById(uint32_t deviceId) const { RootDevice::RootDevice(ExecutionEnvironment *executionEnvironment, uint32_t deviceIndex) : Device(executionEnvironment, deviceIndex) {} bool RootDevice::createDeviceImpl() { - auto status = Device::createDeviceImpl(); - if (!status) { - return status; + auto numSubDevices = DeviceHelper::getDevicesCount(&getHardwareInfo()); + if (numSubDevices == 1) { + numSubDevices = 0; } - auto numSubDevices = DebugManager.flags.CreateMultipleSubDevices.get(); subdevices.reserve(numSubDevices); - for (int i = 0; i < numSubDevices; i++) { + for (auto i = 0u; i < numSubDevices; i++) { auto subDevice = Device::create(executionEnvironment, deviceIndex + i + 1, i, *this); if (!subDevice) { @@ -53,6 +53,10 @@ bool RootDevice::createDeviceImpl() { } subdevices.push_back(std::unique_ptr(subDevice)); } + auto status = Device::createDeviceImpl(); + if (!status) { + return status; + } return true; } @@ -70,4 +74,19 @@ DeviceBitfield RootDevice::getDeviceBitfieldForOsContext() const { deviceBitfield.set(deviceIndex); return deviceBitfield; } + +bool RootDevice::createEngines() { + if (!executionEnvironment->initializeRootCommandStreamReceiver(*this)) { + return Device::createEngines(); + } + return true; +} + +void RootDevice::setupRootEngine(EngineControl engine) { + if (engines.size() > 0u) { + return; + } + defaultEngineIndex = 0; + engines.emplace_back(engine); +} } // namespace NEO diff --git a/runtime/device/root_device.h b/runtime/device/root_device.h index b83226cfda..7f98e689cd 100644 --- a/runtime/device/root_device.h +++ b/runtime/device/root_device.h @@ -21,13 +21,14 @@ class RootDevice : public Device { uint32_t getNumSubDevices() const; uint32_t getRootDeviceIndex() const override; Device *getDeviceById(uint32_t deviceId) const override; - /* We hide the retain and release function of BaseObject. */ void retain() override; unique_ptr_if_unused release() override; + void setupRootEngine(EngineControl engineControl); protected: DeviceBitfield getDeviceBitfieldForOsContext() const override; + bool createEngines() override; std::vector> subdevices; }; } // namespace NEO diff --git a/runtime/execution_environment/execution_environment.cpp b/runtime/execution_environment/execution_environment.cpp index 37d796447e..8792ab92ca 100644 --- a/runtime/execution_environment/execution_environment.cpp +++ b/runtime/execution_environment/execution_environment.cpp @@ -120,14 +120,6 @@ BuiltIns *ExecutionEnvironment::getBuiltIns() { return this->builtins.get(); } -EngineControl *ExecutionEnvironment::getEngineControlForSpecialCsr() { - EngineControl *engine = nullptr; - if (specialCommandStreamReceiver.get()) { - engine = memoryManager->getRegisteredEngineForCsr(specialCommandStreamReceiver.get()); - } - return engine; -} - bool ExecutionEnvironment::isFullRangeSvm() const { return hwInfo->capabilityTable.gpuAddressSpace >= maxNBitValue<47>; } diff --git a/runtime/execution_environment/execution_environment.h b/runtime/execution_environment/execution_environment.h index 1b3539b360..2f76cf8644 100644 --- a/runtime/execution_environment/execution_environment.h +++ b/runtime/execution_environment/execution_environment.h @@ -24,6 +24,7 @@ class GmmHelper; class MemoryManager; class SourceLevelDebugger; class OSInterface; +class RootDevice; class MemoryOperationsHandler; struct EngineControl; struct HardwareInfo; @@ -44,7 +45,7 @@ class ExecutionEnvironment : public ReferenceTrackedObject MOCKABLE_VIRTUAL void initAubCenter(bool localMemoryEnabled, const std::string &aubFileName, CommandStreamReceiverType csrType); void initGmm(); bool initializeCommandStreamReceiver(uint32_t deviceIndex, uint32_t deviceCsrIndex); - void initializeSpecialCommandStreamReceiver(); + MOCKABLE_VIRTUAL bool initializeRootCommandStreamReceiver(RootDevice &rootDevice); void initializeMemoryManager(); void initSourceLevelDebugger(); void setHwInfo(const HardwareInfo *hwInfo); @@ -55,14 +56,12 @@ class ExecutionEnvironment : public ReferenceTrackedObject GmmHelper *getGmmHelper() const; MOCKABLE_VIRTUAL CompilerInterface *getCompilerInterface(); BuiltIns *getBuiltIns(); - EngineControl *getEngineControlForSpecialCsr(); std::unique_ptr osInterface; std::unique_ptr memoryOperationsInterface; std::unique_ptr memoryManager; std::unique_ptr aubCenter; CsrContainer commandStreamReceivers; - std::unique_ptr specialCommandStreamReceiver; std::unique_ptr builtins; std::unique_ptr compilerInterface; std::unique_ptr sourceLevelDebugger; diff --git a/runtime/execution_environment/execution_environment_initialize.cpp b/runtime/execution_environment/execution_environment_initialize.cpp index 9068c4f64f..2e72d0945b 100644 --- a/runtime/execution_environment/execution_environment_initialize.cpp +++ b/runtime/execution_environment/execution_environment_initialize.cpp @@ -8,7 +8,8 @@ #include "runtime/execution_environment/execution_environment.h" namespace NEO { -void ExecutionEnvironment::initializeSpecialCommandStreamReceiver() { +bool ExecutionEnvironment::initializeRootCommandStreamReceiver(RootDevice &device) { + return false; } } // namespace NEO diff --git a/runtime/helpers/device_helpers.cpp b/runtime/helpers/device_helpers.cpp index 6b26a4fb55..c9379ea537 100644 --- a/runtime/helpers/device_helpers.cpp +++ b/runtime/helpers/device_helpers.cpp @@ -14,7 +14,7 @@ namespace NEO { void DeviceHelper::getExtraDeviceInfo(const HardwareInfo &hwInfo, cl_device_info paramName, cl_uint ¶m, const void *&src, size_t &size, size_t &retSize) {} uint32_t DeviceHelper::getDevicesCount(const HardwareInfo *pHwInfo) { - return DebugManager.flags.CreateMultipleRootDevices.get() > 0 ? DebugManager.flags.CreateMultipleRootDevices.get() : 1u; + return DebugManager.flags.CreateMultipleSubDevices.get() > 0 ? DebugManager.flags.CreateMultipleSubDevices.get() : 1u; } uint32_t DeviceHelper::getEnginesCount(const HardwareInfo &hwInfo) { diff --git a/runtime/os_interface/windows/device_factory_win.cpp b/runtime/os_interface/windows/device_factory_win.cpp index 46ab215ff1..92f72a9150 100644 --- a/runtime/os_interface/windows/device_factory_win.cpp +++ b/runtime/os_interface/windows/device_factory_win.cpp @@ -8,7 +8,6 @@ #ifdef _WIN32 #include "runtime/device/device.h" -#include "runtime/helpers/device_helpers.h" #include "runtime/os_interface/debug_settings_manager.h" #include "runtime/os_interface/device_factory.h" #include "runtime/os_interface/hw_info_config.h" @@ -31,7 +30,10 @@ bool DeviceFactory::getDevices(size_t &numDevices, ExecutionEnvironment &executi return false; } - auto totalDeviceCount = DeviceHelper::getDevicesCount(hardwareInfo); + auto totalDeviceCount = 1u; + if (DebugManager.flags.CreateMultipleRootDevices.get()) { + totalDeviceCount = DebugManager.flags.CreateMultipleRootDevices.get(); + } executionEnvironment.memoryOperationsInterface = std::make_unique(wddm.get()); executionEnvironment.osInterface.reset(new OSInterface()); diff --git a/runtime/platform/platform.cpp b/runtime/platform/platform.cpp index 40bc197056..e8a6fcaad4 100644 --- a/runtime/platform/platform.cpp +++ b/runtime/platform/platform.cpp @@ -173,7 +173,6 @@ bool Platform::initialize() { return false; } } - executionEnvironment->initializeSpecialCommandStreamReceiver(); auto hwInfo = executionEnvironment->getHardwareInfo(); diff --git a/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp b/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp index 3cd969bf4c..2dec16eb53 100644 --- a/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp +++ b/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp @@ -8,13 +8,14 @@ #include "core/unit_tests/helpers/debug_manager_state_restore.h" #include "runtime/command_queue/command_queue.h" #include "runtime/command_stream/command_stream_receiver.h" -#include "runtime/device/device.h" #include "runtime/device_queue/device_queue.h" #include "runtime/helpers/hw_helper.h" #include "runtime/os_interface/os_context.h" #include "unit_tests/fixtures/memory_management_fixture.h" #include "unit_tests/helpers/unit_test_helper.h" +#include "unit_tests/helpers/variable_backup.h" #include "unit_tests/mocks/mock_context.h" +#include "unit_tests/mocks/mock_device.h" #include "CL/cl_ext.h" #include "cl_api_tests.h" @@ -382,6 +383,7 @@ HWTEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingComm using LowPriorityCommandQueueTest = ::testing::Test; HWTEST_F(LowPriorityCommandQueueTest, GivenDeviceWithSubdevicesWhenCreatingLowPriorityCommandQueueThenEngineFromFirstSubdeviceIsTaken) { DebugManagerStateRestore restorer; + VariableBackup mockDeviceFlagBackup{&MockDevice::createSingleDevice, false}; DebugManager.flags.CreateMultipleSubDevices.set(2); MockContext context; cl_queue_properties properties[] = {CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_LOW_KHR, 0}; diff --git a/unit_tests/aub/aub_helper_tests.inl b/unit_tests/aub/aub_helper_tests.inl index 304581a33b..ce9f9ca1ff 100644 --- a/unit_tests/aub/aub_helper_tests.inl +++ b/unit_tests/aub/aub_helper_tests.inl @@ -33,7 +33,7 @@ TEST(AubHelper, WhenGetPtEntryBitsIsCalledThenEntryBitsAreNotMasked) { EXPECT_EQ(entryBits, maskedEntryBits); } -TEST(AubHelper, GivenMultipleDevicesWhenGettingDeviceCountThenCorrectValueIsReturned) { +TEST(AubHelper, GivenMultipleSubDevicesWhenGettingDeviceCountThenCorrectValueIsReturned) { DebugManagerStateRestore stateRestore; FeatureTable featureTable = {}; WorkaroundTable workaroundTable = {}; @@ -41,12 +41,12 @@ TEST(AubHelper, GivenMultipleDevicesWhenGettingDeviceCountThenCorrectValueIsRetu GT_SYSTEM_INFO sysInfo = {}; PLATFORM platform = {}; HardwareInfo hwInfo{&platform, &featureTable, &workaroundTable, &sysInfo, capTable}; - DebugManager.flags.CreateMultipleRootDevices.set(2); + DebugManager.flags.CreateMultipleSubDevices.set(2); uint32_t devicesCount = DeviceHelper::getDevicesCount(&hwInfo); EXPECT_EQ(devicesCount, 2u); - DebugManager.flags.CreateMultipleRootDevices.set(0); + DebugManager.flags.CreateMultipleSubDevices.set(0); devicesCount = DeviceHelper::getDevicesCount(&hwInfo); EXPECT_EQ(devicesCount, 1u); } diff --git a/unit_tests/command_queue/command_queue_tests.cpp b/unit_tests/command_queue/command_queue_tests.cpp index 904825e844..a720e436b8 100644 --- a/unit_tests/command_queue/command_queue_tests.cpp +++ b/unit_tests/command_queue/command_queue_tests.cpp @@ -24,6 +24,7 @@ #include "unit_tests/fixtures/image_fixture.h" #include "unit_tests/fixtures/memory_management_fixture.h" #include "unit_tests/helpers/unit_test_helper.h" +#include "unit_tests/helpers/variable_backup.h" #include "unit_tests/libult/ult_command_stream_receiver.h" #include "unit_tests/mocks/mock_command_queue.h" #include "unit_tests/mocks/mock_context.h" @@ -219,6 +220,7 @@ TEST(CommandQueue, givenDeviceNotSupportingBlitOperationsWhenQueueIsCreatedThenD using CommandQueueWithSubDevicesTest = ::testing::Test; HWTEST_F(CommandQueueWithSubDevicesTest, givenDeviceWithSubDevicesSupportingBlitOperationsWhenQueueIsCreatedThenBcsIsTakenFromFirstSubDevice) { DebugManagerStateRestore restorer; + VariableBackup mockDeviceFlagBackup{&MockDevice::createSingleDevice, false}; DebugManager.flags.CreateMultipleSubDevices.set(2); DebugManager.flags.EnableBlitterOperationsForReadWriteBuffers.set(1); HardwareInfo hwInfo = *platformDevices[0]; diff --git a/unit_tests/device/device_tests.cpp b/unit_tests/device/device_tests.cpp index 436094fc88..447bc2134e 100644 --- a/unit_tests/device/device_tests.cpp +++ b/unit_tests/device/device_tests.cpp @@ -173,7 +173,12 @@ TEST(DeviceCreation, givenDefaultHwCsrInDebugVarsWhenDeviceIsCreatedThenIsSimula TEST(DeviceCreation, givenDeviceWhenItIsCreatedThenOsContextIsRegistredInMemoryManager) { auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(nullptr)); auto memoryManager = device->getMemoryManager(); - EXPECT_EQ(HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size(), memoryManager->getRegisteredEnginesCount()); + auto numEnginesForDevice = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances().size(); + if (device->getNumAvailableDevices() > 1) { + numEnginesForDevice *= device->getNumAvailableDevices(); + numEnginesForDevice += device->getExecutionEnvironment()->commandStreamReceivers[0].size(); + } + EXPECT_EQ(numEnginesForDevice, memoryManager->getRegisteredEnginesCount()); } TEST(DeviceCreation, givenMultiDeviceWhenTheyAreCreatedThenEachOsContextHasUniqueId) { diff --git a/unit_tests/device/sub_device_tests.cpp b/unit_tests/device/sub_device_tests.cpp index 6b02c02d24..7ac5975027 100644 --- a/unit_tests/device/sub_device_tests.cpp +++ b/unit_tests/device/sub_device_tests.cpp @@ -25,6 +25,7 @@ TEST(SubDevicesTest, givenDefaultConfigWhenCreateRootDeviceThenItDoesntContainSu TEST(SubDevicesTest, givenCreateMultipleSubDevicesFlagSetWhenCreateRootDeviceThenItsSubdevicesHaveProperRootIdSet) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); EXPECT_EQ(2u, device->getNumSubDevices()); @@ -40,6 +41,7 @@ TEST(SubDevicesTest, givenCreateMultipleSubDevicesFlagSetWhenCreateRootDeviceThe TEST(SubDevicesTest, givenCreateMultipleSubDevicesFlagSetWhenCreateRootDeviceThenItContainsSubDevices) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); EXPECT_EQ(2u, device->getNumSubDevices()); @@ -56,6 +58,7 @@ TEST(SubDevicesTest, givenCreateMultipleSubDevicesFlagSetWhenCreateRootDeviceThe TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenSubDeviceRefcountsAreChangedThenChangeIsPropagatedToRootDevice) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); auto subDevice0 = device->subdevices.at(0).get(); @@ -93,17 +96,20 @@ TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenSubDeviceCreationFailThenWhole TEST(SubDevicesTest, givenCreateMultipleRootDevicesFlagsEnabledWhenDevicesAreCreatedThenEachHasUniqueDeviceIndex) { DebugManagerStateRestore restorer; - DebugManager.flags.CreateMultipleRootDevices.set(2); - DebugManager.flags.CreateMultipleSubDevices.set(3); + DebugManager.flags.CreateMultipleSubDevices.set(2); VariableBackup backup(&overrideDeviceWithDefaultHardwareInfo, false); platform()->initialize(); - EXPECT_EQ(0u, platform()->getDevice(0)->getDeviceIndex()); - EXPECT_EQ(4u, platform()->getDevice(1)->getDeviceIndex()); + auto device = static_cast(platform()->getDevice(0)); + EXPECT_EQ(0u, device->getDeviceIndex()); + EXPECT_EQ(2u, device->getNumSubDevices()); + EXPECT_EQ(1u, device->getDeviceById(0)->getDeviceIndex()); + EXPECT_EQ(2u, device->getDeviceById(1)->getDeviceIndex()); } TEST(SubDevicesTest, givenSubDeviceWhenOsContextIsCreatedThenItsBitfieldBasesOnSubDeviceId) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); EXPECT_EQ(2u, device->getNumSubDevices()); @@ -127,6 +133,7 @@ TEST(SubDevicesTest, givenDeviceWithoutSubDevicesWhenGettingDeviceByIdZeroThenGe TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenGettingDeviceByIdThenGetCorrectSubDevice) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); EXPECT_EQ(2u, device->getNumSubDevices()); EXPECT_EQ(device->subdevices.at(0).get(), device->getDeviceById(0)); @@ -137,6 +144,7 @@ TEST(SubDevicesTest, givenDeviceWithSubDevicesWhenGettingDeviceByIdThenGetCorrec TEST(SubDevicesTest, givenSubDevicesWhenGettingDeviceByIdZeroThenGetThisSubDevice) { DebugManagerStateRestore restorer; DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); EXPECT_EQ(2u, device->getNumSubDevices()); auto subDevice = device->subdevices.at(0).get(); @@ -144,3 +152,45 @@ TEST(SubDevicesTest, givenSubDevicesWhenGettingDeviceByIdZeroThenGetThisSubDevic EXPECT_EQ(subDevice, subDevice->getDeviceById(0)); EXPECT_THROW(subDevice->getDeviceById(1), std::exception); } + +TEST(SubDevicesTest, givenRootDeviceWithSubdevicesWhenSetupRootEngineOnceAgainThenDontOverrideEngine) { + DebugManagerStateRestore restorer; + DebugManager.flags.CreateMultipleSubDevices.set(2); + VariableBackup mockDeviceFlagBackup(&MockDevice::createSingleDevice, false); + auto device = std::unique_ptr(MockDevice::createWithNewExecutionEnvironment(*platformDevices)); + EXPECT_EQ(2u, device->getNumSubDevices()); + auto subDevice = device->subdevices.at(0).get(); + + auto subDeviceEngine = subDevice->getDefaultEngine(); + auto rootDeviceEngine = device->getDefaultEngine(); + + EXPECT_NE(subDeviceEngine.commandStreamReceiver, rootDeviceEngine.commandStreamReceiver); + EXPECT_NE(subDeviceEngine.osContext, rootDeviceEngine.osContext); + + device->setupRootEngine(subDeviceEngine); + rootDeviceEngine = device->getDefaultEngine(); + + EXPECT_NE(subDeviceEngine.commandStreamReceiver, rootDeviceEngine.commandStreamReceiver); + EXPECT_NE(subDeviceEngine.osContext, rootDeviceEngine.osContext); +} + +TEST(SubDevicesTest, givenRootDeviceWithoutEngineWhenSetupRootEngine) { + auto executionEnvironment = platform()->peekExecutionEnvironment(); + MockDevice device(executionEnvironment, 0); + EXPECT_EQ(0u, device.engines.size()); + EngineControl dummyEngine{reinterpret_cast(0x123), reinterpret_cast(0x456)}; + device.setupRootEngine(dummyEngine); + EXPECT_EQ(1u, device.engines.size()); + EXPECT_EQ(dummyEngine.commandStreamReceiver, device.engines[0].commandStreamReceiver); + EXPECT_EQ(dummyEngine.osContext, device.engines[0].osContext); + + device.engines.clear(); +} + +TEST(SubDevicesTest, givenRootDeviceWhenExecutionEnvironmentInitializesRootCommandStreamReceiverThenDeviceDoesntCreateExtraEngines) { + auto executionEnvironment = new MockExecutionEnvironment; + executionEnvironment->initRootCommandStreamReceiver = true; + executionEnvironment->initializeMemoryManager(); + std::unique_ptr device(MockDevice::createWithExecutionEnvironment(*platformDevices, executionEnvironment, 0u)); + EXPECT_EQ(0u, device->engines.size()); +} diff --git a/unit_tests/execution_environment/execution_environment_tests.cpp b/unit_tests/execution_environment/execution_environment_tests.cpp index 1de2ba85c6..71b3fa4ea9 100644 --- a/unit_tests/execution_environment/execution_environment_tests.cpp +++ b/unit_tests/execution_environment/execution_environment_tests.cpp @@ -55,12 +55,19 @@ TEST(ExecutionEnvironment, givenPlatformWhenItIsInitializedAndCreatesDevicesThen std::unique_ptr platform(new Platform); auto executionEnvironment = platform->peekExecutionEnvironment(); + auto expectedRefCounts = executionEnvironment->getRefInternalCount(); platform->initialize(); - EXPECT_LT(0u, platform->getNumDevices()); - EXPECT_EQ(static_cast(1u + platform->getNumDevices()), executionEnvironment->getRefInternalCount()); + EXPECT_LT(0u, platform->getDevice(0)->getNumAvailableDevices()); + if (platform->getDevice(0)->getNumAvailableDevices() > 1) { + expectedRefCounts++; + } + expectedRefCounts += platform->getDevice(0)->getNumAvailableDevices(); + EXPECT_EQ(expectedRefCounts, executionEnvironment->getRefInternalCount()); } TEST(ExecutionEnvironment, givenDeviceThatHaveRefferencesAfterPlatformIsDestroyedThenDeviceIsStillUsable) { + DebugManagerStateRestore restorer; + DebugManager.flags.CreateMultipleSubDevices.set(1); std::unique_ptr platform(new Platform); auto executionEnvironment = platform->peekExecutionEnvironment(); platform->initialize(); @@ -81,20 +88,6 @@ TEST(ExecutionEnvironment, givenPlatformWhenItIsCreatedThenItCreatesCommandStrea EXPECT_NE(nullptr, executionEnvironment->commandStreamReceivers[0][0].get()); } -TEST(ExecutionEnvironment, whenPlatformIsInitializedThenOnlySpecialCommandStreamReceiverIsMultiOsContextCapable) { - Platform platform; - auto executionEnvironment = platform.peekExecutionEnvironment(); - platform.initialize(); - for (auto &csrContainer : executionEnvironment->commandStreamReceivers) { - for (auto &csr : csrContainer) { - EXPECT_FALSE(csr->isMultiOsContextCapable()); - } - } - if (executionEnvironment->specialCommandStreamReceiver) { - EXPECT_TRUE(executionEnvironment->specialCommandStreamReceiver->isMultiOsContextCapable()); - } -} - TEST(ExecutionEnvironment, givenPlatformWhenItIsCreatedThenItCreatesMemoryManagerInExecutionEnvironment) { Platform platform; auto executionEnvironment = platform.peekExecutionEnvironment(); @@ -194,7 +187,6 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerI EXPECT_NE(nullptr, executionEnvironment->memoryManager); } static_assert(sizeof(ExecutionEnvironment) == sizeof(std::vector>) + - sizeof(std::unique_ptr) + sizeof(std::mutex) + sizeof(std::unique_ptr) + (is64bit ? 88 : 48), @@ -206,27 +198,24 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDe struct MockExecutionEnvironment : ExecutionEnvironment { using ExecutionEnvironment::gmmHelper; }; - struct GmmHelperMock : public DestructorCounted { + struct GmmHelperMock : public DestructorCounted { GmmHelperMock(uint32_t &destructorId, const HardwareInfo *hwInfo) : DestructorCounted(destructorId, hwInfo) {} }; - struct OsInterfaceMock : public DestructorCounted { + struct OsInterfaceMock : public DestructorCounted { OsInterfaceMock(uint32_t &destructorId) : DestructorCounted(destructorId) {} }; - struct MemoryOperationsHandlerMock : public DestructorCounted { + struct MemoryOperationsHandlerMock : public DestructorCounted { MemoryOperationsHandlerMock(uint32_t &destructorId) : DestructorCounted(destructorId) {} }; - struct MemoryMangerMock : public DestructorCounted { + struct MemoryMangerMock : public DestructorCounted { MemoryMangerMock(uint32_t &destructorId, ExecutionEnvironment &executionEnvironment) : DestructorCounted(destructorId, executionEnvironment) {} }; - struct AubCenterMock : public DestructorCounted { + struct AubCenterMock : public DestructorCounted { AubCenterMock(uint32_t &destructorId) : DestructorCounted(destructorId, platformDevices[0], false, "", CommandStreamReceiverType::CSR_AUB) {} }; - struct CommandStreamReceiverMock : public DestructorCounted { + struct CommandStreamReceiverMock : public DestructorCounted { CommandStreamReceiverMock(uint32_t &destructorId, ExecutionEnvironment &executionEnvironment) : DestructorCounted(destructorId, executionEnvironment) {} }; - struct SpecialCommandStreamReceiverMock : public DestructorCounted { - SpecialCommandStreamReceiverMock(uint32_t &destructorId, ExecutionEnvironment &executionEnvironment) : DestructorCounted(destructorId, executionEnvironment) {} - }; struct BuiltinsMock : public DestructorCounted { BuiltinsMock(uint32_t &destructorId) : DestructorCounted(destructorId) {} }; @@ -246,13 +235,12 @@ TEST(ExecutionEnvironment, givenExecutionEnvironmentWithVariousMembersWhenItIsDe executionEnvironment->memoryManager = std::make_unique(destructorId, *executionEnvironment); executionEnvironment->aubCenter = std::make_unique(destructorId); executionEnvironment->commandStreamReceivers[0].push_back(std::make_unique(destructorId, *executionEnvironment)); - executionEnvironment->specialCommandStreamReceiver = std::make_unique(destructorId, *executionEnvironment); executionEnvironment->builtins = std::make_unique(destructorId); executionEnvironment->compilerInterface = std::make_unique(destructorId); executionEnvironment->sourceLevelDebugger = std::make_unique(destructorId); executionEnvironment.reset(nullptr); - EXPECT_EQ(10u, destructorId); + EXPECT_EQ(9u, destructorId); } TEST(ExecutionEnvironment, givenMultipleDevicesWhenTheyAreCreatedTheyAllReuseTheSameMemoryManagerAndCommandStreamReceiver) { @@ -294,33 +282,6 @@ HWTEST_F(ExecutionEnvironmentHw, givenHwHelperInputWhenInitializingCsrThenCreate EXPECT_EQ(UnitTestHelper::isPageTableManagerSupported(*hwInfo), csr2->createPageTableManagerCalled); } -TEST(ExecutionEnvironment, whenSpecialCsrNotExistThenReturnNullSpecialEngineControl) { - ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); - executionEnvironment->initializeCommandStreamReceiver(0, 0); - executionEnvironment->initializeMemoryManager(); - EXPECT_NE(nullptr, executionEnvironment->memoryManager); - auto engineControl = executionEnvironment->getEngineControlForSpecialCsr(); - EXPECT_EQ(nullptr, engineControl); -} - -TEST(ExecutionEnvironment, whenSpecialCsrExistsThenReturnSpecialEngineControl) { - ExecutionEnvironment *executionEnvironment = platformImpl->peekExecutionEnvironment(); - executionEnvironment->initializeCommandStreamReceiver(0, 0); - executionEnvironment->initializeMemoryManager(); - EXPECT_NE(nullptr, executionEnvironment->memoryManager); - - executionEnvironment->specialCommandStreamReceiver.reset(createCommandStream(*executionEnvironment)); - auto engineType = HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0]; - auto osContext = executionEnvironment->memoryManager->createAndRegisterOsContext(executionEnvironment->specialCommandStreamReceiver.get(), - engineType, 1, - PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false); - executionEnvironment->specialCommandStreamReceiver->setupContext(*osContext); - - auto engineControl = executionEnvironment->getEngineControlForSpecialCsr(); - ASSERT_NE(nullptr, engineControl); - EXPECT_EQ(executionEnvironment->specialCommandStreamReceiver.get(), engineControl->commandStreamReceiver); -} - TEST(ExecutionEnvironment, givenUnproperSetCsrFlagValueWhenInitializingMemoryManagerThenCreateDefaultMemoryManager) { DebugManagerStateRestore restorer; DebugManager.flags.SetCommandStreamReceiver.set(10); diff --git a/unit_tests/mocks/mock_device.cpp b/unit_tests/mocks/mock_device.cpp index e5506a25da..a15aa02c92 100644 --- a/unit_tests/mocks/mock_device.cpp +++ b/unit_tests/mocks/mock_device.cpp @@ -16,6 +16,8 @@ using namespace NEO; +bool MockDevice::createSingleDevice = true; + MockDevice::MockDevice() : MockDevice(new MockExecutionEnvironment(), 0u) { CommandStreamReceiver *commandStreamReceiver = createCommandStream(*this->executionEnvironment); @@ -40,6 +42,13 @@ MockDevice::MockDevice(ExecutionEnvironment *executionEnvironment, uint32_t devi initializeCaps(); } +bool MockDevice::createDeviceImpl() { + if (MockDevice::createSingleDevice) { + return Device::createDeviceImpl(); + } + return RootDevice::createDeviceImpl(); +} + void MockDevice::setOSTime(OSTime *osTime) { this->osTime.reset(osTime); }; diff --git a/unit_tests/mocks/mock_device.h b/unit_tests/mocks/mock_device.h index 823c53e1ca..1012d0c536 100644 --- a/unit_tests/mocks/mock_device.h +++ b/unit_tests/mocks/mock_device.h @@ -33,6 +33,9 @@ class MockDevice : public RootDevice { void setDriverInfo(DriverInfo *driverInfo); bool hasDriverInfo(); + static bool createSingleDevice; + bool createDeviceImpl() override; + bool getCpuTime(uint64_t *timeStamp) { return true; }; MockDevice(); MockDevice(ExecutionEnvironment *executionEnvironment, uint32_t deviceIndex); diff --git a/unit_tests/mocks/mock_execution_environment.h b/unit_tests/mocks/mock_execution_environment.h index c87c460a90..f6d06ff9f4 100644 --- a/unit_tests/mocks/mock_execution_environment.h +++ b/unit_tests/mocks/mock_execution_environment.h @@ -32,10 +32,14 @@ struct MockExecutionEnvironment : ExecutionEnvironment { } ExecutionEnvironment::initAubCenter(localMemoryEnabled, aubFileName, csrType); } + bool initializeRootCommandStreamReceiver(RootDevice &device) override { + return initRootCommandStreamReceiver; + } bool initAubCenterCalled = false; bool localMemoryEnabledReceived = false; std::string aubFileNameReceived = ""; bool useMockAubCenter = true; + bool initRootCommandStreamReceiver = false; }; template @@ -44,11 +48,12 @@ struct MockExecutionEnvironmentWithCsr : public ExecutionEnvironment { MockExecutionEnvironmentWithCsr(const HardwareInfo &hwInfo, uint32_t devicesCount) { setHwInfo(&hwInfo); auto &gpgpuEngines = HwHelper::get(hwInfo.platform.eRenderCoreFamily).getGpgpuEngineInstances(); - commandStreamReceivers.resize(devicesCount); + auto offset = devicesCount > 1 ? 1u : 0u; + commandStreamReceivers.resize(devicesCount + offset); - for (uint32_t csrIndex = 0; csrIndex < gpgpuEngines.size(); csrIndex++) { - for (auto &csr : commandStreamReceivers) { - csr.push_back(std::unique_ptr(new CsrType(*this))); + for (uint32_t deviceIndex = 0; deviceIndex < devicesCount; deviceIndex++) { + for (uint32_t csrIndex = 0; csrIndex < gpgpuEngines.size(); csrIndex++) { + commandStreamReceivers[deviceIndex + offset].push_back(std::unique_ptr(new CsrType(*this))); } } }