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

Revert "Change event memory layout for multi tile capable platforms" 

This reverts commit 616dd55789.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation 2022-04-07 07:18:40 +02:00 committed by Compute-Runtime-Automation
parent 5b175ebb4a
commit b88e16252e
23 changed files with 105 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -292,7 +292,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_hand
callId = neoDevice->getRootDeviceEnvironment().tagsManager->currentCallCount;
}
if (event->isUsingContextEndOffset()) {
if (event->useContextEndOffset()) {
baseAddr += event->getContextEndOffset();
}
@ -1641,9 +1641,6 @@ void CommandListCoreFamily<gfxCoreFamily>::appendSignalEventPostWalker(ze_event_
commandContainer.addToResidencyContainer(&event->getAllocation(this->device));
uint64_t baseAddr = event->getGpuAddress(this->device);
if (event->isUsingContextEndOffset()) {
baseAddr += event->getContextEndOffset();
}
const auto &hwInfo = this->device->getHwInfo();
if (isCopyOnly()) {
@ -1657,6 +1654,8 @@ void CommandListCoreFamily<gfxCoreFamily>::appendSignalEventPostWalker(ze_event_
if (this->partitionCount > 1) {
args.workloadPartitionOffset = true;
event->setPacketsInUse(this->partitionCount);
event->setPartitionedEvent(true);
baseAddr += event->getContextEndOffset();
}
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
*commandContainer.getCommandStream(),
@ -1798,8 +1797,11 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
callId = neoDevice->getRootDeviceEnvironment().tagsManager->currentCallCount;
}
size_t eventSignalOffset = 0;
if (event->isUsingContextEndOffset()) {
if (this->partitionCount > 1) {
event->setPartitionedEvent(true);
event->setPacketsInUse(this->partitionCount);
}
if (event->useContextEndOffset()) {
eventSignalOffset = event->getContextEndOffset();
}
@ -1813,10 +1815,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
NEO::PipeControlArgs args;
bool applyScope = event->signalScope;
args.dcFlushEnable = NEO::MemorySynchronizationCommands<GfxFamily>::getDcFlushEnable(applyScope, hwInfo);
if (this->partitionCount > 1) {
event->setPacketsInUse(this->partitionCount);
args.workloadPartitionOffset = true;
}
args.workloadPartitionOffset = event->isPartitionedEvent();
if (applyScope || event->isEventTimestampFlagSet()) {
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
*commandContainer.getCommandStream(),
@ -1893,7 +1892,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
gpuAddr = event->getGpuAddress(this->device);
uint32_t packetsToWait = event->getPacketsInUse();
if (event->isUsingContextEndOffset()) {
if (event->useContextEndOffset()) {
gpuAddr += event->getContextEndOffset();
}
for (uint32_t i = 0u; i < packetsToWait; i++) {

29
level_zero/core/source/cmdlist/cmdlist_hw_base.inl
View File

@ -121,22 +121,21 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
updateStreamProperties(*kernel, false, isCooperative);
NEO::EncodeDispatchKernelArgs dispatchKernelArgs{
0, // eventAddress
neoDevice, // device
kernel, // dispatchInterface
reinterpret_cast<const void *>(pThreadGroupDimensions), // pThreadGroupDimensions
commandListPreemptionMode, // preemptionMode
0, // partitionCount
isIndirect, // isIndirect
isPredicate, // isPredicate
false, // isTimestampEvent
false, // L3FlushEnable
this->containsStatelessUncachedResource, // requiresUncachedMocs
false, // useGlobalAtomics
internalUsage, // isInternal
isCooperative // isCooperative
0, //eventAddress
neoDevice, //device
kernel, //dispatchInterface
reinterpret_cast<const void *>(pThreadGroupDimensions), //pThreadGroupDimensions
commandListPreemptionMode, //preemptionMode
0, //partitionCount
isIndirect, //isIndirect
isPredicate, //isPredicate
false, //isTimestampEvent
false, //L3FlushEnable
this->containsStatelessUncachedResource, //requiresUncachedMocs
false, //useGlobalAtomics
internalUsage, //isInternal
isCooperative //isCooperative
};
NEO::EncodeDispatchKernel<GfxFamily>::encode(commandContainer, dispatchKernelArgs);
this->containsStatelessUncachedResource = dispatchKernelArgs.requiresUncachedMocs;

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

@ -21,7 +21,6 @@
#include "shared/source/xe_hp_core/hw_info.h"
#include "level_zero/core/source/cmdlist/cmdlist_hw.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/source/kernel/kernel_imp.h"
#include "level_zero/core/source/module/module.h"
@ -95,7 +94,7 @@ void programEventL3Flush(ze_event_handle_t hEvent,
auto eventPartitionOffset = (partitionCount > 1) ? (partitionCount * event->getSinglePacketSize())
: event->getSinglePacketSize();
uint64_t eventAddress = event->getPacketAddress(device) + eventPartitionOffset;
if (event->isUsingContextEndOffset()) {
if (event->useContextEndOffset()) {
eventAddress += event->getContextEndOffset();
}
@ -164,7 +163,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
eventAlloc = &event->getAllocation(this->device);
commandContainer.addToResidencyContainer(eventAlloc);
L3FlushEnable = NEO::MemorySynchronizationCommands<GfxFamily>::getDcFlushEnable(event->signalScope, hwInfo);
isTimestampEvent = event->isUsingContextEndOffset();
isTimestampEvent = event->isEventTimestampFlagSet();
eventAddress = event->getPacketAddress(this->device);
}
@ -215,20 +214,20 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
this->requiresQueueUncachedMocs |= kernelImp->getKernelRequiresQueueUncachedMocs();
NEO::EncodeDispatchKernelArgs dispatchKernelArgs{
eventAddress, // eventAddress
neoDevice, // device
kernel, // dispatchInterface
reinterpret_cast<const void *>(pThreadGroupDimensions), // pThreadGroupDimensions
commandListPreemptionMode, // preemptionMode
this->partitionCount, // partitionCount
isIndirect, // isIndirect
isPredicate, // isPredicate
isTimestampEvent, // isTimestampEvent
L3FlushEnable, // L3FlushEnable
this->containsStatelessUncachedResource, // requiresUncachedMocs
kernelDescriptor.kernelAttributes.flags.useGlobalAtomics, // useGlobalAtomics
internalUsage, // isInternal
isCooperative // isCooperative
eventAddress, //eventAddress
neoDevice, //device
kernel, //dispatchInterface
reinterpret_cast<const void *>(pThreadGroupDimensions), //pThreadGroupDimensions
commandListPreemptionMode, //preemptionMode
this->partitionCount, //partitionCount
isIndirect, //isIndirect
isPredicate, //isPredicate
isTimestampEvent, //isTimestampEvent
L3FlushEnable, //L3FlushEnable
this->containsStatelessUncachedResource, //requiresUncachedMocs
kernelDescriptor.kernelAttributes.flags.useGlobalAtomics, //useGlobalAtomics
internalUsage, //isInternal
isCooperative //isCooperative
};
NEO::EncodeDispatchKernel<GfxFamily>::encode(commandContainer, dispatchKernelArgs);
this->containsStatelessUncachedResource = dispatchKernelArgs.requiresUncachedMocs;
@ -237,6 +236,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
auto event = Event::fromHandle(hEvent);
if (partitionCount > 1) {
event->setPacketsInUse(partitionCount);
event->setPartitionedEvent(true);
}
if (L3FlushEnable) {
programEventL3Flush<gfxCoreFamily>(hEvent, this->device, partitionCount, commandContainer);

14
level_zero/core/source/event/event.h
View File

@ -88,11 +88,14 @@ struct Event : _ze_event_handle_t {
bool isEventTimestampFlagSet() const {
return isTimestampEvent;
}
void setUsingContextEndOffset(bool usingContextEndOffset) {
this->usingContextEndOffset = usingContextEndOffset;
void setPartitionedEvent(bool partitionedEvent) {
this->partitionedEvent = partitionedEvent;
}
bool isUsingContextEndOffset() const {
return isTimestampEvent || usingContextEndOffset;
bool isPartitionedEvent() const {
return partitionedEvent;
}
bool useContextEndOffset() const {
return isTimestampEvent || partitionedEvent;
}
uint64_t globalStartTS;
@ -120,9 +123,8 @@ struct Event : _ze_event_handle_t {
size_t globalEndOffset = 0u;
size_t timestampSizeInDw = 0u;
size_t singlePacketSize = 0u;
size_t eventPoolOffset = 0u;
bool isTimestampEvent = false;
bool usingContextEndOffset = false;
bool partitionedEvent = false;
};
template <typename TagSizeT>

32
level_zero/core/source/event/event_impl.inl
View File

@ -8,7 +8,6 @@
#include "shared/source/memory_manager/internal_allocation_storage.h"
#include "level_zero/core/source/event/event.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
namespace L0 {
template <typename TagSizeT>
@ -19,18 +18,15 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
if (eventPool->isEventPoolTimestampFlagSet()) {
event->setEventTimestampFlag(true);
}
auto neoDevice = device->getNEODevice();
event->kernelEventCompletionData = std::make_unique<KernelEventCompletionData<TagSizeT>[]>(EventPacketsCount::maxKernelSplit);
auto alloc = eventPool->getAllocation().getGraphicsAllocation(neoDevice->getRootDeviceIndex());
auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
uint64_t baseHostAddr = reinterpret_cast<uint64_t>(alloc->getUnderlyingBuffer());
event->eventPoolOffset = desc->index * eventPool->getEventSize();
event->hostAddress = reinterpret_cast<void *>(baseHostAddr + event->eventPoolOffset);
event->hostAddress = reinterpret_cast<void *>(baseHostAddr + (desc->index * eventPool->getEventSize()));
event->signalScope = desc->signal;
event->waitScope = desc->wait;
event->csr = neoDevice->getDefaultEngine().commandStreamReceiver;
event->setUsingContextEndOffset(L0HwHelper::get(neoDevice->getHardwareInfo().platform.eRenderCoreFamily).multiTileCapablePlatform());
event->csr = device->getNEODevice()->getDefaultEngine().commandStreamReceiver;
EventPoolImp *EventPoolImp = static_cast<struct EventPoolImp *>(eventPool);
// do not reset even if it has been imported, since event pool
@ -45,7 +41,7 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
template <typename TagSizeT>
uint64_t EventImp<TagSizeT>::getGpuAddress(Device *device) {
auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
return (alloc->getGpuAddress() + this->eventPoolOffset);
return (alloc->getGpuAddress() + (index * eventPool->getEventSize()));
}
template <typename TagSizeT>
@ -124,7 +120,7 @@ ze_result_t EventImp<TagSizeT>::queryStatusNonTimestamp() {
for (uint32_t i = 0; i < kernelCount; i++) {
uint32_t packetsToCheck = kernelEventCompletionData[i].getPacketsUsed();
for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++) {
void const *queryAddress = usingContextEndOffset
void const *queryAddress = partitionedEvent
? kernelEventCompletionData[i].getContextEndAddress(packetId)
: kernelEventCompletionData[i].getContextStartAddress(packetId);
bool ready = NEO::WaitUtils::waitFunctionWithPredicate<const TagSizeT>(
@ -142,11 +138,9 @@ ze_result_t EventImp<TagSizeT>::queryStatusNonTimestamp() {
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::queryStatus() {
TagSizeT *hostAddr = static_cast<TagSizeT *>(hostAddress);
if (metricStreamer != nullptr) {
TagSizeT *hostAddr = static_cast<TagSizeT *>(hostAddress);
if (usingContextEndOffset) {
hostAddr = ptrOffset(hostAddr, this->getContextEndOffset());
}
*hostAddr = metricStreamer->getNotificationState();
}
this->csr->downloadAllocations();
@ -191,21 +185,21 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValueTimestamps(TagSizeT eventVal) {
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::hostEventSetValue(TagSizeT eventVal) {
UNRECOVERABLE_IF(hostAddress == nullptr);
if (isEventTimestampFlagSet()) {
return hostEventSetValueTimestamps(eventVal);
}
auto packetHostAddr = hostAddress;
if (usingContextEndOffset) {
packetHostAddr = ptrOffset(packetHostAddr, contextEndOffset);
}
UNRECOVERABLE_IF(packetHostAddr == nullptr);
for (uint32_t i = 0; i < kernelCount; i++) {
uint32_t packetsToSet = kernelEventCompletionData[i].getPacketsUsed();
for (uint32_t j = 0; j < packetsToSet; j++) {
memcpy_s(packetHostAddr, sizeof(TagSizeT), static_cast<void *>(&eventVal), sizeof(TagSizeT));
if (isPartitionedEvent()) {
void *packetContextEndAddr = ptrOffset(packetHostAddr, contextEndOffset);
memcpy_s(packetContextEndAddr, sizeof(TagSizeT), static_cast<void *>(&eventVal), sizeof(TagSizeT));
}
packetHostAddr = ptrOffset(packetHostAddr, singlePacketSize);
}
}
@ -274,8 +268,10 @@ ze_result_t EventImp<TagSizeT>::reset() {
kernelEventCompletionData[i].setPacketsUsed(NEO::TimestampPacketSizeControl::preferredPacketCount);
}
}
partitionedEvent = true;
hostEventSetValue(Event::STATE_INITIAL);
resetPackets();
partitionedEvent = false;
return ZE_RESULT_SUCCESS;
}

2
level_zero/core/source/hw_helpers/l0_hw_helper.h
View File

@ -39,7 +39,6 @@ class L0HwHelper {
virtual void getAttentionBitmaskForSingleThreads(std::vector<ze_device_thread_t> &threads, const NEO::HardwareInfo &hwInfo, std::unique_ptr<uint8_t[]> &bitmask, size_t &bitmaskSize) const = 0;
virtual std::vector<ze_device_thread_t> getThreadsFromAttentionBitmask(const NEO::HardwareInfo &hwInfo, const uint8_t *bitmask, const size_t bitmaskSize) const = 0;
virtual bool multiTileCapablePlatform() const = 0;
protected:
L0HwHelper() = default;
@ -63,7 +62,6 @@ class L0HwHelperHw : public L0HwHelper {
bool isIpSamplingSupported(const NEO::HardwareInfo &hwInfo) const override;
void getAttentionBitmaskForSingleThreads(std::vector<ze_device_thread_t> &threads, const NEO::HardwareInfo &hwInfo, std::unique_ptr<uint8_t[]> &bitmask, size_t &bitmaskSize) const override;
std::vector<ze_device_thread_t> getThreadsFromAttentionBitmask(const NEO::HardwareInfo &hwInfo, const uint8_t *bitmask, const size_t bitmaskSize) const override;
bool multiTileCapablePlatform() const override;
};
} // namespace L0

5
level_zero/core/source/hw_helpers/l0_hw_helper_skl_and_later.inl
View File

@ -13,9 +13,4 @@ template <typename GfxFamily>
void L0HwHelperHw<GfxFamily>::setAdditionalGroupProperty(ze_command_queue_group_properties_t &groupProperty, NEO::EngineGroupType groupType) const {
}
template <typename Family>
bool L0HwHelperHw<Family>::multiTileCapablePlatform() const {
return false;
}
} // namespace L0

5
level_zero/core/source/xe_hp_core/l0_hw_helper_xe_hp_core.cpp
View File

@ -27,11 +27,6 @@ bool L0HwHelperHw<Family>::isResumeWARequired() {
return true;
}
template <>
bool L0HwHelperHw<Family>::multiTileCapablePlatform() const {
return true;
}
// clang-format off
#include "level_zero/core/source/hw_helpers/l0_hw_helper_tgllp_plus.inl"
// clang-format on

5
level_zero/core/source/xe_hpc_core/l0_hw_helper_xe_hpc_core.cpp
View File

@ -29,11 +29,6 @@ bool L0HwHelperHw<Family>::isIpSamplingSupported(const NEO::HardwareInfo &hwInfo
return NEO::PVC::isXt(hwInfo);
}
template <>
bool L0HwHelperHw<Family>::multiTileCapablePlatform() const {
return true;
}
template class L0HwHelperHw<Family>;
} // namespace L0

17
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
View File

@ -40,22 +40,18 @@ HWTEST_F(CommandListAppendEventReset, givenCmdlistWhenResetEventAppendedThenPost
auto itorPC = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(0u, itorPC.size());
auto gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
uint32_t postSyncFound = 0;
bool postSyncFound = false;
for (auto it : itorPC) {
auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
EXPECT_TRUE(cmd->getCommandStreamerStallEnable());
EXPECT_EQ(cmd->getImmediateData(), Event::STATE_INITIAL);
auto gpuAddress = event->getGpuAddress(device);
EXPECT_EQ(gpuAddress, NEO::UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*cmd));
postSyncFound++;
postSyncFound = true;
}
}
EXPECT_EQ(1u, postSyncFound);
ASSERT_TRUE(postSyncFound);
}
HWTEST_F(CommandListAppendEventReset, whenResetEventIsAppendedAndNoSpaceIsAvailableThenNextCommandBufferIsCreated) {
@ -206,9 +202,6 @@ HWTEST2_F(CommandListAppendEventReset, givenEventWithHostScopeUsedInResetThenPip
commandList->appendEventReset(event->toHandle());
auto gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
@ -253,7 +246,7 @@ HWTEST2_F(CommandListAppendEventReset,
constexpr uint32_t packets = 2u;
event->setPacketsInUse(packets);
event->setEventTimestampFlag(false);
event->setUsingContextEndOffset(true);
event->setPartitionedEvent(true);
event->signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
commandList->partitionCount = packets;

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

@ -1081,14 +1081,7 @@ HWTEST_F(CommandListAppendLaunchKernel, givenSingleValidWaitEventsThenAddSemapho
EXPECT_EQ(cmd->getCompareOperation(),
MI_SEMAPHORE_WAIT::COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD);
EXPECT_EQ(static_cast<uint32_t>(-1), cmd->getSemaphoreDataDword());
auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
uint64_t gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
EXPECT_EQ(gpuAddress & addressSpace, cmd->getSemaphoreGraphicsAddress() & addressSpace);
EXPECT_EQ(cmd->getSemaphoreGraphicsAddress() & device->getHwInfo().capabilityTable.gpuAddressSpace, event->getGpuAddress(device) & device->getHwInfo().capabilityTable.gpuAddressSpace);
}
}

14
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_signal_event.cpp
View File

@ -37,13 +37,10 @@ HWTEST_F(CommandListAppendSignalEvent, WhenAppendingSignalEventWithoutScopeThenM
cmdList, ptrOffset(commandList->commandContainer.getCommandStream()->getCpuBase(), 0), usedSpaceAfter));
auto baseAddr = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
baseAddr += event->getContextEndOffset();
}
auto itor = find<MI_STORE_DATA_IMM *>(cmdList.begin(), cmdList.end());
ASSERT_NE(itor, cmdList.end());
EXPECT_NE(cmdList.end(), itor);
auto cmd = genCmdCast<MI_STORE_DATA_IMM *>(*itor);
EXPECT_EQ(baseAddr, cmd->getAddress());
EXPECT_EQ(cmd->getAddress(), baseAddr);
}
HWTEST_F(CommandListAppendSignalEvent, givenCmdlistWhenAppendingSignalEventThenEventPoolGraphicsAllocationIsAddedToResidencyContainer) {
@ -203,7 +200,6 @@ HWTEST2_F(CommandListAppendSignalEvent,
constexpr uint32_t packets = 2u;
event->setEventTimestampFlag(false);
event->setUsingContextEndOffset(true);
event->signalScope = ZE_EVENT_SCOPE_FLAG_HOST;
commandList->partitionCount = packets;
@ -257,7 +253,6 @@ HWTEST2_F(CommandListAppendSignalEvent,
constexpr uint32_t packets = 2u;
event->setEventTimestampFlag(false);
event->setUsingContextEndOffset(true);
event->signalScope = 0;
commandList->partitionCount = packets;
@ -321,10 +316,7 @@ HWTEST2_F(CommandListAppendSignalEvent,
commandList->appendSignalEventPostWalker(event->toHandle());
EXPECT_EQ(packets, event->getPacketsInUse());
auto gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
auto gpuAddress = event->getGpuAddress(device) + event->getContextEndOffset();
auto &hwInfo = device->getNEODevice()->getHardwareInfo();
size_t expectedSize = NEO::MemorySynchronizationCommands<GfxFamily>::getSizeForPipeControlWithPostSyncOperation(hwInfo);

31
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
View File

@ -47,12 +47,7 @@ HWTEST_F(CommandListAppendWaitOnEvent, WhenAppendingWaitOnEventThenSemaphoreWait
auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
uint64_t gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
EXPECT_EQ(gpuAddress & addressSpace, cmd->getSemaphoreGraphicsAddress() & addressSpace);
EXPECT_EQ(cmd->getSemaphoreGraphicsAddress() & addressSpace, event->getGpuAddress(device) & addressSpace);
EXPECT_EQ(cmd->getWaitMode(),
MI_SEMAPHORE_WAIT::WAIT_MODE::WAIT_MODE_POLLING_MODE);
}
@ -78,19 +73,15 @@ HWTEST_F(CommandListAppendWaitOnEvent, givenTwoEventsWhenWaitOnEventsAppendedThe
auto itor = findAll<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(2u, itor.size());
auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
uint64_t gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
for (int i = 0; i < 2; i++) {
auto cmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*itor[i]);
EXPECT_EQ(cmd->getCompareOperation(),
MI_SEMAPHORE_WAIT::COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD);
EXPECT_EQ(static_cast<uint32_t>(-1), cmd->getSemaphoreDataDword());
EXPECT_EQ(gpuAddress & addressSpace, cmd->getSemaphoreGraphicsAddress() & addressSpace);
auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
EXPECT_EQ(cmd->getSemaphoreGraphicsAddress() & addressSpace, event->getGpuAddress(device) & addressSpace);
EXPECT_EQ(cmd->getWaitMode(),
MI_SEMAPHORE_WAIT::WAIT_MODE::WAIT_MODE_POLLING_MODE);
}
@ -275,12 +266,7 @@ HWTEST2_F(CommandListAppendWaitOnEvent, givenCommandListWhenAppendWriteGlobalTim
auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
uint64_t gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
EXPECT_EQ(gpuAddress & addressSpace, cmd->getSemaphoreGraphicsAddress() & addressSpace);
EXPECT_EQ(cmd->getSemaphoreGraphicsAddress() & addressSpace, event->getGpuAddress(device) & addressSpace);
EXPECT_EQ(cmd->getWaitMode(),
MI_SEMAPHORE_WAIT::WAIT_MODE::WAIT_MODE_POLLING_MODE);
@ -336,9 +322,6 @@ HWTEST_F(CommandListAppendWaitOnEvent, givenCommandBufferIsEmptyWhenAppendingWai
EXPECT_NE(oldCommandBuffer, newCommandBuffer);
auto gpuAddress = event->getGpuAddress(device);
if (event->isUsingContextEndOffset()) {
gpuAddress += event->getContextEndOffset();
}
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList,
@ -386,7 +369,7 @@ HWTEST2_F(MultTileCommandListAppendWaitOnEvent,
size_t expectedSize = commandList->partitionCount * sizeof(MI_SEMAPHORE_WAIT);
event->setPacketsInUse(commandList->partitionCount);
event->setUsingContextEndOffset(true);
event->setPartitionedEvent(true);
ze_event_handle_t eventHandle = event->toHandle();

56
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@ -16,7 +16,6 @@
#include "level_zero/core/source/context/context_imp.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/event/event.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
@ -553,12 +552,6 @@ TEST_F(EventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAndO
auto event = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
ASSERT_NE(nullptr, event);
if (L0HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).multiTileCapablePlatform()) {
EXPECT_TRUE(event->isUsingContextEndOffset());
} else {
EXPECT_FALSE(event->isUsingContextEndOffset());
}
result = event->queryStatus();
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
@ -678,38 +671,23 @@ TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithNonZeroTimeoutAn
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
}
TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithTimeoutZeroWhenStateSignaledThenHostSynchronizeReturnsSuccess) {
TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithTimeoutZeroAndStateSignaledHostSynchronizeReturnsSuccess) {
uint32_t *hostAddr = static_cast<uint32_t *>(event->getHostAddress());
*hostAddr = Event::STATE_SIGNALED;
event->setUsingContextEndOffset(false);
ze_result_t result = event->hostSynchronize(0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithTimeoutNonZeroWhenStateSignaledThenHostSynchronizeReturnsSuccess) {
TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithTimeoutNonZeroAndStateSignaledHostSynchronizeReturnsSuccess) {
uint32_t *hostAddr = static_cast<uint32_t *>(event->getHostAddress());
*hostAddr = Event::STATE_SIGNALED;
event->setUsingContextEndOffset(false);
ze_result_t result = event->hostSynchronize(10);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(EventSynchronizeTest, givenCallToEventHostSynchronizeWithTimeoutZeroWhenOffsetEventStateSignaledThenHostSynchronizeReturnsSuccess) {
uint32_t *hostAddr = static_cast<uint32_t *>(event->getHostAddress());
hostAddr = ptrOffset(hostAddr, event->getContextEndOffset());
*hostAddr = Event::STATE_SIGNALED;
event->setUsingContextEndOffset(true);
ze_result_t result = event->hostSynchronize(0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(EventSynchronizeTest, givenInfiniteTimeoutWhenWaitingForNonTimestampEventCompletionThenReturnOnlyAfterAllEventPacketsAreCompleted) {
constexpr uint32_t packetsInUse = 2;
event->setPacketsInUse(packetsInUse);
event->setUsingContextEndOffset(false);
const size_t eventPacketSize = event->getSinglePacketSize();
const size_t eventCompletionOffset = event->getContextStartOffset();
@ -742,10 +720,10 @@ TEST_F(EventSynchronizeTest, givenInfiniteTimeoutWhenWaitingForNonTimestampEvent
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
TEST_F(EventSynchronizeTest, givenInfiniteTimeoutWhenWaitingForOffsetedNonTimestampEventCompletionThenReturnOnlyAfterAllEventPacketsAreCompleted) {
TEST_F(EventSynchronizeTest, givenInfiniteTimeoutWhenWaitingForPartitionedNonTimestampEventCompletionThenReturnOnlyAfterAllEventPacketsAreCompleted) {
constexpr uint32_t packetsInUse = 2;
event->setPacketsInUse(packetsInUse);
event->setUsingContextEndOffset(true);
event->setPartitionedEvent(true);
const size_t eventPacketSize = event->getSinglePacketSize();
const size_t eventCompletionOffset = event->getContextEndOffset();
@ -842,13 +820,11 @@ TEST_F(EventPoolIPCEventResetTests, whenOpeningIpcHandleForEventPoolCreateWithIp
EXPECT_NE(nullptr, event0);
uint32_t *hostAddr = static_cast<uint32_t *>(event0->getHostAddress());
if (event0->isUsingContextEndOffset()) {
hostAddr = ptrOffset(hostAddr, event0->getContextEndOffset());
}
EXPECT_EQ(*hostAddr, Event::STATE_INITIAL);
// change state
event0->hostSignal();
hostAddr = static_cast<uint32_t *>(event0->getHostAddress());
EXPECT_EQ(*hostAddr, Event::STATE_SIGNALED);
// create an event from the pool with the same index as event0, but this time, since isImportedIpcPool is true, no reset should happen
@ -860,9 +836,6 @@ TEST_F(EventPoolIPCEventResetTests, whenOpeningIpcHandleForEventPoolCreateWithIp
EXPECT_NE(nullptr, event1);
uint32_t *hostAddr1 = static_cast<uint32_t *>(event1->getHostAddress());
if (event1->isUsingContextEndOffset()) {
hostAddr1 = ptrOffset(hostAddr1, event1->getContextEndOffset());
}
EXPECT_EQ(*hostAddr1, Event::STATE_SIGNALED);
// create another event from the pool with the same index, but this time, since isImportedIpcPool is false, reset should happen
@ -874,9 +847,6 @@ TEST_F(EventPoolIPCEventResetTests, whenOpeningIpcHandleForEventPoolCreateWithIp
EXPECT_NE(nullptr, event2);
uint32_t *hostAddr2 = static_cast<uint32_t *>(event2->getHostAddress());
if (event2->isUsingContextEndOffset()) {
hostAddr2 = ptrOffset(hostAddr2, event2->getContextEndOffset());
}
EXPECT_EQ(*hostAddr2, Event::STATE_INITIAL);
}
@ -1529,10 +1499,11 @@ TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
auto result = event->hostSignal();
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
event->setUsingContextEndOffset(true);
event->setPartitionedEvent(true);
result = event->reset();
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(event->isPartitionedEvent());
EXPECT_EQ(event->queryStatus(), ZE_RESULT_NOT_READY);
@ -1579,9 +1550,6 @@ TEST_F(EventTests, givenRegularEventUseMultiplePacketsWhenHostSignalThenExpectAl
ASSERT_NE(event, nullptr);
uint32_t *hostAddr = static_cast<uint32_t *>(event->getHostAddress());
if (event->isUsingContextEndOffset()) {
hostAddr = ptrOffset(hostAddr, event->getContextEndOffset());
}
EXPECT_EQ(*hostAddr, Event::STATE_INITIAL);
EXPECT_EQ(1u, event->getPacketsInUse());
@ -1595,7 +1563,7 @@ TEST_F(EventTests, givenRegularEventUseMultiplePacketsWhenHostSignalThenExpectAl
}
}
TEST_F(EventTests, givenEventUseMultiplePacketsWhenHostSignalThenExpectAllPacketsAreSignaled) {
TEST_F(EventTests, givenPartitionedEventUseMultiplePacketsWhenHostSignalThenExpectAllPacketsAreSignaled) {
eventDesc.index = 0;
eventDesc.signal = 0;
eventDesc.wait = 0;
@ -1604,12 +1572,7 @@ TEST_F(EventTests, givenEventUseMultiplePacketsWhenHostSignalThenExpectAllPacket
device)));
ASSERT_NE(event, nullptr);
size_t eventOffset = 0;
if (event->isUsingContextEndOffset()) {
eventOffset = event->getContextEndOffset();
}
uint32_t *hostAddr = static_cast<uint32_t *>(ptrOffset(event->getHostAddress(), eventOffset));
uint32_t *hostAddr = static_cast<uint32_t *>(ptrOffset(event->getHostAddress(), event->getContextEndOffset()));
EXPECT_EQ(Event::STATE_INITIAL, *hostAddr);
EXPECT_EQ(1u, event->getPacketsInUse());
@ -1617,6 +1580,7 @@ TEST_F(EventTests, givenEventUseMultiplePacketsWhenHostSignalThenExpectAllPacket
constexpr uint32_t packetsUsed = 4u;
event->setPacketsInUse(packetsUsed);
event->setEventTimestampFlag(false);
event->setPartitionedEvent(true);
event->hostSignal();
for (uint32_t i = 0; i < packetsUsed; i++) {

7
level_zero/core/test/unit_tests/sources/helper/l0_hw_helper_tests.cpp
View File

@ -19,7 +19,6 @@ namespace ult {
using L0HwHelperTest = ::testing::Test;
using PlatformsWithWa = IsWithinGfxCore<IGFX_GEN12LP_CORE, IGFX_XE_HP_CORE>;
using NonMultiTilePlatforms = IsWithinGfxCore<IGFX_GEN9_CORE, IGFX_GEN12LP_CORE>;
HWTEST2_F(L0HwHelperTest, givenResumeWANotNeededThenFalseIsReturned, IsAtMostGen11) {
auto &l0HwHelper = L0::L0HwHelper::get(NEO::defaultHwInfo->platform.eRenderCoreFamily);
@ -561,9 +560,5 @@ HWTEST2_F(L0HwHelperFusedEuTest, givenBitmaskWithAttentionBitsForHalfOfThreadsWh
}
}
HWTEST2_F(L0HwHelperTest, GivenNonMultiTilePlatformsWhenCheckingL0HelperForMultiTileCapablePlatformThenReturnFalse, NonMultiTilePlatforms) {
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().multiTileCapablePlatform());
}
} // namespace ult
} // namespace L0
} // namespace L0

2
level_zero/core/test/unit_tests/xe_hp_core/test_cmdlist_xe_hp_core.cpp
View File

@ -739,7 +739,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenEventWhenInvokingAppendLaunchKerne
for (auto it : itorPS) {
auto cmd = genCmdCast<WALKER_TYPE *>(*it);
auto &postSync = cmd->getPostSync();
EXPECT_EQ(POSTSYNC_DATA::OPERATION_WRITE_TIMESTAMP, postSync.getOperation());
EXPECT_EQ(POSTSYNC_DATA::OPERATION_WRITE_IMMEDIATE_DATA, postSync.getOperation());
EXPECT_EQ(gpuAddress, postSync.getDestinationAddress());
postSyncFound = true;
}

7
level_zero/core/test/unit_tests/xe_hp_core/test_l0_hw_helper_xe_hp_core.cpp
View File

@ -7,7 +7,6 @@
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
namespace L0 {
@ -19,11 +18,5 @@ HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForAllEUsWhe
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenEu0To1Threads0To3BitmaskWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_XE_HP_CORE);
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForHalfOfThreadsWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_XE_HP_CORE);
using L0HwHelperTestXeHp = ::testing::Test;
XEHPTEST_F(L0HwHelperTestXeHp, GivenXeHpWhenCheckingL0HelperForMultiTileCapablePlatformThenReturnTrue) {
EXPECT_TRUE(L0::L0HwHelperHw<FamilyType>::get().multiTileCapablePlatform());
}
} // namespace ult
} // namespace L0

1
level_zero/core/test/unit_tests/xe_hpc_core/CMakeLists.txt
View File

@ -11,7 +11,6 @@ if(TESTS_XE_HPC_CORE)
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdlist_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_cmdqueue_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_l0_hw_helper_xe_hpc_core.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_module_xe_hpc_core.cpp
)
add_subdirectories()

22
level_zero/core/test/unit_tests/xe_hpc_core/test_l0_hw_helper_xe_hpc_core.cpp
View File

@ -1,22 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
namespace L0 {
namespace ult {
using L0HwHelperTestXeHpc = ::testing::Test;
XE_HPC_CORETEST_F(L0HwHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForMultiTileCapablePlatformThenReturnTrue) {
EXPECT_TRUE(L0::L0HwHelperHw<FamilyType>::get().multiTileCapablePlatform());
}
} // namespace ult
} // namespace L0

70
level_zero/core/test/unit_tests/xe_hpg_core/test_cmdlist_xe_hpg_core.cpp
View File

@ -10,13 +10,11 @@
#include "shared/source/helpers/register_offsets.h"
#include "shared/source/helpers/state_base_address.h"
#include "shared/test/common/cmd_parse/gen_cmd_parse.h"
#include "shared/test/common/helpers/unit_test_helper.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
#include "level_zero/core/test/unit_tests/mocks/mock_module.h"
@ -379,73 +377,5 @@ HWTEST2_F(CommandListCreate, GivenComputeModePropertiesWhenUpdateStreamPropertie
EXPECT_TRUE(pCommandList->finalStreamState.stateComputeMode.largeGrfMode.isDirty);
EXPECT_FALSE(pCommandList->finalStreamState.stateComputeMode.isCoherencyRequired.isDirty);
}
using CommandListAppendLaunchKernelXeHpgCore = Test<ModuleFixture>;
HWTEST2_F(CommandListAppendLaunchKernelXeHpgCore, givenEventWhenAppendKernelIsCalledThenImmediateDataPostSyncIsAdded, IsXeHpgCore) {
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
using POSTSYNC_DATA = typename FamilyType::POSTSYNC_DATA;
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
Mock<::L0::Kernel> kernel;
auto pMockModule = std::unique_ptr<Module>(new Mock<Module>(device, nullptr));
kernel.module = pMockModule.get();
kernel.setGroupSize(1, 1, 1);
ze_group_count_t groupCount{8, 1, 1};
auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
auto result = commandList->initialize(device, NEO::EngineGroupType::CooperativeCompute, 0u);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
eventPoolDesc.count = 1;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
auto eventPool = std::unique_ptr<EventPool>(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto event = std::unique_ptr<Event>(Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, event->toHandle(), 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto usedSpaceAfter = commandList->commandContainer.getCommandStream()->getUsed();
EXPECT_GT(usedSpaceAfter, usedSpaceBefore);
GenCmdList cmdList;
EXPECT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList,
ptrOffset(commandList->commandContainer.getCommandStream()->getCpuBase(), usedSpaceBefore),
usedSpaceAfter - usedSpaceBefore));
auto gpuAddress = event->getGpuAddress(device);
auto itorWalker = find<WALKER_TYPE *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorWalker);
auto cmdWalker = genCmdCast<WALKER_TYPE *>(*itorWalker);
auto &postSync = cmdWalker->getPostSync();
EXPECT_EQ(POSTSYNC_DATA::OPERATION_WRITE_IMMEDIATE_DATA, postSync.getOperation());
EXPECT_EQ(gpuAddress, postSync.getDestinationAddress());
gpuAddress += event->getSinglePacketSize();
auto itorPC = findAll<PIPE_CONTROL *>(itorWalker, cmdList.end());
ASSERT_NE(0u, itorPC.size());
uint32_t postSyncCount = 0u;
for (auto it : itorPC) {
auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
EXPECT_EQ(gpuAddress, NEO::UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*cmd));
postSyncCount++;
}
}
EXPECT_EQ(1u, postSyncCount);
}
} // namespace ult
} // namespace L0

7
level_zero/core/test/unit_tests/xe_hpg_core/test_l0_hw_helper_xe_hpg_core.cpp
View File

@ -7,7 +7,6 @@
#include "shared/test/common/test_macros/test.h"
#include "level_zero/core/source/hw_helpers/l0_hw_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
namespace L0 {
@ -19,11 +18,5 @@ HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForAllEUsWhe
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenEu0To1Threads0To3BitmaskWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_XE_HPG_CORE);
HWTEST_EXCLUDE_PRODUCT(L0HwHelperTest, givenBitmaskWithAttentionBitsForHalfOfThreadsWhenGettingThreadsThenCorrectThreadsAreReturned, IGFX_XE_HPG_CORE);
using L0HwHelperTestXeHpg = ::testing::Test;
XE_HPG_CORETEST_F(L0HwHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForMultiTileCapablePlatformThenReturnFalse) {
EXPECT_FALSE(L0::L0HwHelperHw<FamilyType>::get().multiTileCapablePlatform());
}
} // namespace ult
} // namespace L0

28
shared/test/common/fixtures/command_container_fixture.h
View File

@ -38,20 +38,20 @@ class CommandEncodeStatesFixture : public DeviceFixture {
const void *pThreadGroupDimensions,
bool requiresUncachedMocs) {
EncodeDispatchKernelArgs args{
0, // eventAddress
device, // device
dispatchInterface, // dispatchInterface
pThreadGroupDimensions, // pThreadGroupDimensions
PreemptionMode::Disabled, // preemptionMode
1, // partitionCount
false, // isIndirect
false, // isPredicate
false, // isTimestampEvent
false, // L3FlushEnable
requiresUncachedMocs, // requiresUncachedMocs
false, // useGlobalAtomics
false, // isInternal
false // isCooperative
0, //eventAddress
device, //device
dispatchInterface, //dispatchInterface
pThreadGroupDimensions, //pThreadGroupDimensions
PreemptionMode::Disabled, //preemptionMode
1, //partitionCount
false, //isIndirect
false, //isPredicate
false, //isTimestampEvent
false, //L3FlushEnable
requiresUncachedMocs, //requiresUncachedMocs
false, //useGlobalAtomics
false, //isInternal
false //isCooperative
};
return args;

24
shared/test/unit_test/encoders/test_encode_dispatch_kernel_xehp_and_later.cpp
View File

@ -1206,27 +1206,3 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesDynamicImplicitScaling, givenImp
EXPECT_EQ(WALKER_TYPE::PARTITION_TYPE::PARTITION_TYPE_DISABLED, internalWalkerCmd->getPartitionType());
EXPECT_EQ(16u, internalWalkerCmd->getThreadGroupIdXDimension());
}
HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTest, givenNonTimestampEventWhenTimestampPostSyncRequiredThenTimestampPostSyncIsAdded) {
using POSTSYNC_DATA = typename FamilyType::POSTSYNC_DATA;
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
uint32_t dims[] = {2, 1, 1};
std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
uint64_t eventAddress = MemoryConstants::cacheLineSize * 123;
bool requiresUncachedMocs = false;
EncodeDispatchKernelArgs dispatchArgs = createDefaultDispatchKernelArgs(pDevice, dispatchInterface.get(), dims, requiresUncachedMocs);
dispatchArgs.eventAddress = eventAddress;
dispatchArgs.isTimestampEvent = true;
EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dispatchArgs);
GenCmdList commands;
CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
using WALKER_TYPE = typename FamilyType::WALKER_TYPE;
auto itor = find<WALKER_TYPE *>(commands.begin(), commands.end());
ASSERT_NE(itor, commands.end());
auto cmd = genCmdCast<WALKER_TYPE *>(*itor);
EXPECT_EQ(POSTSYNC_DATA::OPERATION_WRITE_TIMESTAMP, cmd->getPostSync().getOperation());
}