intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 09:09:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "performance: set 1ms timeout for ulls controller since xe2"

Browse Source 
This reverts commit 28c008e438.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2025-02-23 12:46:46 +01:00
committed by Compute-Runtime-Automation
parent 74c2a92edc
commit f907c7dcb2
10 changed files with 267 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
shared/source/debug_settings/debug_variables_base.inl
View File

@@ -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.")

21
shared/source/direct_submission/direct_submission_controller.cpp
View File

@@ -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<std::mutex> 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<std::chrono::microseconds>(now - this->lastTerminateCpuTimestamp);

1
shared/source/direct_submission/direct_submission_controller.h
View File

@@ -98,6 +98,7 @@ class DirectSubmissionController {
MOCKABLE_VIRTUAL bool sleep(std::unique_lock<std::mutex> &lock);
MOCKABLE_VIRTUAL SteadyClock::time_point getCpuTimestamp();
void adjustTimeout(CommandStreamReceiver *csr);
void recalculateTimeout();
void applyTimeoutForAcLineStatusAndThrottle(bool acLineConnected);
void updateLastSubmittedThrottle(QueueThrottle throttle);

5
shared/source/helpers/gfx_core_helper.h
View File

@@ -16,7 +16,6 @@
#include "aubstream/aubstream.h"
#include "igfxfmid.h"
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
@@ -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:

4
shared/source/helpers/gfx_core_helper_base.inl
View File

@@ -833,8 +833,4 @@ uint32_t GfxCoreHelperHw<Family>::getInternalCopyEngineIndex(const HardwareInfo
return std::min(defaultInternalCopyEngineIndex, highestAvailableIndex);
}
template <typename Family>
void GfxCoreHelperHw<Family>::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const {
}
} // namespace NEO

12
shared/source/helpers/gfx_core_helper_xe2_and_later.inl
View File

@@ -82,16 +82,4 @@ void MemorySynchronizationCommands<Family>::encodeAdditionalTimestampOffsets(Lin
EncodeStoreMMIO<Family>::encode(commandStream, RegisterOffsets::globalTimestampUn, globalAddress + sizeof(uint32_t), false, nullptr, isBcs);
}
template <>
void GfxCoreHelperHw<Family>::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

5
shared/source/xe2_hpg_core/lnl/os_agnostic_product_helper_lnl.inl
View File

@@ -45,6 +45,11 @@ bool ProductHelperHw<gfxProduct>::isCachingOnCpuAvailable() const {
return false;
}
template <>
bool ProductHelperHw<gfxProduct>::isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled() const {
return true;
}
template <>
TimeoutParams ProductHelperHw<gfxProduct>::getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const {
TimeoutParams params{};

1
shared/test/common/test_files/igdrcl.config
View File

@@ -125,6 +125,7 @@ DirectSubmissionMaxRingBuffers = -1
USMEvictAfterMigration = 0
EnableDirectSubmissionController = -1
DirectSubmissionControllerTimeout = -1
DirectSubmissionControllerDivisor = -1
DirectSubmissionMonitorFenceInputPolicy = -1
UseVmBind = -1
EnableNullHardware = 0

248
shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp
View File

@@ -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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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(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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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(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<OsContext> 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<OsContext> 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<OsContext> 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<OsContext> 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);

18
shared/test/unit_test/helpers/gfx_core_helper_xe2_and_later.cpp
View File

@@ -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<GfxCoreHelper>();
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);
}