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

performance: set 1ms ULLS timeout on Windows since Xe2

Browse Source 
Related-To: NEO-13843

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek
2025-06-16 16:40:35 +00:00
committed by Compute-Runtime-Automation
parent 763fe6ff86
commit 558752288f
14 changed files with 72 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -14,7 +14,6 @@
#include "shared/source/os_interface/os_context.h"
#include "shared/source/os_interface/os_thread.h"
#include "shared/source/os_interface/os_time.h"
#include "shared/source/os_interface/product_helper.h"
#include <chrono>
#include <thread>
@@ -45,7 +44,7 @@ DirectSubmissionController::~DirectSubmissionController() {
void DirectSubmissionController::registerDirectSubmission(CommandStreamReceiver *csr) {
std::lock_guard<std::mutex> lock(directSubmissionsMutex);
directSubmissions.insert(std::make_pair(csr, DirectSubmissionState()));
csr->getProductHelper().overrideDirectSubmissionTimeouts(this->timeout, this->maxTimeout);
this->overrideDirectSubmissionTimeouts(csr->getProductHelper());
}
void DirectSubmissionController::unregisterDirectSubmission(CommandStreamReceiver *csr) {

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

@@ -89,6 +89,7 @@ class DirectSubmissionController {
bool isDirectSubmissionIdle(CommandStreamReceiver *csr, std::unique_lock<std::recursive_mutex> &csrLock);
MOCKABLE_VIRTUAL bool sleep(std::unique_lock<std::mutex> &lock);
MOCKABLE_VIRTUAL SteadyClock::time_point getCpuTimestamp();
MOCKABLE_VIRTUAL void overrideDirectSubmissionTimeouts(const ProductHelper &productHelper);
void recalculateTimeout();
void applyTimeoutForAcLineStatusAndThrottle(bool acLineConnected);
@@ -116,7 +117,6 @@ class DirectSubmissionController {
int32_t timeoutDivisor = 1;
int32_t bcsTimeoutDivisor = 1;
QueueThrottle lowestThrottleSubmitted = QueueThrottle::HIGH;
bool adjustTimeoutOnThrottleAndAcLineStatus = false;
bool isCsrIdleDetectionEnabled = false;
std::condition_variable condVar;

4
shared/source/direct_submission/linux/direct_submission_controller_linux.cpp
View File

@@ -13,4 +13,8 @@ namespace NEO {
bool DirectSubmissionController::sleep(std::unique_lock<std::mutex> &lock) {
return NEO::waitOnConditionWithPredicate(condVar, lock, getSleepValue(), [&] { return !pagingFenceRequests.empty(); });
}
void DirectSubmissionController::overrideDirectSubmissionTimeouts(const ProductHelper &productHelper) {
}
} // namespace NEO

6
shared/source/direct_submission/windows/direct_submission_controller_windows.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/direct_submission/direct_submission_controller.h"
#include "shared/source/helpers/sleep.h"
#include "shared/source/os_interface/product_helper.h"
#include "shared/source/os_interface/windows/sys_calls_winmm.h"
#include <chrono>
@@ -17,4 +18,9 @@ bool DirectSubmissionController::sleep(std::unique_lock<std::mutex> &lock) {
SysCalls::timeEndPeriod(1u);
return returnValue;
}
void DirectSubmissionController::overrideDirectSubmissionTimeouts(const ProductHelper &productHelper) {
productHelper.overrideDirectSubmissionTimeouts(this->timeout, this->maxTimeout);
}
} // namespace NEO

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

@@ -971,10 +971,6 @@ uint32_t ProductHelperHw<gfxProduct>::adjustMaxThreadsPerThreadGroup(uint32_t ma
return maxThreadsPerThreadGroup;
}
template <PRODUCT_FAMILY gfxProduct>
void ProductHelperHw<gfxProduct>::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const {
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isMisalignedUserPtr2WayCoherent() const {
return false;

4
shared/source/os_interface/product_helper_before_xe2.inl
View File

@@ -66,4 +66,8 @@ bool ProductHelperHw<gfxProduct>::isPidFdOrSocketForIpcSupported() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
void ProductHelperHw<gfxProduct>::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const {
}
} // namespace NEO

12
shared/source/os_interface/product_helper_xe2_and_later.inl
View File

@@ -69,4 +69,16 @@ bool ProductHelperHw<gfxProduct>::isPidFdOrSocketForIpcSupported() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
void ProductHelperHw<gfxProduct>::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

12
shared/source/xe2_hpg_core/windows/product_helper_lnl.cpp
View File

@@ -21,17 +21,5 @@ bool ProductHelperHw<gfxProduct>::restartDirectSubmissionForHostptrFree() const
return true;
}
template <>
void ProductHelperHw<gfxProduct>::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()};
}
}
template class ProductHelperHw<gfxProduct>;
} // namespace NEO

12
shared/source/xe3_core/windows/product_helper_ptl.cpp
View File

@@ -16,18 +16,6 @@ constexpr static auto gfxProduct = IGFX_PTL;
namespace NEO {
template <>
void ProductHelperHw<gfxProduct>::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()};
}
}
template class ProductHelperHw<gfxProduct>;
} // namespace NEO

4
shared/test/common/mocks/mock_product_helper.cpp
View File

@@ -488,6 +488,10 @@ bool ProductHelperHw<IGFX_UNKNOWN>::isPidFdOrSocketForIpcSupported() const {
return false;
}
template <>
void ProductHelperHw<IGFX_UNKNOWN>::overrideDirectSubmissionTimeouts(std::chrono::microseconds &timeout, std::chrono::microseconds &maxTimeout) const {
}
} // namespace NEO
#include "shared/source/os_interface/product_helper.inl"

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

@@ -11,7 +11,6 @@
namespace NEO {
struct DirectSubmissionControllerMock : public DirectSubmissionController {
using DirectSubmissionController::adjustTimeoutOnThrottleAndAcLineStatus;
using DirectSubmissionController::bcsTimeoutDivisor;
using DirectSubmissionController::checkNewSubmissions;
using DirectSubmissionController::condVarMutex;

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

@@ -238,26 +238,6 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenIncreas
controller.unregisterDirectSubmission(&csr);
}
TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegisterCsrsThenTimeoutIsAdjusted) {
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;
auto timeout = std::chrono::microseconds{5'000};
EXPECT_EQ(controller.timeout, timeout);
controller.registerDirectSubmission(&csr);
csr.getProductHelper().overrideDirectSubmissionTimeouts(timeout, timeout);
EXPECT_EQ(controller.timeout, timeout);
}
TEST(DirectSubmissionControllerTests, givenPowerSavingUintWhenCallingGetThrottleFromPowerSavingUintThenCorrectValueIsReturned) {
EXPECT_EQ(QueueThrottle::MEDIUM, getThrottleFromPowerSavingUint(0u));
EXPECT_EQ(QueueThrottle::LOW, getThrottleFromPowerSavingUint(1u));

14
shared/test/unit_test/direct_submission/windows/wddm_direct_submission_tests.cpp
View File

@@ -1333,4 +1333,18 @@ HWTEST2_F(WddmDirectSubmissionTest, givenRelaxedOrderingSchedulerRequiredWhenAsk
EXPECT_EQ(expectedBaseEndSize + directSubmission.getSizeDispatchRelaxedOrderingQueueStall(), directSubmission.getSizeEnd(true));
EXPECT_EQ(expectedBaseEndSize, directSubmission.getSizeEnd(false));
}
HWTEST_F(WddmDirectSubmissionTest, givenDirectSubmissionControllerWhenRegisterCsrsThenTimeoutIsAdjusted) {
auto csr = device->getDefaultEngine().commandStreamReceiver;
DirectSubmissionControllerMock controller;
auto timeout = std::chrono::microseconds{5'000};
EXPECT_EQ(controller.timeout, timeout);
controller.registerDirectSubmission(csr);
csr->getProductHelper().overrideDirectSubmissionTimeouts(timeout, timeout);
EXPECT_EQ(controller.timeout, timeout);
controller.unregisterDirectSubmission(csr);
}
} // namespace NEO

26
shared/test/unit_test/os_interface/product_helper_tests.cpp
View File

@@ -1145,6 +1145,32 @@ HWTEST2_F(ProductHelperTest, givenProductHelperThenCompressionIsNotForbidden, Is
EXPECT_FALSE(productHelper->isCompressionForbidden(hwInfo));
}
HWTEST2_F(ProductHelperTest, givenProductHelperBeforeXe2WhenOverrideDirectSubmissionTimeoutsThenTimeoutsNotAdjusted, IsBeforeXe2HpgCore) {
DebugManagerStateRestore restorer;
std::chrono::microseconds timeout{5000};
std::chrono::microseconds maxTimeout{5000};
productHelper->overrideDirectSubmissionTimeouts(timeout, maxTimeout);
EXPECT_EQ(std::chrono::microseconds{5000}, timeout);
EXPECT_EQ(std::chrono::microseconds{5000}, maxTimeout);
}
HWTEST2_F(ProductHelperTest, givenProductHelperWhenOverrideDirectSubmissionTimeoutsThenTimeoutsAdjusted, IsAtLeastXe2HpgCore) {
DebugManagerStateRestore restorer;
std::chrono::microseconds timeout{5000};
std::chrono::microseconds maxTimeout{5000};
productHelper->overrideDirectSubmissionTimeouts(timeout, maxTimeout);
EXPECT_EQ(std::chrono::microseconds{1000}, timeout);
EXPECT_EQ(std::chrono::microseconds{1000}, maxTimeout);
debugManager.flags.DirectSubmissionControllerTimeout.set(10000);
debugManager.flags.DirectSubmissionControllerMaxTimeout.set(10000);
productHelper->overrideDirectSubmissionTimeouts(timeout, maxTimeout);
EXPECT_EQ(std::chrono::microseconds{10000}, timeout);
EXPECT_EQ(std::chrono::microseconds{10000}, maxTimeout);
}
HWTEST_F(ProductHelperTest, givenProductHelperWhenQueryIsPostImageWriteFlushRequiredThenFalseReturned) {
EXPECT_FALSE(productHelper->isPostImageWriteFlushRequired());
}