intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: remove unused logic in ULLS controller

Browse Source 
Related-To: NEO-13843

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2025-04-15 11:54:38 +00:00
committed by Compute-Runtime-Automation
parent 49489a9bd8
commit 3596522637
11 changed files with 1 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
shared/source/command_stream/command_stream_receiver.cpp
View File

@@ -646,7 +646,6 @@ void CommandStreamReceiver::downloadAllocation(GraphicsAllocation &gfxAllocation
void CommandStreamReceiver::startControllingDirectSubmissions() {
auto controller = this->executionEnvironment.directSubmissionController.get();
if (controller) {
controller->setTimeoutParamsForPlatform(this->getProductHelper());
controller->startControlling();
}
}

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

@@ -455,7 +455,6 @@ 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, 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.")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionPCIBarrier, -1, "Use PCI barrier for data synchronization before semaphore unblock -1: default, 0 - disable, 1 - enable.")

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

@@ -48,41 +48,6 @@ void DirectSubmissionController::registerDirectSubmission(CommandStreamReceiver
csr->getProductHelper().overrideDirectSubmissionTimeouts(this->timeout, this->maxTimeout);
}
void DirectSubmissionController::setTimeoutParamsForPlatform(const ProductHelper &helper) {
adjustTimeoutOnThrottleAndAcLineStatus = helper.isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled();
if (debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.get() != -1) {
adjustTimeoutOnThrottleAndAcLineStatus = debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.get();
}
if (adjustTimeoutOnThrottleAndAcLineStatus) {
for (auto throttle : {QueueThrottle::LOW, QueueThrottle::MEDIUM, QueueThrottle::HIGH}) {
for (auto acLineStatus : {false, true}) {
auto key = this->getTimeoutParamsMapKey(throttle, acLineStatus);
auto timeoutParam = std::make_pair(key, helper.getDirectSubmissionControllerTimeoutParams(acLineStatus, throttle));
this->timeoutParamsMap.insert(timeoutParam);
}
}
}
}
void DirectSubmissionController::applyTimeoutForAcLineStatusAndThrottle(bool acLineConnected) {
const auto &timeoutParams = this->timeoutParamsMap[this->getTimeoutParamsMapKey(this->lowestThrottleSubmitted, acLineConnected)];
this->timeout = timeoutParams.timeout;
this->maxTimeout = timeoutParams.maxTimeout;
this->timeoutDivisor = timeoutParams.timeoutDivisor;
}
void DirectSubmissionController::updateLastSubmittedThrottle(QueueThrottle throttle) {
if (throttle < this->lowestThrottleSubmitted) {
this->lowestThrottleSubmitted = throttle;
}
}
size_t DirectSubmissionController::getTimeoutParamsMapKey(QueueThrottle throttle, bool acLineStatus) {
return (static_cast<size_t>(throttle) << 1) + acLineStatus;
}
void DirectSubmissionController::unregisterDirectSubmission(CommandStreamReceiver *csr) {
std::lock_guard<std::mutex> lock(directSubmissionsMutex);
directSubmissions.erase(csr);
@@ -165,16 +130,11 @@ void DirectSubmissionController::checkNewSubmissions() {
csr->stopDirectSubmission(false, false);
state.isStopped = true;
shouldRecalculateTimeout = true;
this->lowestThrottleSubmitted = QueueThrottle::HIGH;
}
state.taskCount = csr->peekTaskCount();
} else {
state.isStopped = false;
state.taskCount = taskCount;
if (this->adjustTimeoutOnThrottleAndAcLineStatus) {
this->updateLastSubmittedThrottle(csr->getLastDirectSubmissionThrottle());
this->applyTimeoutForAcLineStatusAndThrottle(csr->getAcLineConnected(true));
}
}
}
if (shouldRecalculateTimeout) {

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

@@ -29,13 +29,6 @@ class ProductHelper;
using SteadyClock = std::chrono::steady_clock;
using HighResolutionClock = std::chrono::high_resolution_clock;
struct TimeoutParams {
std::chrono::microseconds maxTimeout;
std::chrono::microseconds timeout;
int32_t timeoutDivisor;
bool directSubmissionEnabled;
};
struct WaitForPagingFenceRequest {
CommandStreamReceiver *csr;
uint64_t pagingFenceValue;
@@ -54,7 +47,6 @@ class DirectSubmissionController {
DirectSubmissionController();
virtual ~DirectSubmissionController();
void setTimeoutParamsForPlatform(const ProductHelper &helper);
void registerDirectSubmission(CommandStreamReceiver *csr);
void unregisterDirectSubmission(CommandStreamReceiver *csr);
@@ -123,7 +115,6 @@ class DirectSubmissionController {
std::chrono::microseconds timeout{defaultTimeout};
int32_t timeoutDivisor = 1;
int32_t bcsTimeoutDivisor = 1;
std::unordered_map<size_t, TimeoutParams> timeoutParamsMap;
QueueThrottle lowestThrottleSubmitted = QueueThrottle::HIGH;
bool adjustTimeoutOnThrottleAndAcLineStatus = false;
bool isCsrIdleDetectionEnabled = false;

3
shared/source/os_interface/product_helper.h
View File

@@ -44,7 +44,6 @@ class Image;
class GraphicsAllocation;
class MemoryManager;
struct RootDeviceEnvironment;
struct TimeoutParams;
class OSInterface;
class DriverModel;
enum class DriverModelType;
@@ -113,8 +112,6 @@ class ProductHelper {
virtual bool isDirectSubmissionSupported(ReleaseHelper *releaseHelper) const = 0;
virtual bool isDirectSubmissionConstantCacheInvalidationNeeded(const HardwareInfo &hwInfo) const = 0;
virtual bool restartDirectSubmissionForHostptrFree() const = 0;
virtual bool isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled() const = 0;
virtual TimeoutParams getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const = 0;
virtual std::pair<bool, bool> isPipeControlPriorToNonPipelinedStateCommandsWARequired(const HardwareInfo &hwInfo, bool isRcs, const ReleaseHelper *releaseHelper) const = 0;
virtual bool heapInLocalMem(const HardwareInfo &hwInfo) const = 0;
virtual void setCapabilityCoherencyFlag(const HardwareInfo &hwInfo, bool &coherencyFlag) const = 0;

15
shared/source/os_interface/product_helper.inl
View File

@@ -384,21 +384,6 @@ bool ProductHelperHw<gfxProduct>::restartDirectSubmissionForHostptrFree() const
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
TimeoutParams ProductHelperHw<gfxProduct>::getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const {
TimeoutParams params{};
params.maxTimeout = std::chrono::microseconds{DirectSubmissionController::defaultTimeout};
params.timeout = std::chrono::microseconds{DirectSubmissionController::defaultTimeout};
params.timeoutDivisor = 1;
params.directSubmissionEnabled = true;
return params;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isForceEmuInt32DivRemSPWARequired(const HardwareInfo &hwInfo) const {
return false;

2
shared/source/os_interface/product_helper_hw.h
View File

@@ -52,8 +52,6 @@ class ProductHelperHw : public ProductHelper {
bool isDirectSubmissionSupported(ReleaseHelper *releaseHelper) const override;
bool isDirectSubmissionConstantCacheInvalidationNeeded(const HardwareInfo &hwInfo) const override;
bool restartDirectSubmissionForHostptrFree() const override;
bool isAdjustDirectSubmissionTimeoutOnThrottleAndAcLineStatusEnabled() const override;
TimeoutParams getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const override;
std::pair<bool, bool> isPipeControlPriorToNonPipelinedStateCommandsWARequired(const HardwareInfo &hwInfo, bool isRcs, const ReleaseHelper *releaseHelper) const override;
bool heapInLocalMem(const HardwareInfo &hwInfo) const override;
void setCapabilityCoherencyFlag(const HardwareInfo &hwInfo, bool &coherencyFlag) const override;

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

@@ -52,49 +52,6 @@ bool ProductHelperHw<gfxProduct>::isCachingOnCpuAvailable() const {
return false;
}
template <>
TimeoutParams ProductHelperHw<gfxProduct>::getDirectSubmissionControllerTimeoutParams(bool acLineConnected, QueueThrottle queueThrottle) const {
TimeoutParams params{};
if (acLineConnected) {
switch (queueThrottle) {
case NEO::LOW:
params.maxTimeout = std::chrono::microseconds{500};
params.timeout = std::chrono::microseconds{500};
break;
case NEO::MEDIUM:
params.maxTimeout = std::chrono::microseconds{4'500};
params.timeout = std::chrono::microseconds{4'500};
break;
case NEO::HIGH:
params.maxTimeout = std::chrono::microseconds{DirectSubmissionController::defaultTimeout};
params.timeout = std::chrono::microseconds{DirectSubmissionController::defaultTimeout};
break;
default:
break;
}
} else {
switch (queueThrottle) {
case NEO::LOW:
params.maxTimeout = std::chrono::microseconds{500};
params.timeout = std::chrono::microseconds{500};
break;
case NEO::MEDIUM:
params.maxTimeout = std::chrono::microseconds{2'000};
params.timeout = std::chrono::microseconds{2'000};
break;
case NEO::HIGH:
params.maxTimeout = std::chrono::microseconds{3'000};
params.timeout = std::chrono::microseconds{3'000};
break;
default:
break;
}
}
params.timeoutDivisor = 1;
params.directSubmissionEnabled = true;
return params;
}
template <>
bool ProductHelperHw<gfxProduct>::isMisalignedUserPtr2WayCoherent() const {
return true;

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

@@ -613,7 +613,6 @@ UseLocalPreferredForCacheableBuffers = -1
EnableFtrTile64Optimization = 0
ForceTlbFlushWithTaskCountAfterCopy = -1
ForceSynchronizedDispatchMode = -1
DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus = -1
ReadOnlyAllocationsTypeMask = 0
EnableLogLevel = 6
EnableReusingGpuTimestamps = -1

4
shared/test/unit_test/direct_submission/direct_submission_controller_mock.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2024 Intel Corporation
* Copyright (C) 2019-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,7 +19,6 @@ struct DirectSubmissionControllerMock : public DirectSubmissionController {
using DirectSubmissionController::directSubmissions;
using DirectSubmissionController::directSubmissionsMutex;
using DirectSubmissionController::getSleepValue;
using DirectSubmissionController::getTimeoutParamsMapKey;
using DirectSubmissionController::handlePagingFenceRequests;
using DirectSubmissionController::keepControlling;
using DirectSubmissionController::lastTerminateCpuTimestamp;
@@ -28,7 +27,6 @@ struct DirectSubmissionControllerMock : public DirectSubmissionController {
using DirectSubmissionController::pagingFenceRequests;
using DirectSubmissionController::timeout;
using DirectSubmissionController::timeoutDivisor;
using DirectSubmissionController::timeoutParamsMap;
using DirectSubmissionController::timeSinceLastCheck;
bool sleep(std::unique_lock<std::mutex> &lock) override {

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

@@ -162,7 +162,6 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenIncreas
DebugManagerStateRestore restorer;
debugManager.flags.DirectSubmissionControllerTimeout.set(5'000);
debugManager.flags.DirectSubmissionControllerMaxTimeout.set(200'000);
debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.set(0);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.prepareRootDeviceEnvironments(1);
executionEnvironment.initializeMemoryManager();
@@ -239,161 +238,6 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenIncreas
controller.unregisterDirectSubmission(&csr);
}
void fillTimeoutParamsMap(DirectSubmissionControllerMock &controller) {
controller.timeoutParamsMap.clear();
for (auto throttle : {QueueThrottle::LOW, QueueThrottle::MEDIUM, QueueThrottle::HIGH}) {
for (auto acLineStatus : {false, true}) {
auto key = controller.getTimeoutParamsMapKey(throttle, acLineStatus);
TimeoutParams params{};
if (throttle == QueueThrottle::LOW) {
params.maxTimeout = std::chrono::microseconds{500u};
} else {
params.maxTimeout = std::chrono::microseconds{500u + static_cast<size_t>(throttle) * 500u + (acLineStatus ? 0u : 1500u)};
}
params.timeout = params.maxTimeout;
params.timeoutDivisor = 1;
params.directSubmissionEnabled = true;
auto keyValue = std::make_pair(key, params);
bool result = false;
std::tie(std::ignore, result) = controller.timeoutParamsMap.insert(keyValue);
EXPECT_TRUE(result);
}
}
}
TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndAdjustOnThrottleAndAcLineStatusDisabledWhenSetTimeoutParamsForPlatformThenTimeoutParamsMapsIsEmpty) {
DebugManagerStateRestore restorer;
debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.set(0);
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());
DirectSubmissionControllerMock controller;
controller.setTimeoutParamsForPlatform(csr.getProductHelper());
EXPECT_EQ(0u, controller.timeoutParamsMap.size());
}
TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerAndAdjustOnThrottleAndAcLineStatusEnabledWhenThrottleOrAcLineStatusChangesThenTimeoutIsChanged) {
DebugManagerStateRestore restorer;
debugManager.flags.DirectSubmissionControllerAdjustOnThrottleAndAcLineStatus.set(1);
MockExecutionEnvironment executionEnvironment;
executionEnvironment.prepareRootDeviceEnvironments(1);
executionEnvironment.initializeMemoryManager();
executionEnvironment.rootDeviceEnvironments[0]->initOsTime();
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());
DirectSubmissionControllerMock controller;
controller.timeoutElapsedReturnValue.store(TimeoutElapsedMode::fullyElapsed);
controller.setTimeoutParamsForPlatform(csr.getProductHelper());
controller.registerDirectSubmission(&csr);
EXPECT_TRUE(controller.adjustTimeoutOnThrottleAndAcLineStatus);
fillTimeoutParamsMap(controller);
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::LOW;
csr.getAcLineConnectedReturnValue = true;
csr.taskCount.store(1u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 1u);
EXPECT_EQ(500u, controller.timeout.count());
EXPECT_EQ(500u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::MEDIUM;
csr.getAcLineConnectedReturnValue = true;
csr.taskCount.store(2u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 2u);
EXPECT_EQ(1'000u, controller.timeout.count());
EXPECT_EQ(1'000u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::HIGH;
csr.getAcLineConnectedReturnValue = true;
csr.taskCount.store(3u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 3u);
EXPECT_EQ(1'500u, controller.timeout.count());
EXPECT_EQ(1'500u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::LOW;
csr.getAcLineConnectedReturnValue = false;
csr.taskCount.store(4u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 4u);
EXPECT_EQ(500u, controller.timeout.count());
EXPECT_EQ(500u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::MEDIUM;
csr.getAcLineConnectedReturnValue = false;
csr.taskCount.store(5u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 5u);
EXPECT_EQ(2'500u, controller.timeout.count());
EXPECT_EQ(2'500u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::HIGH;
csr.getLastDirectSubmissionThrottleReturnValue = QueueThrottle::HIGH;
csr.getAcLineConnectedReturnValue = false;
csr.taskCount.store(6u);
controller.checkNewSubmissions();
EXPECT_FALSE(controller.directSubmissions[&csr].isStopped);
EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 6u);
EXPECT_EQ(3'000u, controller.timeout.count());
EXPECT_EQ(3'000u, controller.maxTimeout.count());
EXPECT_EQ(1, controller.timeoutDivisor);
}
{
controller.lowestThrottleSubmitted = QueueThrottle::LOW;
controller.checkNewSubmissions();
EXPECT_EQ(QueueThrottle::HIGH, controller.lowestThrottleSubmitted);
}
controller.unregisterDirectSubmission(&csr);
}
TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterCsrsThenTimeoutIsAdjusted) {
MockExecutionEnvironment executionEnvironment;
executionEnvironment.prepareRootDeviceEnvironments(1);