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

fix: Add texture cache flush after kernels writing to images on imm cmdlists

Browse Source 
- add `hasImageWriteArg` flag to KernelDescriptor,
based on image access qualifier
- add `isPostImageWriteFlushRequired` method to productHelper,
to require cache flush only on selected platforms
- if possible, add the `textureCacheInvalidationEnable` arg to the
existing PC, otherwise add a new PC

Related-To: NEO-13427, HSD-18041321008
Signed-off-by: Fabian Zwoliński <fabian.zwolinski@intel.com>
This commit is contained in:
Fabian Zwoliński
2025-04-16 18:34:28 +00:00
committed by Compute-Runtime-Automation
parent 5a2a792c34
commit ee769f5983
19 changed files with 187 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@@ -195,7 +195,7 @@ struct CommandListCoreFamily : public CommandListImp {
void appendWaitOnInOrderDependency(std::shared_ptr<NEO::InOrderExecInfo> &inOrderExecInfo, CommandToPatchContainer *outListCommands,
uint64_t waitValue, uint32_t offset, bool relaxedOrderingAllowed, bool implicitDependency,
bool skipAddingWaitEventsToResidency, bool noopDispatch, bool copyOffloadOperation);
void appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall);
void appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall, bool textureFlushRequired);
void handleInOrderDependencyCounter(Event *signalEvent, bool nonWalkerInOrderCmdsChaining, bool copyOffloadOperation);
void handleInOrderCounterOverflow(bool copyOffloadOperation);

31
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -207,7 +207,7 @@ void CommandListCoreFamily<gfxCoreFamily>::handleInOrderCounterOverflow(bool cop
inOrderExecInfo->setAllocationOffset(newOffset);
inOrderExecInfo->initializeAllocationsFromHost();
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false); // signal counter on new offset
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false, false); // signal counter on new offset
}
}
@@ -597,7 +597,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_hand
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(event, false, false);
appendSignalInOrderDependencyCounter(event, false, false, false);
}
handleInOrderDependencyCounter(event, false, false);
event->unsetInOrderExecInfo();
@@ -645,7 +645,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryRangesBarrier(uint
addToMappedEventList(signalEvent);
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -1530,7 +1530,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendCopyImageBlit(NEO::Graph
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, true);
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -1792,7 +1792,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopy(void *dstptr,
if (launchParams.isKernelSplitOperation || inOrderCopyOnlySignalingAllowed || emitPipeControl) {
dispatchInOrderPostOperationBarrier(signalEvent, dcFlush, isCopyOnlyEnabled);
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false);
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false, false);
}
if (!isCopyOnlyEnabled || inOrderCopyOnlySignalingAllowed) {
@@ -1897,7 +1897,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopyRegion(void *d
if (this->isInOrderExecutionEnabled()) {
if (inOrderCopyOnlySignalingAllowed) {
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false);
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false, false);
handleInOrderDependencyCounter(signalEvent, false, isCopyOnlyEnabled);
}
} else {
@@ -2368,7 +2368,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryFill(void *ptr,
if (this->isInOrderExecutionEnabled()) {
if (launchParams.isKernelSplitOperation) {
dispatchInOrderPostOperationBarrier(signalEvent, dcFlush, isCopyOnly(false));
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
} else {
nonWalkerInOrderCmdChaining = isInOrderNonWalkerSignalingRequired(signalEvent);
}
@@ -2440,7 +2440,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendBlitFill(void *ptr,
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, true);
if (isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
}
@@ -2687,7 +2687,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(event, false, false);
appendSignalInOrderDependencyCounter(event, false, false, false);
}
handleInOrderDependencyCounter(event, false, false);
@@ -2922,7 +2922,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
if (apiRequest) {
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false);
appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false, false);
}
handleInOrderDependencyCounter(nullptr, false, copyOffloadOperation);
}
@@ -2965,7 +2965,7 @@ void CommandListCoreFamily<gfxCoreFamily>::appendSdiInOrderCounterSignalling(uin
}
template <GFXCORE_FAMILY gfxCoreFamily>
void CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall) {
void CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall, bool textureFlushRequired) {
using ATOMIC_OPCODES = typename GfxFamily::MI_ATOMIC::ATOMIC_OPCODES;
using DATA_SIZE = typename GfxFamily::MI_ATOMIC::DATA_SIZE;
@@ -2978,6 +2978,7 @@ void CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(
NEO::PipeControlArgs args;
args.dcFlushEnable = true;
args.workloadPartitionOffset = partitionCount > 1;
args.textureCacheInvalidationEnable = textureFlushRequired;
NEO::MemorySynchronizationCommands<GfxFamily>::addBarrierWithPostSyncOperation(
*cmdStream,
@@ -3210,7 +3211,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWriteGlobalTimestamp(
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, isCopyOnly(false));
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -3795,7 +3796,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendBarrier(ze_event_handle_
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, this->isInOrderExecutionEnabled(), false, isCopyOnly(false));
if (isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -3966,7 +3967,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnMemory(void *desc,
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, isCopyOnly(false));
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -4013,7 +4014,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWriteToMemory(void *desc
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(nullptr, false, false);
appendSignalInOrderDependencyCounter(nullptr, false, false, false);
}
handleInOrderDependencyCounter(nullptr, false, false);

5
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@@ -615,7 +615,7 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleInOrderNonWalkerSignal
}
CommandListCoreFamily<gfxCoreFamily>::appendWaitOnSingleEvent(event, nullptr, nonWalkerSignalingHasRelaxedOrdering, false, CommandToPatch::Invalid);
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(event, false, false);
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(event, false, false, false);
}
template <GFXCORE_FAMILY gfxCoreFamily>
@@ -1326,7 +1326,7 @@ template <GFXCORE_FAMILY gfxCoreFamily>
ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::flushInOrderCounterSignal(bool waitOnInOrderCounterRequired) {
ze_result_t ret = ZE_RESULT_SUCCESS;
if (waitOnInOrderCounterRequired && !this->isHeaplessModeEnabled() && this->latestOperationHasOptimizedCbEvent) {
this->appendSignalInOrderDependencyCounter(nullptr, false, true);
this->appendSignalInOrderDependencyCounter(nullptr, false, true, false);
this->inOrderExecInfo->addCounterValue(this->getInOrderIncrementValue());
this->handleInOrderCounterOverflow(false);
ret = flushImmediate(ret, false, true, false, NEO::AppendOperations::nonKernel, false, nullptr, false, nullptr, nullptr);
@@ -1808,6 +1808,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendCommandLists(ui
copyEngineExecution);
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(signalEvent,
copyOffloadOperation,
false,
false);
}

2
level_zero/core/source/cmdlist/cmdlist_hw_skl_to_tgllp.inl
View File

@@ -304,7 +304,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
appendSignalInOrderDependencyCounter(event, false, false);
appendSignalInOrderDependencyCounter(event, false, false, false);
}
return ZE_RESULT_SUCCESS;

16
level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl
View File

@@ -67,6 +67,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
NEO::PipeControlArgs args;
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
NEO::Device *neoDevice = device->getNEODevice();
const auto deviceHandle = static_cast<DriverHandleImp *>(device->getDriverHandle());
@@ -458,6 +459,10 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
}
}
bool textureFlushRequired = this->device->getProductHelper().isPostImageWriteFlushRequired() &&
this->isImmediateType() &&
kernelInfo->kernelDescriptor.kernelAttributes.hasImageWriteArg;
if (inOrderExecSignalRequired) {
if (inOrderNonWalkerSignalling) {
if (!launchParams.skipInOrderNonWalkerSignaling) {
@@ -465,11 +470,12 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
if (compactEvent && (compactEvent->isCounterBased() && !this->asMutable())) {
auto pcCmdPtr = this->commandContainer.getCommandStream()->getSpace(0u);
inOrderCounterValue = this->inOrderExecInfo->getCounterValue() + getInOrderIncrementValue();
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, true);
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, true, textureFlushRequired);
addCmdForPatching(nullptr, pcCmdPtr, nullptr, inOrderCounterValue, NEO::InOrderPatchCommandHelpers::PatchCmdType::pipeControl);
textureFlushRequired = false;
} else {
appendWaitOnSingleEvent(eventForInOrderExec, launchParams.outListCommands, false, false, CommandToPatch::CbEventTimestampPostSyncSemaphoreWait);
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, false);
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, false, false);
}
} else {
this->latestOperationHasOptimizedCbEvent = true;
@@ -484,6 +490,12 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
launchParams.skipInOrderNonWalkerSignaling = false;
}
if (textureFlushRequired) {
NEO::PipeControlArgs args;
args.textureCacheInvalidationEnable = true;
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
if (neoDevice->getDebugger() && !this->immediateCmdListHeapSharing && !neoDevice->getBindlessHeapsHelper() && this->cmdListHeapAddressModel == NEO::HeapAddressModel::privateHeaps) {
auto *ssh = commandContainer.getIndirectHeap(NEO::HeapType::surfaceState);
auto surfaceStateSpace = neoDevice->getDebugger()->getDebugSurfaceReservedSurfaceState(*ssh);

2
level_zero/core/source/device/bcs_split.h
View File

@@ -143,7 +143,7 @@ struct BcsSplit {
cmdList->appendEventForProfilingAllWalkers(this->events.marker[markerEventIndex], nullptr, nullptr, false, true, false, true);
if (cmdList->isInOrderExecutionEnabled()) {
cmdList->appendSignalInOrderDependencyCounter(signalEvent, false, false);
cmdList->appendSignalInOrderDependencyCounter(signalEvent, false, false, false);
}
cmdList->handleInOrderDependencyCounter(signalEvent, false, false);

45
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
View File

@@ -1501,6 +1501,51 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenImmediateCommandListWhenAppendLaun
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
}
HWTEST_F(CommandListAppendLaunchKernel, GivenImmCmdListAndKernelWithImageWriteArgAndPlatformRequiresFlushWhenLaunchingKernelThenPipeControlWithTextureCacheInvalidationIsAdded) {
if (!device->getProductHelper().isPostImageWriteFlushRequired()) {
GTEST_SKIP();
}
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
auto kernel = std::make_unique<Mock<KernelImp>>();
kernel->module = module.get();
kernel->immutableData.kernelInfo->kernelDescriptor.kernelAttributes.hasImageWriteArg = true;
ze_command_queue_desc_t queueDesc = {};
auto queue = std::make_unique<Mock<CommandQueue>>(device, device->getNEODevice()->getDefaultEngine().commandStreamReceiver, &queueDesc);
MockCommandListImmediateHw<FamilyType::gfxCoreFamily> commandList;
commandList.isFlushTaskSubmissionEnabled = false;
commandList.cmdListType = CommandList::CommandListType::typeImmediate;
commandList.cmdQImmediate = queue.get();
commandList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
commandList.commandContainer.setImmediateCmdListCsr(device->getNEODevice()->getDefaultEngine().commandStreamReceiver);
auto usedSpaceBefore = commandList.getCmdContainer().getCommandStream()->getUsed();
ze_group_count_t groupCount{1, 1, 1};
ze_result_t returnValue;
CmdListKernelLaunchParams launchParams = {};
returnValue = commandList.appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false);
EXPECT_EQ(1u, commandList.executeCommandListImmediateCalledCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
auto usedSpaceAfter = commandList.getCmdContainer().getCommandStream()->getUsed();
EXPECT_GT(usedSpaceAfter, usedSpaceBefore);
GenCmdList cmdList;
EXPECT_TRUE(FamilyType::Parse::parseCommandBuffer(
cmdList, ptrOffset(commandList.getCmdContainer().getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
auto itorPC = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(0u, itorPC.size());
PIPE_CONTROL *cmd = genCmdCast<PIPE_CONTROL *>(*itorPC[itorPC.size() - 1]);
EXPECT_TRUE(cmd->getTextureCacheInvalidationEnable());
}
template <GFXCORE_FAMILY gfxCoreFamily>
struct MockCommandListCoreFamilyWithoutHeapSupport : public WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>> {
using BaseClass = WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>;

6
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_1.cpp
View File

@@ -2672,6 +2672,10 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, InOrderCmdListTests, givenInOrderModeWhenProgrammin
address |= pcCmd->getAddress();
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress() + counterOffset, address);
EXPECT_EQ(2u, pcCmd->getImmediateData());
const bool textureFlushRequired = device->getProductHelper().isPostImageWriteFlushRequired() &&
kernel->kernelImmData->getKernelInfo()->kernelDescriptor.kernelAttributes.hasImageWriteArg;
EXPECT_EQ(textureFlushRequired, pcCmd->getTextureCacheInvalidationEnable());
} else {
if (!immCmdList->inOrderExecInfo->isAtomicDeviceSignalling()) {
EXPECT_EQ(PostSyncType::OPERATION::OPERATION_WRITE_IMMEDIATE_DATA, postSync.getOperation());
@@ -5737,7 +5741,7 @@ HWTEST_F(InOrderCmdListTests, givenExternalSyncStorageWhenCallingAppendSignalInO
auto cmdStream = immCmdList->getCmdContainer().getCommandStream();
immCmdList->inOrderAtomicSignalingEnabled = false;
immCmdList->appendSignalInOrderDependencyCounter(eventObj.get(), false, false);
immCmdList->appendSignalInOrderDependencyCounter(eventObj.get(), false, false, false);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(cmdList, cmdStream->getCpuBase(), cmdStream->getUsed()));

2
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_2.cpp
View File

@@ -3154,7 +3154,7 @@ HWTEST2_F(MultiTileInOrderCmdListTests, givenMultiTileInOrderModeWhenSignalingSy
auto cmdStream = immCmdList->getCmdContainer().getCommandStream();
immCmdList->inOrderAtomicSignalingEnabled = false;
immCmdList->appendSignalInOrderDependencyCounter(nullptr, false, false);
immCmdList->appendSignalInOrderDependencyCounter(nullptr, false, false, false);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(cmdList, cmdStream->getCpuBase(), cmdStream->getUsed()));

7
shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
View File

@@ -1050,6 +1050,13 @@ DecodeError decodeZeInfoKernelPayloadArguments(KernelDescriptor &dst, Yaml::Yaml
bindfulImageAccess = true;
}
}
if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::argTImage>()) {
if (dst.payloadMappings.explicitArgs[arg.argIndex].getTraits().getAccessQualifier() == NEO::KernelArgMetadata::AccessQualifier::AccessWriteOnly ||
dst.payloadMappings.explicitArgs[arg.argIndex].getTraits().getAccessQualifier() == NEO::KernelArgMetadata::AccessQualifier::AccessReadWrite) {
dst.kernelAttributes.hasImageWriteArg = true;
}
}
}
const auto implicitArgsVec = dst.getImplicitArgBindlessCandidatesVec();

1
shared/source/kernel/kernel_descriptor.h
View File

@@ -86,6 +86,7 @@ struct KernelDescriptor : NEO::NonCopyableAndNonMovableClass {
bool hasNonKernelArgAtomic = false;
bool hasIndirectStatelessAccess = false;
bool hasIndirectAccessInImplicitArg = false;
bool hasImageWriteArg = false;
AddressingMode bufferAddressingMode = BindfulAndStateless;
AddressingMode imageAddressingMode = Bindful;

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

@@ -201,6 +201,7 @@ class ProductHelper {
virtual uint32_t getInternalHeapsPreallocated() const = 0;
virtual bool overrideAllocationCacheable(const AllocationData &allocationData) const = 0;
virtual bool is2MBLocalMemAlignmentEnabled() const = 0;
virtual bool isPostImageWriteFlushRequired() const = 0;
virtual bool getFrontEndPropertyScratchSizeSupport() const = 0;
virtual bool getFrontEndPropertyPrivateScratchSizeSupport() const = 0;

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

@@ -226,6 +226,11 @@ bool ProductHelperHw<gfxProduct>::is2MBLocalMemAlignmentEnabled() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isPostImageWriteFlushRequired() const {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isAdditionalStateBaseAddressWARequired(const HardwareInfo &hwInfo) const {
return false;

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

@@ -140,6 +140,7 @@ class ProductHelperHw : public ProductHelper {
uint32_t getInternalHeapsPreallocated() const override;
bool overrideAllocationCacheable(const AllocationData &allocationData) const override;
bool is2MBLocalMemAlignmentEnabled() const override;
bool isPostImageWriteFlushRequired() const override;
bool getFrontEndPropertyScratchSizeSupport() const override;
bool getFrontEndPropertyPrivateScratchSizeSupport() const override;

5
shared/source/xe_hpg_core/os_agnostic_product_helper_xe_hpg_core.inl
View File

@@ -20,4 +20,9 @@ uint32_t ProductHelperHw<gfxProduct>::getMaxThreadsForWorkgroupInDSSOrSS(const H
return getMaxThreadsForWorkgroup(hwInfo, maxNumEUsPerDualSubSlice);
}
template <>
bool ProductHelperHw<gfxProduct>::isPostImageWriteFlushRequired() const {
return true;
}
} // namespace NEO

69
shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
View File

@@ -7093,6 +7093,75 @@ kernels:
ASSERT_EQ(192u, kernelDescriptor->generatedSsh.size());
}
TEST_F(decodeZeInfoKernelEntryTest, GivenImageArgWithReadOnlyAccessWhenPopulatingKernelDescriptorThenHasImageWriteArgIsFalse) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 32
payload_arguments:
- arg_type: arg_bypointer
offset: 24
size: 8
arg_index: 0
addrmode: bindless
addrspace: image
access_type: readonly
image_type: image_2d
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::success, err);
EXPECT_FALSE(kernelDescriptor->kernelAttributes.hasImageWriteArg);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenImageArgWithWriteOnlyAccessWhenPopulatingKernelDescriptorThenHasImageWriteArgIsTrue) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 32
payload_arguments:
- arg_type: arg_bypointer
offset: 32
size: 8
arg_index: 1
addrmode: bindless
addrspace: image
access_type: writeonly
image_type: image_2d
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::success, err);
EXPECT_TRUE(kernelDescriptor->kernelAttributes.hasImageWriteArg);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenImageArgWithReadWriteAccessWhenPopulatingKernelDescriptorThenHasImageWriteArgIsTrue) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 32
payload_arguments:
- arg_type: arg_bypointer
offset: 24
size: 8
arg_index: 0
addrmode: bindless
addrspace: image
access_type: readwrite
image_type: image_2d
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::success, err);
EXPECT_TRUE(kernelDescriptor->kernelAttributes.hasImageWriteArg);
}
TEST(PopulateInlineSamplers, GivenInvalidSamplerIndexThenPopulateInlineSamplersFails) {
NEO::KernelDescriptor kd;
std::string errors, warnings;

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

@@ -1164,3 +1164,7 @@ HWTEST2_F(ProductHelperTest, givenProductHelperThenCompressionIsNotForbidden, Is
auto hwInfo = *defaultHwInfo;
EXPECT_FALSE(productHelper->isCompressionForbidden(hwInfo));
}
HWTEST_F(ProductHelperTest, givenProductHelperWhenQueryIsPostImageWriteFlushRequiredThenFalseReturned) {
EXPECT_FALSE(productHelper->isPostImageWriteFlushRequired());
}

3
shared/test/unit_test/xe_hpg_core/excludes_xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -11,6 +11,7 @@ HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenSamplerStateWhenAdjustSamplerStat
HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedIfBlitterForImagesIsSupportedThenFalseIsReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedIfTile64With3DSurfaceOnBCSIsSupportedThenTrueIsReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenIsSystolicModeConfigurabledThenFalseIsReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenQueryIsPostImageWriteFlushRequiredThenFalseReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(CommandEncodeStatesTest, givenEventAddressWhenEncodeThenMocsFromGmmHelperIsSet, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeCmdSizeWhenLargeGrfModeChangeIsRequiredThenSCMCommandSizeIsCalculated, IGFX_XE_HPG_CORE);

6
shared/test/unit_test/xe_hpg_core/test_product_helper_xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,3 +19,7 @@ using XeHpgProductHelper = ProductHelperTest;
XE_HPG_CORETEST_F(XeHpgProductHelper, givenProductHelperWhenIsSystolicModeConfigurabledThenTrueIsReturned) {
EXPECT_TRUE(productHelper->isSystolicModeConfigurable(pInHwInfo));
}
XE_HPG_CORETEST_F(XeHpgProductHelper, givenProductHelperWhenQueryIsPostImageWriteFlushRequiredThenTrueIsReturned) {
EXPECT_TRUE(productHelper->isPostImageWriteFlushRequired());
}