Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: remove unused ulls diagnostic mode 

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk 2025-05-09 08:28:30 +00:00 committed by Compute-Runtime-Automation
parent 9dc734ce44
commit e964ccdf57
12 changed files with 30 additions and 819 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -436,8 +436,6 @@ DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionSemaphorePlacement, -1, "-1: do
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionBufferAddressing, -1, "-1: do not override, 0: not use 48bit, 1: use 48bit")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionSemaphoreAddressing, -1, "-1: do not override, 0: not use 48bit, 1: use 48bit")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionDisableCpuCacheFlush, -1, "-1: do not override, 0: disable, 1: enable")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionEnableDebugBuffer, 0, "0: diagnostic feature disabled - dispatch regular workload, 1: dispatch diagnostic buffer - mode 1 - single SDI command, 2: dispatch diagnostic buffer - mode 2 - no command")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionDiagnosticExecutionCount, 30, "Number of executions of EnableDebugBuffer modes within diagnostic run")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionDrmContext, -1, "Create special drm context: -1: default, when new residency model available, 0: disable, 1: enable")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionOverrideBlitterSupport, -1, "Overrides default blitter support: -1: do not override, 0: disable engine support, 1: enable engine support with init start, 2: enable engine support without init start")
DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionOverrideRenderSupport, -1, "Overrides default render support: -1: do not override, 0: disable engine support, 1: enable engine support with init start, 2: enable engine support without init start")

2
shared/source/direct_submission/CMakeLists.txt
View File

@ -14,8 +14,6 @@ set(NEO_CORE_DIRECT_SUBMISSION
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_hw.h
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_hw.inl
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_tgllp_and_later.inl
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_hw_diagnostic_mode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_hw_diagnostic_mode.h
${CMAKE_CURRENT_SOURCE_DIR}/direct_submission_properties.h
${CMAKE_CURRENT_SOURCE_DIR}/relaxed_ordering_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/relaxed_ordering_helper.h

15
shared/source/direct_submission/direct_submission_hw.h
View File

@ -25,10 +25,7 @@ struct RingSemaphoreData {
uint8_t reservedCacheline0[60];
uint32_t tagAllocation;
uint8_t reservedCacheline1[60];
uint32_t diagnosticModeCounter;
uint32_t reserved0Uint32;
uint64_t reserved1Uint64;
uint8_t reservedCacheline2[48];
uint8_t reservedCacheline2[64];
uint64_t miFlushSpace;
uint8_t reservedCacheline3[56];
uint32_t pagingFenceCounter;
@ -56,7 +53,6 @@ inline constexpr bool defaultDisableMonitorFence = true;
} // namespace UllsDefaults
struct BatchBuffer;
class DirectSubmissionDiagnosticsCollector;
class FlushStampTracker;
class GraphicsAllocation;
struct HardwareInfo;
@ -205,11 +201,6 @@ class DirectSubmissionHw {
void dispatchSystemMemoryFenceAddress();
size_t getSizeSystemMemoryFenceAddress();
void createDiagnostic();
void initDiagnostic(bool &submitOnInit);
MOCKABLE_VIRTUAL void performDiagnosticMode();
void dispatchDiagnosticModeSection();
size_t getDiagnosticModeSection();
void setImmWritePostSyncOffset();
virtual void dispatchStopRingBufferSection(){};
virtual size_t dispatchStopRingBufferSectionSize() {
@ -239,7 +230,6 @@ class DirectSubmissionHw {
uint32_t maxRingBufferCount = std::numeric_limits<uint32_t>::max();
LinearStream ringCommandStream;
std::unique_ptr<DirectSubmissionDiagnosticsCollector> diagnostic;
uint64_t semaphoreGpuVa = 0u;
uint64_t gpuVaForMiFlush = 0u;
@ -261,13 +251,10 @@ class DirectSubmissionHw {
GraphicsAllocation *relaxedOrderingSchedulerAllocation = nullptr;
void *semaphorePtr = nullptr;
volatile RingSemaphoreData *semaphoreData = nullptr;
volatile void *workloadModeOneStoreAddress = nullptr;
uint32_t *pciBarrierPtr = nullptr;
volatile TagAddressType *tagAddress;
uint32_t currentQueueWorkCount = 1u;
uint32_t workloadMode = 0;
uint32_t workloadModeOneExpectedValue = 0u;
uint32_t activeTiles = 1u;
uint32_t immWritePostSyncOffset = 0u;
uint32_t currentRelaxedOrderingQueueSize = 0;

145
shared/source/direct_submission/direct_submission_hw.inl
View File

@ -11,7 +11,6 @@
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/device/device.h"
#include "shared/source/direct_submission/direct_submission_hw.h"
#include "shared/source/direct_submission/direct_submission_hw_diagnostic_mode.h"
#include "shared/source/direct_submission/relaxed_ordering_helper.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
@ -98,7 +97,6 @@ DirectSubmissionHw<GfxFamily, Dispatcher>::DirectSubmissionHw(const DirectSubmis
UNRECOVERABLE_IF(!CpuInfo::getInstance().isFeatureSupported(CpuInfo::featureClflush) && !disableCpuCacheFlush);
createDiagnostic();
setImmWritePostSyncOffset();
dcFlushRequired = MemorySynchronizationCommands<GfxFamily>::getDcFlushEnable(true, inputParams.rootDeviceEnvironment);
@ -406,8 +404,6 @@ bool DirectSubmissionHw<GfxFamily, Dispatcher>::allocateResources() {
memset(semaphorePtr, 0, sizeof(RingSemaphoreData));
semaphoreData->queueWorkCount = 0;
cpuCachelineFlush(semaphorePtr, MemoryConstants::cacheLineSize);
workloadModeOneStoreAddress = static_cast<volatile void *>(&semaphoreData->diagnosticModeCounter);
*static_cast<volatile uint32_t *>(workloadModeOneStoreAddress) = 0u;
this->gpuVaForMiFlush = this->semaphoreGpuVa + offsetof(RingSemaphoreData, miFlushSpace);
this->gpuVaForPagingFenceSemaphore = this->semaphoreGpuVa + offsetof(RingSemaphoreData, pagingFenceCounter);
@ -469,7 +465,6 @@ template <typename GfxFamily, typename Dispatcher>
bool DirectSubmissionHw<GfxFamily, Dispatcher>::initialize(bool submitOnInit) {
bool ret = allocateResources();
initDiagnostic(submitOnInit);
if (ret && submitOnInit) {
size_t startBufferSize = Dispatcher::getSizePreemption() +
getSizeSemaphoreSection(false);
@ -496,14 +491,10 @@ bool DirectSubmissionHw<GfxFamily, Dispatcher>::initialize(bool submitOnInit) {
this->relaxedOrderingInitialized = true;
}
if (workloadMode == 1) {
dispatchDiagnosticModeSection();
startBufferSize += getDiagnosticModeSection();
}
dispatchSemaphoreSection(currentQueueWorkCount);
ringStart = submit(ringCommandStream.getGraphicsAllocation()->getGpuAddress(), startBufferSize, nullptr);
performDiagnosticMode();
return ringStart;
}
return ret;
@ -644,16 +635,10 @@ inline size_t DirectSubmissionHw<GfxFamily, Dispatcher>::getSizeEnd(bool relaxed
template <typename GfxFamily, typename Dispatcher>
inline size_t DirectSubmissionHw<GfxFamily, Dispatcher>::getSizeDispatch(bool relaxedOrderingSchedulerRequired, bool returnPtrsRequired, bool dispatchMonitorFence) {
size_t size = getSizeSemaphoreSection(relaxedOrderingSchedulerRequired);
if (workloadMode == 0) {
size += getSizeStartSection();
if (this->relaxedOrderingEnabled && returnPtrsRequired) {
size += RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>();
}
} else if (workloadMode == 1) {
size += getDiagnosticModeSection();
size_t size = getSizeSemaphoreSection(relaxedOrderingSchedulerRequired) + getSizeStartSection();
if (this->relaxedOrderingEnabled && returnPtrsRequired) {
size += RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>();
}
// mode 2 does not dispatch any commands
if (!disableCacheFlush) {
size += Dispatcher::getSizeCacheFlush(rootDeviceEnvironment);
@ -711,38 +696,32 @@ void *DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchWorkloadSection(BatchBu
dispatchSemaphoreForPagingFence(batchBuffer.pagingFenceSemInfo.pagingFenceValue);
}
if (workloadMode == 0) {
auto commandStreamAddress = ptrOffset(batchBuffer.commandBufferAllocation->getGpuAddress(), batchBuffer.startOffset);
void *returnCmd = batchBuffer.endCmdPtr;
auto commandStreamAddress = ptrOffset(batchBuffer.commandBufferAllocation->getGpuAddress(), batchBuffer.startOffset);
void *returnCmd = batchBuffer.endCmdPtr;
LinearStream relaxedOrderingReturnPtrCmdStream;
if (this->relaxedOrderingEnabled && batchBuffer.hasRelaxedOrderingDependencies) {
// preallocate and patch after start section
auto relaxedOrderingReturnPtrCmds = ringCommandStream.getSpace(RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>());
relaxedOrderingReturnPtrCmdStream.replaceBuffer(relaxedOrderingReturnPtrCmds, RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>());
}
if (copyCmdBuffer) {
auto cmdStreamTaskPtr = ptrOffset(batchBuffer.stream->getCpuBase(), batchBuffer.startOffset);
auto sizeToCopy = ptrDiff(returnCmd, cmdStreamTaskPtr);
auto ringPtr = ringCommandStream.getSpace(sizeToCopy);
memcpy(ringPtr, cmdStreamTaskPtr, sizeToCopy);
} else {
dispatchStartSection(commandStreamAddress);
}
uint64_t returnGpuPointer = ringCommandStream.getCurrentGpuAddressPosition();
if (this->relaxedOrderingEnabled && batchBuffer.hasRelaxedOrderingDependencies) {
dispatchRelaxedOrderingReturnPtrRegs(relaxedOrderingReturnPtrCmdStream, returnGpuPointer);
} else if (!copyCmdBuffer) {
setReturnAddress(returnCmd, returnGpuPointer);
}
} else if (workloadMode == 1) {
DirectSubmissionDiagnostics::diagnosticModeOneDispatch(diagnostic.get());
dispatchDiagnosticModeSection();
LinearStream relaxedOrderingReturnPtrCmdStream;
if (this->relaxedOrderingEnabled && batchBuffer.hasRelaxedOrderingDependencies) {
// preallocate and patch after start section
auto relaxedOrderingReturnPtrCmds = ringCommandStream.getSpace(RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>());
relaxedOrderingReturnPtrCmdStream.replaceBuffer(relaxedOrderingReturnPtrCmds, RelaxedOrderingHelper::getSizeReturnPtrRegs<GfxFamily>());
}
if (copyCmdBuffer) {
auto cmdStreamTaskPtr = ptrOffset(batchBuffer.stream->getCpuBase(), batchBuffer.startOffset);
auto sizeToCopy = ptrDiff(returnCmd, cmdStreamTaskPtr);
auto ringPtr = ringCommandStream.getSpace(sizeToCopy);
memcpy(ringPtr, cmdStreamTaskPtr, sizeToCopy);
} else {
dispatchStartSection(commandStreamAddress);
}
uint64_t returnGpuPointer = ringCommandStream.getCurrentGpuAddressPosition();
if (this->relaxedOrderingEnabled && batchBuffer.hasRelaxedOrderingDependencies) {
dispatchRelaxedOrderingReturnPtrRegs(relaxedOrderingReturnPtrCmdStream, returnGpuPointer);
} else if (!copyCmdBuffer) {
setReturnAddress(returnCmd, returnGpuPointer);
}
// mode 2 does not dispatch any commands
if (this->relaxedOrderingEnabled && batchBuffer.hasRelaxedOrderingDependencies) {
dispatchTaskStoreSection(batchBuffer.taskStartAddress);
@ -1023,7 +1002,6 @@ bool DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchCommandBuffer(BatchBuffe
cpuCachelineFlush(semaphorePtr, MemoryConstants::cacheLineSize);
currentQueueWorkCount++;
DirectSubmissionDiagnostics::diagnosticModeOneSubmit(diagnostic.get());
uint64_t flushValue = updateTagValue(dispatchMonitorFence);
if (flushValue == DirectSubmissionHw<GfxFamily, Dispatcher>::updateTagValueFail) {
@ -1173,73 +1151,6 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::deallocateResources() {
memoryManager->freeGraphicsMemory(relaxedOrderingSchedulerAllocation);
}
template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::createDiagnostic() {
if (directSubmissionDiagnosticAvailable) {
workloadMode = debugManager.flags.DirectSubmissionEnableDebugBuffer.get();
if (workloadMode > 0) {
disableCacheFlush = debugManager.flags.DirectSubmissionDisableCacheFlush.get();
disableMonitorFence = debugManager.flags.DirectSubmissionDisableMonitorFence.get();
uint32_t executions = static_cast<uint32_t>(debugManager.flags.DirectSubmissionDiagnosticExecutionCount.get());
diagnostic = std::make_unique<DirectSubmissionDiagnosticsCollector>(
executions,
workloadMode == 1,
debugManager.flags.DirectSubmissionBufferPlacement.get(),
debugManager.flags.DirectSubmissionSemaphorePlacement.get(),
workloadMode,
disableCacheFlush,
disableMonitorFence);
}
}
}
template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::initDiagnostic(bool &submitOnInit) {
if (directSubmissionDiagnosticAvailable) {
if (diagnostic.get()) {
submitOnInit = true;
diagnostic->diagnosticModeAllocation();
}
}
}
template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::performDiagnosticMode() {
if (directSubmissionDiagnosticAvailable) {
if (diagnostic.get()) {
diagnostic->diagnosticModeDiagnostic();
if (workloadMode == 1) {
diagnostic->diagnosticModeOneWait(workloadModeOneStoreAddress, workloadModeOneExpectedValue);
}
BatchBuffer dummyBuffer = {};
FlushStampTracker dummyTracker(true);
for (uint32_t execution = 0; execution < diagnostic->getExecutionsCount(); execution++) {
dispatchCommandBuffer(dummyBuffer, dummyTracker);
if (workloadMode == 1) {
diagnostic->diagnosticModeOneWaitCollect(execution, workloadModeOneStoreAddress, workloadModeOneExpectedValue);
}
}
workloadMode = 0;
disableCacheFlush = UllsDefaults::defaultDisableCacheFlush;
disableMonitorFence = UllsDefaults::defaultDisableMonitorFence;
diagnostic.reset(nullptr);
}
}
}
template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchDiagnosticModeSection() {
workloadModeOneExpectedValue++;
uint64_t storeAddress = semaphoreGpuVa;
storeAddress += ptrDiff(workloadModeOneStoreAddress, semaphorePtr);
Dispatcher::dispatchStoreDwordCommand(ringCommandStream, storeAddress, workloadModeOneExpectedValue);
}
template <typename GfxFamily, typename Dispatcher>
size_t DirectSubmissionHw<GfxFamily, Dispatcher>::getDiagnosticModeSection() {
return Dispatcher::getSizeStoreDwordCommand();
}
template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchSystemMemoryFenceAddress() {
this->makeGlobalFenceAlwaysResident();

56
shared/source/direct_submission/direct_submission_hw_diagnostic_mode.cpp
View File

@ -1,56 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/direct_submission/direct_submission_hw_diagnostic_mode.h"
#include "shared/source/helpers/debug_helpers.h"
namespace NEO {
DirectSubmissionDiagnosticsCollector::DirectSubmissionDiagnosticsCollector(uint32_t executions,
bool storeExecutions,
int32_t ringBufferLogData,
int32_t semaphoreLogData,
int32_t workloadMode,
bool cacheFlushLog,
bool monitorFenceLog)
: storeExecutions(storeExecutions) {
UNRECOVERABLE_IF(executions == 0);
executionList.resize(executions);
executionsCount = executions;
std::stringstream value;
value << std::dec << "mode-" << workloadMode << "_executions-" << executions;
value << "_ring_" << ringBufferLogData << "_semaphore_" << semaphoreLogData;
value << "_cacheflush-" << cacheFlushLog << "_monitorfence-" << monitorFenceLog;
std::stringstream filename;
filename << "ulls_diagnostic_" << value.str() << ".log";
logFile = IoFunctions::fopenPtr(filename.str().c_str(), "at");
UNRECOVERABLE_IF(logFile == nullptr);
IoFunctions::fprintf(logFile, "%s\n", value.str().c_str());
}
void DirectSubmissionDiagnosticsCollector::storeData() {
auto initDelta = diagnosticModeDiagnosticTime - diagnosticModeAllocationTime;
int64_t initTimeDiff =
std::chrono::duration_cast<std::chrono::microseconds>(initDelta).count();
IoFunctions::fprintf(logFile, "From allocations ready to exit of OS submit function %lld useconds\n", initTimeDiff);
if (storeExecutions) {
for (uint32_t execution = 0; execution < executionsCount; execution++) {
DirectSubmissionSingleDelta &delta = executionList[execution];
std::stringstream value;
value << std::dec << " execution: " << execution;
value << " total diff: " << delta.totalTimeDiff << " nsec"
<< " dispatch-submit: " << delta.dispatchSubmitTimeDiff << " nsec"
<< " submit-wait: " << delta.submitWaitTimeDiff << " nsec";
IoFunctions::fprintf(logFile, "%s\n", value.str().c_str());
}
}
}
} // namespace NEO

117
shared/source/direct_submission/direct_submission_hw_diagnostic_mode.h
View File

@ -1,117 +0,0 @@
/*
* Copyright (C) 2020-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "shared/source/utilities/io_functions.h"
#include <chrono>
#include <sstream>
#include <vector>
namespace NEO {
#if defined(_RELEASE_INTERNAL) || (_DEBUG)
inline constexpr bool directSubmissionDiagnosticAvailable = true;
#else
inline constexpr bool directSubmissionDiagnosticAvailable = false;
#endif
struct DirectSubmissionSingleDelta {
int64_t dispatchSubmitTimeDiff = 0;
int64_t submitWaitTimeDiff = 0;
int64_t totalTimeDiff = 0;
};
using DirectSubmissionExecution = std::vector<DirectSubmissionSingleDelta>;
class DirectSubmissionDiagnosticsCollector : NonCopyableAndNonMovableClass {
public:
DirectSubmissionDiagnosticsCollector(uint32_t executions,
bool storeExecutions,
int32_t ringBufferLogData,
int32_t semaphoreLogData,
int32_t workloadMode,
bool cacheFlushLog,
bool monitorFenceLog);
~DirectSubmissionDiagnosticsCollector() {
storeData();
IoFunctions::fclosePtr(logFile);
}
void diagnosticModeAllocation() {
diagnosticModeAllocationTime = std::chrono::high_resolution_clock::now();
}
void diagnosticModeDiagnostic() {
diagnosticModeDiagnosticTime = std::chrono::high_resolution_clock::now();
}
void diagnosticModeOneDispatch() {
diagnosticModeOneDispatchTime = std::chrono::high_resolution_clock::now();
}
void diagnosticModeOneSubmit() {
diagnosticModeOneSubmitTime = std::chrono::high_resolution_clock::now();
}
void diagnosticModeOneWait(volatile void *waitLocation,
uint32_t waitValue) {
volatile uint32_t *waitAddress = static_cast<volatile uint32_t *>(waitLocation);
while (waitValue > *waitAddress)
;
}
void diagnosticModeOneWaitCollect(uint32_t execution,
volatile void *waitLocation,
uint32_t waitValue) {
diagnosticModeOneWait(waitLocation, waitValue);
diagnosticModeOneWaitTime = std::chrono::high_resolution_clock::now();
auto delta = diagnosticModeOneWaitTime - diagnosticModeOneDispatchTime;
executionList[execution].totalTimeDiff = std::chrono::duration_cast<std::chrono::nanoseconds>(delta).count();
delta = diagnosticModeOneSubmitTime - diagnosticModeOneDispatchTime;
executionList[execution].dispatchSubmitTimeDiff = std::chrono::duration_cast<std::chrono::nanoseconds>(delta).count();
delta = diagnosticModeOneWaitTime - diagnosticModeOneSubmitTime;
executionList[execution].submitWaitTimeDiff = std::chrono::duration_cast<std::chrono::nanoseconds>(delta).count();
}
uint32_t getExecutionsCount() const {
return executionsCount;
}
void storeData();
protected:
std::chrono::high_resolution_clock::time_point diagnosticModeOneDispatchTime;
std::chrono::high_resolution_clock::time_point diagnosticModeOneSubmitTime;
std::chrono::high_resolution_clock::time_point diagnosticModeOneWaitTime;
std::chrono::high_resolution_clock::time_point diagnosticModeAllocationTime;
std::chrono::high_resolution_clock::time_point diagnosticModeDiagnosticTime;
DirectSubmissionExecution executionList;
FILE *logFile = nullptr;
uint32_t executionsCount = 0;
bool storeExecutions = true;
};
namespace DirectSubmissionDiagnostics {
inline void diagnosticModeOneDispatch(DirectSubmissionDiagnosticsCollector *collect) {
if (directSubmissionDiagnosticAvailable) {
if (collect) {
collect->diagnosticModeOneDispatch();
}
}
}
inline void diagnosticModeOneSubmit(DirectSubmissionDiagnosticsCollector *collect) {
if (directSubmissionDiagnosticAvailable) {
if (collect) {
collect->diagnosticModeOneSubmit();
}
}
}
} // namespace DirectSubmissionDiagnostics
} // namespace NEO

20
shared/test/common/mocks/mock_direct_submission_hw.h
View File

@ -7,7 +7,6 @@
#pragma once
#include "shared/source/direct_submission/direct_submission_hw.h"
#include "shared/source/direct_submission/direct_submission_hw_diagnostic_mode.h"
#include "shared/source/memory_manager/graphics_allocation.h"
#include "shared/test/common/mocks/mock_memory_operations_handler.h"
namespace NEO {
@ -27,7 +26,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
using BaseClass::deallocateResources;
using BaseClass::deferredTasksListAllocation;
using BaseClass::detectGpuHang;
using BaseClass::diagnostic;
using BaseClass::DirectSubmissionHw;
using BaseClass::disableCacheFlush;
using BaseClass::disableCpuCacheFlush;
@ -42,7 +40,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
using BaseClass::dispatchSwitchRingBufferSection;
using BaseClass::dispatchUllsState;
using BaseClass::dispatchWorkloadSection;
using BaseClass::getDiagnosticModeSection;
using BaseClass::getSizeDisablePrefetcher;
using BaseClass::getSizeDispatch;
using BaseClass::getSizeDispatchRelaxedOrderingQueueStall;
@ -67,7 +64,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
using BaseClass::partitionConfigSet;
using BaseClass::partitionedMode;
using BaseClass::pciBarrierPtr;
using BaseClass::performDiagnosticMode;
using BaseClass::preinitializedRelaxedOrderingScheduler;
using BaseClass::preinitializedTaskStoreSection;
using BaseClass::relaxedOrderingEnabled;
@ -89,9 +85,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
using BaseClass::switchRingBuffersNeeded;
using BaseClass::systemMemoryFenceAddressSet;
using BaseClass::unblockGpu;
using BaseClass::workloadMode;
using BaseClass::workloadModeOneExpectedValue;
using BaseClass::workloadModeOneStoreAddress;
using BaseClass::workPartitionAllocation;
using typename BaseClass::RingBufferUse;
@ -167,18 +160,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
tagData.tagValue = tagValueSetValue;
}
void performDiagnosticMode() override {
if (!NEO::directSubmissionDiagnosticAvailable) {
disabledDiagnosticCalled++;
}
uint32_t add = 1;
if (diagnostic.get()) {
add += diagnostic->getExecutionsCount();
}
*static_cast<volatile uint32_t *>(workloadModeOneStoreAddress) = workloadModeOneExpectedValue + add;
BaseClass::performDiagnosticMode();
}
bool isCompleted(uint32_t ringBufferIndex) override {
return this->isCompletedReturn;
}
@ -199,7 +180,6 @@ struct MockDirectSubmissionHw : public DirectSubmissionHw<GfxFamily, Dispatcher>
size_t submitSize = 0u;
uint32_t submitCount = 0u;
uint32_t handleResidencyCount = 0u;
uint32_t disabledDiagnosticCalled = 0u;
uint32_t preinitializeRelaxedOrderingSectionsCalled = 0;
uint32_t dispatchStaticRelaxedOrderingSchedulerCalled = 0;
uint32_t dispatchRelaxedOrderingSchedulerSectionCalled = 0;

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

@ -112,8 +112,6 @@ DirectSubmissionSemaphorePlacement = -1
DirectSubmissionBufferAddressing = -1
DirectSubmissionSemaphoreAddressing = -1
DirectSubmissionDisableCpuCacheFlush = -1
DirectSubmissionEnableDebugBuffer = 0
DirectSubmissionDiagnosticExecutionCount = 30
DirectSubmissionNewResourceTlbFlush = -1
DirectSubmissionDisableCacheFlush = -1
DirectSubmissionPCIBarrier = -1

384
shared/test/unit_test/direct_submission/direct_submission_tests_1.cpp
View File

@ -26,7 +26,6 @@
#include "shared/test/common/mocks/mock_io_functions.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/unit_test/fixtures/direct_submission_fixture.h"
#include "shared/test/unit_test/mocks/mock_direct_submission_diagnostic_collector.h"
using DirectSubmissionTest = Test<DirectSubmissionFixture>;
@ -533,35 +532,6 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenGetDispatchSizeThenExpec
EXPECT_EQ(expectedSize, actualSize);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionEnableDebugBufferModeOneWhenGetDispatchSizeThenExpectCorrectSizeReturned) {
using Dispatcher = RenderDispatcher<FamilyType>;
DebugManagerStateRestore restorer;
debugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
directSubmission.workloadMode = 1;
size_t expectedSize = Dispatcher::getSizeStoreDwordCommand() +
Dispatcher::getSizeCacheFlush(directSubmission.rootDeviceEnvironment) +
directSubmission.getSizeSemaphoreSection(false) + directSubmission.getSizeNewResourceHandler();
size_t actualSize = directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false));
EXPECT_EQ(expectedSize, actualSize);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionEnableDebugBufferModeTwoWhenGetDispatchSizeThenExpectCorrectSizeReturned) {
DebugManagerStateRestore restorer;
debugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
directSubmission.workloadMode = 2;
size_t expectedSize = Dispatcher::getSizeCacheFlush(directSubmission.rootDeviceEnvironment) +
directSubmission.getSizeSemaphoreSection(false) + directSubmission.getSizeNewResourceHandler();
size_t actualSize = directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false));
EXPECT_EQ(expectedSize, actualSize);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDisableCacheFlushWhenGetDispatchSizeThenExpectCorrectSizeReturned) {
using Dispatcher = RenderDispatcher<FamilyType>;
@ -759,360 +729,6 @@ HWTEST_F(DirectSubmissionTest, givenDebugFlagSetWhenProgrammingEndingCommandThen
cmdStream.replaceGraphicsAllocation(nullptr);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticNotAvailableWhenDiagnosticRegistryIsUsedThenDoNotEnableDiagnostic) {
using Dispatcher = RenderDispatcher<FamilyType>;
if (NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionEnableDebugBuffer.set(1);
debugManager.flags.DirectSubmissionDisableCacheFlush.set(true);
debugManager.flags.DirectSubmissionDisableMonitorFence.set(true);
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_TRUE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(0u, directSubmission.workloadMode);
EXPECT_EQ(nullptr, directSubmission.diagnostic.get());
bool ret = directSubmission.initialize(false);
EXPECT_TRUE(ret);
EXPECT_FALSE(directSubmission.ringStart);
EXPECT_EQ(0u, directSubmission.disabledDiagnosticCalled);
EXPECT_EQ(0u, directSubmission.ringCommandStream.getUsed());
EXPECT_EQ(0u, NEO::IoFunctions::mockFopenCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockFcloseCalled);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticNotAvailableWhenDiagnosticRegistryIsUsedThenDoNotEnableDiagnosticStartOnlyWithSemaphore) {
using Dispatcher = RenderDispatcher<FamilyType>;
if (NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
auto &compilerProductHelper = pDevice->getCompilerProductHelper();
auto heaplessStateInit = compilerProductHelper.isHeaplessStateInitEnabled(compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo));
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionEnableDebugBuffer.set(1);
debugManager.flags.DirectSubmissionDisableCacheFlush.set(true);
debugManager.flags.DirectSubmissionDisableMonitorFence.set(true);
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_TRUE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(0u, directSubmission.workloadMode);
EXPECT_EQ(nullptr, directSubmission.diagnostic.get());
bool ret = directSubmission.initialize(true);
EXPECT_TRUE(ret);
EXPECT_TRUE(directSubmission.ringStart);
EXPECT_EQ(1u, directSubmission.disabledDiagnosticCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockFopenCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockFcloseCalled);
size_t expectedSize = Dispatcher::getSizePreemption() +
directSubmission.getSizeSemaphoreSection(false);
if (directSubmission.globalFenceAllocation && !heaplessStateInit) {
expectedSize += directSubmission.getSizeSystemMemoryFenceAddress();
}
if (directSubmission.isRelaxedOrderingEnabled()) {
expectedSize += RelaxedOrderingHelper::getSizeReturnPtrRegs<FamilyType>();
}
EXPECT_EQ(expectedSize, directSubmission.ringCommandStream.getUsed());
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticAvailableWhenDiagnosticRegistryIsNotUsedThenDoNotEnableDiagnostic) {
using Dispatcher = RenderDispatcher<FamilyType>;
if (!NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionDisableCacheFlush.set(true);
debugManager.flags.DirectSubmissionDisableMonitorFence.set(true);
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_TRUE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(0u, directSubmission.workloadMode);
EXPECT_EQ(nullptr, directSubmission.diagnostic.get());
bool ret = directSubmission.initialize(false);
EXPECT_TRUE(ret);
EXPECT_FALSE(directSubmission.ringStart);
EXPECT_EQ(0u, directSubmission.disabledDiagnosticCalled);
EXPECT_EQ(0u, directSubmission.ringCommandStream.getUsed());
EXPECT_EQ(0u, NEO::IoFunctions::mockFopenCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockFcloseCalled);
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticAvailableWhenDiagnosticRegistryUsedThenDoPerformDiagnosticRun) {
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
using COMPARE_OPERATION = typename FamilyType::MI_SEMAPHORE_WAIT::COMPARE_OPERATION;
using WAIT_MODE = typename FamilyType::MI_SEMAPHORE_WAIT::WAIT_MODE;
using Dispatcher = RenderDispatcher<FamilyType>;
if (!NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
auto &compilerProductHelper = pDevice->getCompilerProductHelper();
auto heaplessStateInit = compilerProductHelper.isHeaplessStateInitEnabled(compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo));
uint32_t execCount = 5u;
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionEnableDebugBuffer.set(1);
debugManager.flags.DirectSubmissionDisableCacheFlush.set(true);
debugManager.flags.DirectSubmissionDisableMonitorFence.set(true);
debugManager.flags.DirectSubmissionDiagnosticExecutionCount.set(static_cast<int32_t>(execCount));
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount;
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_TRUE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(1u, directSubmission.workloadMode);
ASSERT_NE(nullptr, directSubmission.diagnostic.get());
uint32_t expectedExecCount = 5u;
expectedSemaphoreValue += expectedExecCount;
EXPECT_EQ(expectedExecCount, directSubmission.diagnostic->getExecutionsCount());
size_t expectedSize = Dispatcher::getSizePreemption() +
directSubmission.getSizeSemaphoreSection(false) +
directSubmission.getDiagnosticModeSection();
expectedSize += expectedExecCount * (directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false)) - directSubmission.getSizeNewResourceHandler());
if (directSubmission.globalFenceAllocation && !heaplessStateInit) {
expectedSize += directSubmission.getSizeSystemMemoryFenceAddress();
}
if (directSubmission.isRelaxedOrderingEnabled()) {
expectedSize += RelaxedOrderingHelper::getSizeRegistersInit<FamilyType>();
}
bool ret = directSubmission.initialize(false);
EXPECT_TRUE(ret);
EXPECT_TRUE(directSubmission.ringStart);
EXPECT_EQ(0u, directSubmission.disabledDiagnosticCalled);
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
// 1 - preamble, 1 - init time, 5 - exec logs
EXPECT_EQ(7u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(1u, NEO::IoFunctions::mockFcloseCalled);
EXPECT_EQ(expectedSize, directSubmission.ringCommandStream.getUsed());
EXPECT_EQ(expectedSemaphoreValue, directSubmission.currentQueueWorkCount);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(0u, directSubmission.workloadMode);
EXPECT_EQ(nullptr, directSubmission.diagnostic.get());
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, 0);
GenCmdList storeDataCmdList = hwParse.getCommandsList<MI_STORE_DATA_IMM>();
execCount += 1;
ASSERT_EQ(execCount, storeDataCmdList.size());
uint64_t expectedStoreAddress = directSubmission.semaphoreGpuVa;
expectedStoreAddress += ptrDiff(directSubmission.workloadModeOneStoreAddress, directSubmission.semaphorePtr);
uint32_t expectedData = 1u;
for (auto &storeCmdData : storeDataCmdList) {
MI_STORE_DATA_IMM *storeCmd = static_cast<MI_STORE_DATA_IMM *>(storeCmdData);
auto storeData = storeCmd->getDataDword0();
EXPECT_EQ(expectedData, storeData);
expectedData++;
EXPECT_EQ(expectedStoreAddress, storeCmd->getAddress());
}
size_t cmdOffset = 0;
if (directSubmission.globalFenceAllocation && !heaplessStateInit) {
cmdOffset = directSubmission.getSizeSystemMemoryFenceAddress();
}
if (directSubmission.isRelaxedOrderingEnabled()) {
cmdOffset += RelaxedOrderingHelper::getSizeRegistersInit<FamilyType>();
}
uint8_t *cmdBufferPosition = static_cast<uint8_t *>(directSubmission.ringCommandStream.getCpuBase()) + Dispatcher::getSizePreemption() + cmdOffset;
MI_STORE_DATA_IMM *storeDataCmdAtPosition = genCmdCast<MI_STORE_DATA_IMM *>(cmdBufferPosition);
ASSERT_NE(nullptr, storeDataCmdAtPosition);
EXPECT_EQ(1u, storeDataCmdAtPosition->getDataDword0());
EXPECT_EQ(expectedStoreAddress, storeDataCmdAtPosition->getAddress());
cmdBufferPosition += sizeof(MI_STORE_DATA_IMM);
auto &productHelper = pDevice->getProductHelper();
if (productHelper.isPrefetcherDisablingInDirectSubmissionRequired()) {
cmdBufferPosition += directSubmission.getSizeDisablePrefetcher();
}
MI_SEMAPHORE_WAIT *semaphoreWaitCmdAtPosition = genCmdCast<MI_SEMAPHORE_WAIT *>(cmdBufferPosition);
ASSERT_NE(nullptr, semaphoreWaitCmdAtPosition);
EXPECT_EQ(COMPARE_OPERATION::COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD,
semaphoreWaitCmdAtPosition->getCompareOperation());
EXPECT_EQ(1u, semaphoreWaitCmdAtPosition->getSemaphoreDataDword());
EXPECT_EQ(directSubmission.semaphoreGpuVa, semaphoreWaitCmdAtPosition->getSemaphoreGraphicsAddress());
EXPECT_EQ(WAIT_MODE::WAIT_MODE_POLLING_MODE, semaphoreWaitCmdAtPosition->getWaitMode());
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticAvailableWhenDiagnosticRegistryModeTwoUsedThenDoPerformDiagnosticRunWithoutRoundtripMeasures) {
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
using Dispatcher = RenderDispatcher<FamilyType>;
if (!NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
auto &compilerProductHelper = pDevice->getCompilerProductHelper();
auto heaplessStateInit = compilerProductHelper.isHeaplessStateInitEnabled(compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo));
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionEnableDebugBuffer.set(2);
debugManager.flags.DirectSubmissionDisableCacheFlush.set(true);
debugManager.flags.DirectSubmissionDisableMonitorFence.set(true);
debugManager.flags.DirectSubmissionDiagnosticExecutionCount.set(5);
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount;
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_TRUE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(2u, directSubmission.workloadMode);
ASSERT_NE(nullptr, directSubmission.diagnostic.get());
uint32_t expectedExecCount = 5u;
expectedSemaphoreValue += expectedExecCount;
EXPECT_EQ(expectedExecCount, directSubmission.diagnostic->getExecutionsCount());
size_t expectedSize = Dispatcher::getSizePreemption() +
directSubmission.getSizeSemaphoreSection(false);
size_t expectedDispatch = directSubmission.getSizeSemaphoreSection(false);
EXPECT_EQ(expectedDispatch, directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false)) - directSubmission.getSizeNewResourceHandler());
expectedSize += expectedExecCount * expectedDispatch;
if (directSubmission.globalFenceAllocation && !heaplessStateInit) {
expectedSize += directSubmission.getSizeSystemMemoryFenceAddress();
}
if (directSubmission.isRelaxedOrderingEnabled()) {
expectedSize += RelaxedOrderingHelper::getSizeReturnPtrRegs<FamilyType>();
}
bool ret = directSubmission.initialize(false);
EXPECT_TRUE(ret);
EXPECT_TRUE(directSubmission.ringStart);
EXPECT_EQ(0u, directSubmission.disabledDiagnosticCalled);
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
// 1 - preamble, 1 - init time, 0 exec logs in mode 2
EXPECT_EQ(2u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(1u, NEO::IoFunctions::mockFcloseCalled);
EXPECT_EQ(expectedSize, directSubmission.ringCommandStream.getUsed());
EXPECT_EQ(expectedSemaphoreValue, directSubmission.currentQueueWorkCount);
EXPECT_TRUE(directSubmission.disableCacheFlush);
EXPECT_TRUE(directSubmission.disableMonitorFence);
EXPECT_EQ(0u, directSubmission.workloadMode);
EXPECT_EQ(nullptr, directSubmission.diagnostic.get());
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, 0);
GenCmdList storeDataCmdList = hwParse.getCommandsList<MI_STORE_DATA_IMM>();
EXPECT_EQ(0u, storeDataCmdList.size());
}
HWTEST_F(DirectSubmissionTest,
givenDirectSubmissionDiagnosticAvailableWhenLoggingTimeStampsThenExpectStoredTimeStampsAvailable) {
using Dispatcher = RenderDispatcher<FamilyType>;
if (!NEO::directSubmissionDiagnosticAvailable) {
GTEST_SKIP();
}
uint32_t executions = 2;
int32_t workloadMode = 1;
DebugManagerStateRestore restore;
debugManager.flags.DirectSubmissionEnableDebugBuffer.set(workloadMode);
debugManager.flags.DirectSubmissionDiagnosticExecutionCount.set(static_cast<int32_t>(executions));
NEO::IoFunctions::mockFopenCalled = 0u;
NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
EXPECT_NE(nullptr, directSubmission.diagnostic.get());
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
// ctor: preamble 1 call
EXPECT_EQ(1u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(0u, NEO::IoFunctions::mockFcloseCalled);
directSubmission.diagnostic = std::make_unique<MockDirectSubmissionDiagnosticsCollector>(
executions,
true,
debugManager.flags.DirectSubmissionBufferPlacement.get(),
debugManager.flags.DirectSubmissionSemaphorePlacement.get(),
workloadMode,
debugManager.flags.DirectSubmissionDisableCacheFlush.get(),
debugManager.flags.DirectSubmissionDisableMonitorFence.get());
EXPECT_EQ(2u, NEO::IoFunctions::mockFopenCalled);
// dtor: 1 call general delta, 2 calls storing execution, ctor: preamble 1 call
EXPECT_EQ(5u, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(1u, NEO::IoFunctions::mockFcloseCalled);
bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret);
ASSERT_NE(nullptr, directSubmission.workloadModeOneStoreAddress);
directSubmission.diagnostic->diagnosticModeOneWaitCollect(0, directSubmission.workloadModeOneStoreAddress, directSubmission.workloadModeOneExpectedValue);
auto mockDiagnostic = reinterpret_cast<MockDirectSubmissionDiagnosticsCollector *>(directSubmission.diagnostic.get());
EXPECT_NE(0ll, mockDiagnostic->executionList[0].totalTimeDiff);
EXPECT_NE(0ll, mockDiagnostic->executionList[0].submitWaitTimeDiff);
EXPECT_EQ(0ll, mockDiagnostic->executionList[0].dispatchSubmitTimeDiff);
directSubmission.diagnostic->diagnosticModeOneWaitCollect(1, directSubmission.workloadModeOneStoreAddress, directSubmission.workloadModeOneExpectedValue);
EXPECT_NE(0ll, mockDiagnostic->executionList[1].totalTimeDiff);
EXPECT_NE(0ll, mockDiagnostic->executionList[1].submitWaitTimeDiff);
EXPECT_EQ(0ll, mockDiagnostic->executionList[1].dispatchSubmitTimeDiff);
// 1 call general delta, 2 calls storing execution
uint32_t expectedVfprintfCall = NEO::IoFunctions::mockVfptrinfCalled + 1u + 2u;
directSubmission.diagnostic.reset(nullptr);
EXPECT_EQ(2u, NEO::IoFunctions::mockFopenCalled);
EXPECT_EQ(expectedVfprintfCall, NEO::IoFunctions::mockVfptrinfCalled);
EXPECT_EQ(2u, NEO::IoFunctions::mockFcloseCalled);
}
HWCMDTEST_F(IGFX_GEN12LP_CORE, DirectSubmissionTest,
givenLegacyPlatformsWhenProgrammingPartitionRegisterThenExpectNoAction) {
using Dispatcher = RenderDispatcher<FamilyType>;

83
shared/test/unit_test/direct_submission/direct_submission_tests_2.cpp
View File

@ -33,7 +33,6 @@
#include "shared/test/common/mocks/mock_io_functions.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/unit_test/fixtures/direct_submission_fixture.h"
#include "shared/test/unit_test/mocks/mock_direct_submission_diagnostic_collector.h"
namespace CpuIntrinsicsTests {
extern std::atomic<uint32_t> sfenceCounter;
@ -549,88 +548,6 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
EXPECT_FALSE(foundFlush);
}
HWTEST_F(DirectSubmissionDispatchBufferTest,
givenDirectSubmissionDebugBufferModeOneWhenDispatchWorkloadCalledThenExpectNoStartAndLoadDataImm) {
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(false, false, regularDirectSubmission.dispatchMonitorFenceRequired(false));
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
directSubmission.workloadMode = 1;
bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret);
size_t startSize = directSubmission.getSizeStartSection();
size_t storeDataSize = Dispatcher::getSizeStoreDwordCommand();
size_t debugSizeDispatch = directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false));
EXPECT_EQ(debugSizeDispatch, (regularSizeDispatch - startSize + storeDataSize));
directSubmission.workloadModeOneExpectedValue = 0x40u;
directSubmission.semaphoreGpuVa = 0xAFF0000;
directSubmission.dispatchWorkloadSection(batchBuffer, directSubmission.dispatchMonitorFenceRequired(batchBuffer.hasStallingCmds));
size_t expectedDispatchSize = debugSizeDispatch - directSubmission.getSizeNewResourceHandler();
EXPECT_EQ(expectedDispatchSize, directSubmission.ringCommandStream.getUsed());
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, 0);
if (directSubmission.getSizePrefetchMitigation() == sizeof(MI_BATCH_BUFFER_START)) {
EXPECT_EQ(1u, hwParse.getCommandCount<MI_BATCH_BUFFER_START>());
} else {
EXPECT_EQ(0u, hwParse.getCommandCount<MI_BATCH_BUFFER_START>());
}
MI_STORE_DATA_IMM *storeData = hwParse.getCommand<MI_STORE_DATA_IMM>();
ASSERT_NE(nullptr, storeData);
EXPECT_EQ(0x40u + 1u, storeData->getDataDword0());
uint64_t expectedGpuVa = directSubmission.semaphoreGpuVa;
auto semaphore = static_cast<RingSemaphoreData *>(directSubmission.semaphorePtr);
expectedGpuVa += ptrDiff(&semaphore->diagnosticModeCounter, directSubmission.semaphorePtr);
EXPECT_EQ(expectedGpuVa, storeData->getAddress());
}
HWTEST_F(DirectSubmissionDispatchBufferTest,
givenDirectSubmissionDebugBufferModeTwoWhenDispatchWorkloadCalledThenExpectNoStartAndNoLoadDataImm) {
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> regularDirectSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(false, false, regularDirectSubmission.dispatchMonitorFenceRequired(false));
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice->getDefaultEngine().commandStreamReceiver);
directSubmission.workloadMode = 2;
bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret);
size_t startSize = directSubmission.getSizeStartSection();
size_t debugSizeDispatch = directSubmission.getSizeDispatch(false, false, directSubmission.dispatchMonitorFenceRequired(false));
EXPECT_EQ(debugSizeDispatch, (regularSizeDispatch - startSize));
directSubmission.currentQueueWorkCount = 0x40u;
directSubmission.dispatchWorkloadSection(batchBuffer, directSubmission.dispatchMonitorFenceRequired(batchBuffer.dispatchMonitorFence));
size_t expectedDispatchSize = debugSizeDispatch - directSubmission.getSizeNewResourceHandler();
EXPECT_EQ(expectedDispatchSize, directSubmission.ringCommandStream.getUsed());
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, 0);
if (directSubmission.getSizePrefetchMitigation() == sizeof(MI_BATCH_BUFFER_START)) {
EXPECT_EQ(1u, hwParse.getCommandCount<MI_BATCH_BUFFER_START>());
} else {
EXPECT_EQ(0u, hwParse.getCommandCount<MI_BATCH_BUFFER_START>());
}
MI_STORE_DATA_IMM *storeData = hwParse.getCommand<MI_STORE_DATA_IMM>();
EXPECT_EQ(nullptr, storeData);
}
HWTEST_F(DirectSubmissionDispatchBufferTest,
givenDirectSubmissionRingStartAndSwitchBuffersWhenDispatchingCommandBufferThenExpectDispatchInCommandBufferAndQueueCountIncrease) {
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;

3
shared/test/unit_test/mocks/CMakeLists.txt
View File

@ -1,5 +1,5 @@
#
# Copyright (C) 2021-2024 Intel Corporation
# Copyright (C) 2021-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -10,7 +10,6 @@ target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/mock_cpuid_functions.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_cpuid_functions.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_csr_simulated_common_hw.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_direct_submission_diagnostic_collector.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_dispatch_kernel_encoder_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_lrca_helper.h

20
shared/test/unit_test/mocks/mock_direct_submission_diagnostic_collector.h
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/direct_submission/direct_submission_hw_diagnostic_mode.h"
namespace NEO {
struct MockDirectSubmissionDiagnosticsCollector : public DirectSubmissionDiagnosticsCollector {
using BaseClass = DirectSubmissionDiagnosticsCollector;
using BaseClass::DirectSubmissionDiagnosticsCollector;
using BaseClass::executionList;
};
} // namespace NEO