diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 33695e1cdd..4e3c8291c7 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -447,6 +447,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, EnableDirectSubmissionController, -1, "Enable di DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionControllerTimeout, -1, "Set direct submission controller timeout, -1: default 5000 us, >=0: timeout in us") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionControllerBcsTimeoutDivisor, -1, "If >=1, divide controller timeout to stop BCS only engines faster than others") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionControllerMaxTimeout, -1, "Set direct submission controller max timeout - timeout will increase up to given value, -1: default 5000 us, >=0: max timeout in us") +DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionControllerDivisor, -1, "Set direct submission controller timeout divider, -1: default 1, >0: divider value") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus, -1, "Adjust controller timeout settings based on queue throttle and ac line status, -1: default, 0: disabled, 1: enabled") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionForceLocalMemoryStorageMode, -1, "Force local memory storage for command/ring/semaphore buffer, -1: default - for all engines, 0: disabled, 1: for multiOsContextCapable engine, 2: for all engines") DECLARE_DEBUG_VARIABLE(int32_t, EnableRingSwitchTagUpdateWa, -1, "-1: default, 0 - disable, 1 - enable. If enabled, completionFences wont be updated if ring is not running.") diff --git a/shared/source/direct_submission/direct_submission_controller.cpp b/shared/source/direct_submission/direct_submission_controller.cpp index 8148a71880..2790870299 100644 --- a/shared/source/direct_submission/direct_submission_controller.cpp +++ b/shared/source/direct_submission/direct_submission_controller.cpp @@ -10,7 +10,6 @@ #include "shared/source/command_stream/command_stream_receiver.h" #include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/execution_environment/root_device_environment.h" -#include "shared/source/helpers/gfx_core_helper.h" #include "shared/source/helpers/sleep.h" #include "shared/source/os_interface/os_context.h" #include "shared/source/os_interface/os_thread.h" @@ -26,6 +25,9 @@ DirectSubmissionController::DirectSubmissionController() { if (debugManager.flags.DirectSubmissionControllerTimeout.get() != -1) { timeout = std::chrono::microseconds{debugManager.flags.DirectSubmissionControllerTimeout.get()}; } + if (debugManager.flags.DirectSubmissionControllerDivisor.get() != -1) { + timeoutDivisor = debugManager.flags.DirectSubmissionControllerDivisor.get(); + } if (debugManager.flags.DirectSubmissionControllerBcsTimeoutDivisor.get() != -1) { bcsTimeoutDivisor = debugManager.flags.DirectSubmissionControllerBcsTimeoutDivisor.get(); } @@ -46,7 +48,7 @@ DirectSubmissionController::~DirectSubmissionController() { void DirectSubmissionController::registerDirectSubmission(CommandStreamReceiver *csr) { std::lock_guard lock(directSubmissionsMutex); directSubmissions.insert(std::make_pair(csr, DirectSubmissionState())); - csr->getGfxCoreHelper().overrideDirectSubmissionTimeouts(this->timeout, this->maxTimeout); + this->adjustTimeout(csr); } void DirectSubmissionController::setTimeoutParamsForPlatform(const ProductHelper &helper) { @@ -215,6 +217,21 @@ SteadyClock::time_point DirectSubmissionController::getCpuTimestamp() { return SteadyClock::now(); } +void DirectSubmissionController::adjustTimeout(CommandStreamReceiver *csr) { + if (EngineHelpers::isCcs(csr->getOsContext().getEngineType())) { + for (size_t subDeviceIndex = 0u; subDeviceIndex < csr->getOsContext().getDeviceBitfield().size(); ++subDeviceIndex) { + if (csr->getOsContext().getDeviceBitfield().test(subDeviceIndex)) { + ++this->ccsCount[subDeviceIndex]; + } + } + auto curentMaxCcsCount = std::max_element(this->ccsCount.begin(), this->ccsCount.end()); + if (*curentMaxCcsCount > this->maxCcsCount) { + this->maxCcsCount = *curentMaxCcsCount; + this->timeout /= this->timeoutDivisor; + } + } +} + void DirectSubmissionController::recalculateTimeout() { const auto now = this->getCpuTimestamp(); const auto timeSinceLastTerminate = std::chrono::duration_cast(now - this->lastTerminateCpuTimestamp); diff --git a/shared/source/direct_submission/direct_submission_controller.h b/shared/source/direct_submission/direct_submission_controller.h index e6fe418727..4f2ec86810 100644 --- a/shared/source/direct_submission/direct_submission_controller.h +++ b/shared/source/direct_submission/direct_submission_controller.h @@ -98,6 +98,7 @@ class DirectSubmissionController { MOCKABLE_VIRTUAL bool sleep(std::unique_lock &lock); MOCKABLE_VIRTUAL SteadyClock::time_point getCpuTimestamp(); + void adjustTimeout(CommandStreamReceiver *csr); void recalculateTimeout(); void applyTimeoutForAcLineStatusAndThrottle(bool acLineConnected); void updateLastSubmittedThrottle(QueueThrottle throttle); diff --git a/shared/source/helpers/gfx_core_helper.h b/shared/source/helpers/gfx_core_helper.h index 2f6e94a91b..a86d207013 100644 --- a/shared/source/helpers/gfx_core_helper.h +++ b/shared/source/helpers/gfx_core_helper.h @@ -16,7 +16,6 @@ #include "aubstream/aubstream.h" #include "igfxfmid.h" -#include #include #include #include @@ -200,8 +199,6 @@ class GfxCoreHelper { virtual uint32_t getDeviceTimestampWidth() const = 0; virtual void alignThreadGroupCountToDssSize(uint32_t &threadCount, uint32_t dssCount, uint32_t threadsPerDss, uint32_t threadGroupSize) const = 0; - virtual void overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const = 0; - virtual ~GfxCoreHelper() = default; protected: @@ -440,8 +437,6 @@ class GfxCoreHelperHw : public GfxCoreHelper { uint32_t getDeviceTimestampWidth() const override; - void overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const override; - ~GfxCoreHelperHw() override = default; protected: diff --git a/shared/source/helpers/gfx_core_helper_base.inl b/shared/source/helpers/gfx_core_helper_base.inl index fed0a02ee2..9f8d5c67f8 100644 --- a/shared/source/helpers/gfx_core_helper_base.inl +++ b/shared/source/helpers/gfx_core_helper_base.inl @@ -833,8 +833,4 @@ uint32_t GfxCoreHelperHw::getInternalCopyEngineIndex(const HardwareInfo return std::min(defaultInternalCopyEngineIndex, highestAvailableIndex); } -template -void GfxCoreHelperHw::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const { -} - } // namespace NEO diff --git a/shared/source/helpers/gfx_core_helper_xe2_and_later.inl b/shared/source/helpers/gfx_core_helper_xe2_and_later.inl index 0dc7d3dbe6..db745d67fd 100644 --- a/shared/source/helpers/gfx_core_helper_xe2_and_later.inl +++ b/shared/source/helpers/gfx_core_helper_xe2_and_later.inl @@ -82,16 +82,4 @@ void MemorySynchronizationCommands::encodeAdditionalTimestampOffsets(Lin EncodeStoreMMIO::encode(commandStream, RegisterOffsets::globalTimestampUn, globalAddress + sizeof(uint32_t), false, nullptr, isBcs); } -template <> -void GfxCoreHelperHw::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const { - timeout = std::chrono::microseconds{1'000}; - maxTimeout = std::chrono::microseconds{1'000}; - if (debugManager.flags.DirectSubmissionControllerTimeout.get() != -1) { - timeout = std::chrono::microseconds{debugManager.flags.DirectSubmissionControllerTimeout.get()}; - } - if (debugManager.flags.DirectSubmissionControllerMaxTimeout.get() != -1) { - maxTimeout = std::chrono::microseconds{debugManager.flags.DirectSubmissionControllerMaxTimeout.get()}; - } -} - } // namespace NEO diff --git a/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl b/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl index 90f1f6d94f..9d74ea1af8 100644 --- a/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl +++ b/shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl @@ -45,6 +45,11 @@ bool ProductHelperHw::isCachingOnCpuAvailable() const { return false; } +template <> +bool ProductHelperHw::isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled() const { + return true; +} + template <> TimeoutParams ProductHelperHw::getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const { TimeoutParams params{}; diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index b5225fe7dd..17cb80c479 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -125,6 +125,7 @@ DirectSubmissionMaxRingBuffers = -1 USMEvictAfterMigration = 0 EnableDirectSubmissionController = -1 DirectSubmissionControllerTimeout = -1 +DirectSubmissionControllerDivisor = -1 DirectSubmissionMonitorFenceInputPolicy = -1 UseVmBind = -1 EnableNullHardware = 0 diff --git a/shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp b/shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp index 9d86724bb8..cc8f101c12 100644 --- a/shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp +++ b/shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp @@ -5,7 +5,6 @@ * */ -#include "shared/source/helpers/gfx_core_helper.h" #include "shared/source/os_interface/os_context.h" #include "shared/source/os_interface/os_thread.h" #include "shared/source/os_interface/os_time.h" @@ -28,6 +27,15 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerTimeoutWhen EXPECT_EQ(controller.timeout.count(), 14); } +TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllertimeoutDivisorWhenCreateObjectThentimeoutDivisorIsEqualWithDebugFlag) { + DebugManagerStateRestore restorer; + debugManager.flags.DirectSubmissionControllerDivisor.set(4); + + DirectSubmissionControllerMock controller; + + EXPECT_EQ(controller.timeoutDivisor, 4); +} + TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterDirectSubmissionWorksThenItIsMonitoringItsState) { MockExecutionEnvironment executionEnvironment; executionEnvironment.prepareRootDeviceEnvironments(1); @@ -158,10 +166,10 @@ TEST(DirectSubmissionControllerTests, givenDebugFlagSetWhenCheckingNewSubmission controller.unregisterDirectSubmission(&ccsCsr); } -TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenIncreaseTimeoutEnabledThenTimeoutIsIncreased) { +TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndDivisorDisabledWhenIncreaseTimeoutEnabledThenTimeoutIsIncreased) { DebugManagerStateRestore restorer; - debugManager.flags.DirectSubmissionControllerTimeout.set(5'000); debugManager.flags.DirectSubmissionControllerMaxTimeout.set(200'000); + debugManager.flags.DirectSubmissionControllerDivisor.set(1); debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.set(0); MockExecutionEnvironment executionEnvironment; executionEnvironment.prepareRootDeviceEnvironments(1); @@ -282,6 +290,7 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndAdjustOn TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndAdjustOnThrottleAndAcLineStatusEnabledWhenThrottleOrAcLineStatusChangesThenTimeoutIsChanged) { DebugManagerStateRestore restorer; + debugManager.flags.DirectSubmissionControllerDivisor.set(1); debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.set(1); MockExecutionEnvironment executionEnvironment; executionEnvironment.prepareRootDeviceEnvironments(1); @@ -394,7 +403,7 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndAdjustOn controller.unregisterDirectSubmission(&csr); } -TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterCsrsThenTimeoutIsAdjusted) { +TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterCsrsThenTimeoutIsNotAdjusted) { MockExecutionEnvironment executionEnvironment; executionEnvironment.prepareRootDeviceEnvironments(1); executionEnvironment.initializeMemoryManager(); @@ -406,12 +415,54 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegiste PreemptionMode::ThreadGroup, deviceBitfield))); csr.setupContext(*osContext.get()); + MockCommandStreamReceiver csr1(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext1(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr1.setupContext(*osContext1.get()); + + MockCommandStreamReceiver csr2(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext2(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr2.setupContext(*osContext2.get()); + + MockCommandStreamReceiver csr3(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext3(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr3.setupContext(*osContext3.get()); + + MockCommandStreamReceiver csr4(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext4(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr4.setupContext(*osContext4.get()); + DirectSubmissionControllerMock controller; - auto timeout = std::chrono::microseconds{5'000}; - EXPECT_EQ(controller.timeout, timeout); + + EXPECT_EQ(controller.timeout.count(), 5'000); + controller.registerDirectSubmission(&csr); - csr.getGfxCoreHelper().overrideDirectSubmissionTimeouts(timeout, timeout); - EXPECT_EQ(controller.timeout, timeout); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr3); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr1); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr2); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr4); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.unregisterDirectSubmission(&csr); + controller.unregisterDirectSubmission(&csr1); + controller.unregisterDirectSubmission(&csr2); + controller.unregisterDirectSubmission(&csr3); + controller.unregisterDirectSubmission(&csr4); } TEST(DirectSubmissionControllerTests, givenPowerSavingUintWhenCallingGetThrottleFromPowerSavingUintThenCorrectValueIsReturned) { @@ -420,6 +471,187 @@ TEST(DirectSubmissionControllerTests, givenPowerSavingUintWhenCallingGetThrottle EXPECT_EQ(QueueThrottle::LOW, getThrottleFromPowerSavingUint(100u)); } +TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterCsrsFromDifferentSubdevicesThenTimeoutIsAdjusted) { + DebugManagerStateRestore restorer; + debugManager.flags.DirectSubmissionControllerDivisor.set(4); + MockExecutionEnvironment executionEnvironment; + executionEnvironment.prepareRootDeviceEnvironments(1); + executionEnvironment.initializeMemoryManager(); + DeviceBitfield deviceBitfield(1); + DeviceBitfield deviceBitfield1(0b10); + + MockCommandStreamReceiver csr(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr.setupContext(*osContext.get()); + + MockCommandStreamReceiver csr1(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext1(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr1.setupContext(*osContext1.get()); + + MockCommandStreamReceiver csr2(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext2(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr2.setupContext(*osContext2.get()); + + MockCommandStreamReceiver csr3(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext3(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr3.setupContext(*osContext3.get()); + + MockCommandStreamReceiver csr4(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext4(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr4.setupContext(*osContext4.get()); + + MockCommandStreamReceiver csr5(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext5(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr5.setupContext(*osContext5.get()); + + MockCommandStreamReceiver csr6(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext6(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr6.setupContext(*osContext6.get()); + + MockCommandStreamReceiver csr7(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext7(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr7.setupContext(*osContext7.get()); + + MockCommandStreamReceiver csr8(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext8(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr8.setupContext(*osContext8.get()); + + MockCommandStreamReceiver csr9(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext9(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr9.setupContext(*osContext9.get()); + + MockCommandStreamReceiver csr10(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext10(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield1))); + csr10.setupContext(*osContext10.get()); + + DirectSubmissionControllerMock controller; + + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr5); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr1); + EXPECT_EQ(controller.timeout.count(), 1'250); + + controller.registerDirectSubmission(&csr2); + EXPECT_EQ(controller.timeout.count(), 312); + + controller.registerDirectSubmission(&csr4); + EXPECT_EQ(controller.timeout.count(), 312); + + controller.registerDirectSubmission(&csr6); + EXPECT_EQ(controller.timeout.count(), 312); + + controller.registerDirectSubmission(&csr7); + EXPECT_EQ(controller.timeout.count(), 312); + + controller.registerDirectSubmission(&csr9); + EXPECT_EQ(controller.timeout.count(), 312); + + controller.registerDirectSubmission(&csr8); + EXPECT_EQ(controller.timeout.count(), 78); + + controller.registerDirectSubmission(&csr10); + EXPECT_EQ(controller.timeout.count(), 78); + + controller.unregisterDirectSubmission(&csr); + controller.unregisterDirectSubmission(&csr1); + controller.unregisterDirectSubmission(&csr2); + controller.unregisterDirectSubmission(&csr3); + controller.unregisterDirectSubmission(&csr4); +} + +TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerDirectSubmissionControllerDivisorSetWhenRegisterCsrsThenTimeoutIsAdjusted) { + DebugManagerStateRestore restorer; + debugManager.flags.DirectSubmissionControllerDivisor.set(5); + + MockExecutionEnvironment executionEnvironment; + executionEnvironment.prepareRootDeviceEnvironments(1); + executionEnvironment.initializeMemoryManager(); + DeviceBitfield deviceBitfield(1); + + MockCommandStreamReceiver csr(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr.setupContext(*osContext.get()); + + MockCommandStreamReceiver csr1(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext1(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr1.setupContext(*osContext1.get()); + + MockCommandStreamReceiver csr2(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext2(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr2.setupContext(*osContext2.get()); + + MockCommandStreamReceiver csr3(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext3(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr3.setupContext(*osContext3.get()); + + MockCommandStreamReceiver csr4(executionEnvironment, 0, deviceBitfield); + std::unique_ptr osContext4(OsContext::create(nullptr, 0, 0, + EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular}, + PreemptionMode::ThreadGroup, deviceBitfield))); + csr4.setupContext(*osContext4.get()); + + DirectSubmissionControllerMock controller; + + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr3); + EXPECT_EQ(controller.timeout.count(), 5'000); + + controller.registerDirectSubmission(&csr1); + EXPECT_EQ(controller.timeout.count(), 1'000); + + controller.registerDirectSubmission(&csr2); + EXPECT_EQ(controller.timeout.count(), 200); + + controller.registerDirectSubmission(&csr4); + EXPECT_EQ(controller.timeout.count(), 200); + + controller.unregisterDirectSubmission(&csr); + controller.unregisterDirectSubmission(&csr1); + controller.unregisterDirectSubmission(&csr2); + controller.unregisterDirectSubmission(&csr3); + controller.unregisterDirectSubmission(&csr4); +} + TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenEnqueueWaitForPagingFenceThenWaitInQueue) { MockExecutionEnvironment executionEnvironment; executionEnvironment.prepareRootDeviceEnvironments(1); diff --git a/shared/test/unit_test/helpers/gfx_core_helper_xe2_and_later.cpp b/shared/test/unit_test/helpers/gfx_core_helper_xe2_and_later.cpp index 5bdda05a22..93bfe55cb8 100644 --- a/shared/test/unit_test/helpers/gfx_core_helper_xe2_and_later.cpp +++ b/shared/test/unit_test/helpers/gfx_core_helper_xe2_and_later.cpp @@ -106,21 +106,3 @@ HWTEST2_F(GfxCoreHelperXe2AndLaterTests, givenAtLeastXe2HpgWhenEncodeAdditionalT EXPECT_EQ(storeRegMem->getRegisterAddress(), RegisterOffsets::globalTimestampUn); EXPECT_EQ(storeRegMem->getMemoryAddress(), sndAddress + sizeof(uint32_t)); } - -HWTEST2_F(GfxCoreHelperXe2AndLaterTests, givenOverrideDirectSubmissionTimeoutsCalledThenTimeoutsAreOverridden, IsAtLeastXe2HpgCore) { - MockExecutionEnvironment mockExecutionEnvironment{}; - auto &gfxCoreHelper = mockExecutionEnvironment.rootDeviceEnvironments[0]->getHelper(); - auto timeout = std::chrono::microseconds{5'000}; - auto maxTimeout = timeout; - gfxCoreHelper.overrideDirectSubmissionTimeouts(timeout, maxTimeout); - EXPECT_EQ(timeout.count(), 1'000); - EXPECT_EQ(maxTimeout.count(), 1'000); - - DebugManagerStateRestore restorer{}; - debugManager.flags.DirectSubmissionControllerTimeout.set(2'000); - debugManager.flags.DirectSubmissionControllerMaxTimeout.set(3'000); - - gfxCoreHelper.overrideDirectSubmissionTimeouts(timeout, maxTimeout); - EXPECT_EQ(timeout.count(), 2'000); - EXPECT_EQ(maxTimeout.count(), 3'000); -} \ No newline at end of file