intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 23:03:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: Release temporary allocations from bcs split

Browse Source 
Related-To: NEO-7933

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2023-04-27 14:11:10 +00:00
committed by Compute-Runtime-Automation
parent 464c67789f
commit 48114e5423
11 changed files with 109 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -12,7 +12,7 @@
#include "shared/source/sku_info/sku_info_base.h"
#include "level_zero/core/source/cmdlist/cmdlist_hw_immediate.h"
#include "level_zero/core/source/cmdqueue/cmdqueue.h"
#include "level_zero/core/source/cmdqueue/cmdqueue_imp.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/event/event.h"
@@ -118,6 +118,10 @@ struct BcsSplit {
totalSize -= localSize;
engineCount--;
if (hSignalEvent) {
Event::fromHandle(hSignalEvent)->appendAdditionalCsr(static_cast<CommandQueueImp *>(cmdQsForSplit[i])->getCsr());
}
}
cmdList->addEventsToCmdList(static_cast<uint32_t>(cmdQsForSplit.size()), eventHandles.data(), hasRelaxedOrderingDependencies, false);

3
level_zero/core/source/event/event.cpp
View File

@@ -384,7 +384,8 @@ void Event::resetPackets(bool resetAllPackets) {
cpuStartTimestamp = 0;
gpuStartTimestamp = 0;
gpuEndTimestamp = 0;
this->csr = this->device->getNEODevice()->getDefaultEngine().commandStreamReceiver;
this->csrs.clear();
this->csrs.push_back(this->device->getNEODevice()->getDefaultEngine().commandStreamReceiver);
}
void Event::setIsCompleted() {

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

@@ -135,7 +135,15 @@ struct Event : _ze_event_handle_t {
return isTimestampEvent || usingContextEndOffset;
}
void setCsr(NEO::CommandStreamReceiver *csr) {
this->csr = csr;
this->csrs[0] = csr;
}
void appendAdditionalCsr(NEO::CommandStreamReceiver *additonalCsr) {
for (const auto &csr : csrs) {
if (csr == additonalCsr) {
return;
}
}
csrs.push_back(additonalCsr);
}
void increaseKernelCount();
@@ -226,7 +234,7 @@ struct Event : _ze_event_handle_t {
// Metric streamer instance associated with the event.
MetricStreamer *metricStreamer = nullptr;
NEO::CommandStreamReceiver *csr = nullptr;
StackVec<NEO::CommandStreamReceiver *, 1> csrs;
void *hostAddress = nullptr;
Device *device = nullptr;
EventPool *eventPool = nullptr;

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

@@ -42,7 +42,7 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
event->hostAddress = reinterpret_cast<void *>(baseHostAddr + event->eventPoolOffset);
event->signalScope = desc->signal;
event->waitScope = desc->wait;
event->csr = csr;
event->csrs.push_back(csr);
event->maxKernelCount = eventPool->getMaxKernelCount();
event->maxPacketCount = eventPool->getEventMaxPackets();
event->isFromIpcPool = eventPool->getImportedIpcPool();
@@ -167,10 +167,14 @@ ze_result_t EventImp<TagSizeT>::queryStatusEventPackets() {
}
}
if (this->downloadAllocationRequired) {
this->csr->downloadAllocations();
for (auto &csr : csrs) {
csr->downloadAllocations();
}
}
this->setIsCompleted();
this->csr->getInternalAllocationStorage()->cleanAllocationList(this->csr->peekTaskCount(), NEO::AllocationUsage::TEMPORARY_ALLOCATION);
for (auto &csr : csrs) {
csr->getInternalAllocationStorage()->cleanAllocationList(csr->peekTaskCount(), NEO::AllocationUsage::TEMPORARY_ALLOCATION);
}
return ZE_RESULT_SUCCESS;
}
@@ -180,7 +184,9 @@ ze_result_t EventImp<TagSizeT>::queryStatus() {
hostEventSetValue(metricStreamer->getNotificationState());
}
if (this->downloadAllocationRequired) {
this->csr->downloadAllocation(this->getAllocation(this->device));
for (auto &csr : csrs) {
csr->downloadAllocation(this->getAllocation(this->device));
}
}
if (!this->isFromIpcPool && isAlreadyCompleted()) {
@@ -292,7 +298,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
ze_result_t ret = ZE_RESULT_NOT_READY;
if (this->csr->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
if (this->csrs[0]->getType() == NEO::CommandStreamReceiverType::CSR_AUB) {
return ZE_RESULT_SUCCESS;
}
@@ -320,7 +326,7 @@ ze_result_t EventImp<TagSizeT>::hostSynchronize(uint64_t timeout) {
if (elapsedTimeSinceGpuHangCheck.count() >= this->gpuHangCheckPeriod.count()) {
lastHangCheckTime = currentTime;
if (this->csr->isGpuHangDetected()) {
if (this->csrs[0]->isGpuHangDetected()) {
if (device->getNEODevice()->getRootDeviceEnvironment().assertHandler.get()) {
device->getNEODevice()->getRootDeviceEnvironment().assertHandler->printAssertAndAbort();
}

4
level_zero/core/test/unit_tests/mocks/mock_event.h
View File

@@ -19,7 +19,7 @@ namespace ult {
template <>
struct WhiteBox<::L0::Event> : public ::L0::Event {
using BaseClass = ::L0::Event;
using BaseClass::csr;
using BaseClass::csrs;
using BaseClass::Event;
using BaseClass::gpuHangCheckPeriod;
using BaseClass::hostAddress;
@@ -36,7 +36,7 @@ using Event = WhiteBox<::L0::Event>;
template <typename TagSizeT>
struct WhiteBox<::L0::EventImp<TagSizeT>> : public L0::EventImp<TagSizeT> {
using BaseClass = ::L0::EventImp<TagSizeT>;
using BaseClass::csr;
using BaseClass::csrs;
using BaseClass::gpuHangCheckPeriod;
using BaseClass::hostAddress;
using BaseClass::hostEventSetValueTimestamps;

6
level_zero/core/test/unit_tests/sources/assert/test_assert.cpp
View File

@@ -472,7 +472,7 @@ TEST_F(EventAssertTest, GivenGpuHangWhenHostSynchronizeIsCalledThenAssertIsCheck
const auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
csr->isGpuHangDetectedReturnValue = true;
event->csr = csr.get();
event->csrs[0] = csr.get();
event->gpuHangCheckPeriod = std::chrono::microseconds::zero();
auto assertHandler = new MockAssertHandler(device->getNEODevice());
neoDevice->getRootDeviceEnvironmentRef().assertHandler.reset(assertHandler);
@@ -488,7 +488,7 @@ TEST_F(EventAssertTest, GivenNoGpuHangAndOneNanosecondTimeoutWhenHostSynchronize
const auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
csr->isGpuHangDetectedReturnValue = false;
event->csr = csr.get();
event->csrs[0] = csr.get();
event->gpuHangCheckPeriod = std::chrono::microseconds::zero();
auto assertHandler = new MockAssertHandler(device->getNEODevice());
neoDevice->getRootDeviceEnvironmentRef().assertHandler.reset(assertHandler);
@@ -506,7 +506,7 @@ TEST_F(EventAssertTest, GivenEventSignalledWhenHostSynchronizeIsCalledThenAssert
*hostAddr = Event::STATE_SIGNALED;
event->setUsingContextEndOffset(false);
event->csr = csr.get();
event->csrs[0] = csr.get();
auto assertHandler = new MockAssertHandler(device->getNEODevice());
neoDevice->getRootDeviceEnvironmentRef().assertHandler.reset(assertHandler);

56
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@@ -934,8 +934,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendSignalEvent
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendSignalEvent(event);
@@ -974,8 +974,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendBarrierThen
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendBarrier(nullptr, 1, &event);
@@ -1340,8 +1340,8 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
returnValue = commandList->appendWaitOnEvents(1, &event, false, true);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
@@ -1396,8 +1396,8 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnExecutingCommandListsWhenCreatingImme
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang;
@@ -1475,8 +1475,8 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCom
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang;
@@ -1526,8 +1526,8 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCom
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
Mock<CommandQueue> mockCommandQueue(device, &mockCommandStreamReceiver, &desc);
@@ -1576,8 +1576,8 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCom
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
Mock<CommandQueue> mockCommandQueue(device, &mockCommandStreamReceiver, &desc);
@@ -1626,8 +1626,8 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
returnValue = commandList->appendWaitOnEvents(1, &event, false, true);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
@@ -1714,8 +1714,8 @@ HWTEST_F(CommandListCreate, GivenGpuHangAndEnabledFlushTaskSubmissionFlagWhenCre
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang;
@@ -1761,8 +1761,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendResetEventT
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendEventReset(event);
@@ -1802,8 +1802,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendSignalEven
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendSignalEvent(event);
@@ -1843,8 +1843,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThe
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendBarrier(event, 0, nullptr);
@@ -1887,8 +1887,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndCopyEngineAndApp
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendBarrier(event, 0, nullptr);
@@ -1930,8 +1930,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendEventReset
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendEventReset(event);

12
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@@ -1171,8 +1171,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendSignalEven
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendSignalEvent(event);
@@ -1212,8 +1212,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThe
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendBarrier(event, 0, nullptr);
@@ -1255,8 +1255,8 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendEventReset
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
commandList->appendEventReset(event);

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

@@ -378,10 +378,10 @@ HWTEST2_F(CommandListTest, givenImmediateCommandListWhenFlushImmediateThenOverri
auto event = std::unique_ptr<Event>(static_cast<Event *>(L0::Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device)));
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
cmdList.csr = event->csr;
event->csr = &mockCommandStreamReceiver;
cmdList.csr = event->csrs[0];
event->csrs[0] = &mockCommandStreamReceiver;
cmdList.flushImmediate(ZE_RESULT_SUCCESS, false, false, false, event->toHandle());
EXPECT_EQ(event->csr, cmdList.csr);
EXPECT_EQ(event->csrs[0], cmdList.csr);
}
HWTEST2_F(CommandListTest,

8
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@@ -270,8 +270,8 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledWithImmediat
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
returnValue = commandList->appendWaitOnEvents(1, &event, false, true);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
@@ -334,8 +334,8 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledWithImmedia
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
returnValue = commandList->appendWaitOnEvents(1, &event, false, true);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);

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

@@ -259,8 +259,8 @@ TEST_F(EventPoolCreate, givenAnEventIsCreatedFromThisEventPoolThenEventContainsD
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<Event> eventObject(static_cast<Event *>(L0::Event::fromHandle(event)));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
ASSERT_NE(nullptr, eventObject->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csrs[0]);
}
TEST_F(EventPoolCreate, GivenNoDeviceThenEventPoolIsCreated) {
@@ -1298,8 +1298,8 @@ TEST_F(EventCreate, givenAnEventCreatedThenTheEventHasTheDeviceCommandStreamRece
std::unique_ptr<Event> event(static_cast<Event *>(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device)));
ASSERT_NE(nullptr, event);
ASSERT_NE(nullptr, event->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, event->csr);
ASSERT_NE(nullptr, event->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, event->csrs[0]);
}
TEST_F(EventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAndOffsetAreSet) {
@@ -1460,7 +1460,7 @@ TEST_F(EventSynchronizeTest, GivenGpuHangWhenHostSynchronizeIsCalledThenDeviceLo
const auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
csr->isGpuHangDetectedReturnValue = true;
event->csr = csr.get();
event->csrs[0] = csr.get();
event->gpuHangCheckPeriod = 0ms;
constexpr uint64_t timeout = std::numeric_limits<std::uint64_t>::max();
@@ -1473,7 +1473,7 @@ TEST_F(EventSynchronizeTest, GivenNoGpuHangAndOneNanosecondTimeoutWhenHostSynchr
const auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
csr->isGpuHangDetectedReturnValue = false;
event->csr = csr.get();
event->csrs[0] = csr.get();
event->gpuHangCheckPeriod = 0ms;
constexpr uint64_t timeoutNanoseconds = 1;
@@ -1484,7 +1484,7 @@ TEST_F(EventSynchronizeTest, GivenNoGpuHangAndOneNanosecondTimeoutWhenHostSynchr
TEST_F(EventSynchronizeTest, GivenLongPeriodOfGpuCheckAndOneNanosecondTimeoutWhenHostSynchronizeIsCalledThenResultNotReadyIsReturnedDueToTimeout) {
const auto csr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
event->csr = csr.get();
event->csrs[0] = csr.get();
event->gpuHangCheckPeriod = 50000000ms;
constexpr uint64_t timeoutNanoseconds = 1;
@@ -2804,8 +2804,8 @@ HWTEST_F(EventTests,
auto event = whiteboxCast(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device));
ASSERT_NE(event, nullptr);
ASSERT_NE(nullptr, event->csr);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, event->csr);
ASSERT_NE(nullptr, event->csrs[0]);
ASSERT_EQ(device->getNEODevice()->getDefaultEngine().commandStreamReceiver, event->csrs[0]);
event->setUsingContextEndOffset(false);
size_t eventCompletionOffset = event->getContextStartOffset();
@@ -2825,7 +2825,7 @@ HWTEST_F(EventTests,
}
};
auto ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(event->csr);
auto ultCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(event->csrs[0]);
VariableBackup<std::function<void(GraphicsAllocation & gfxAllocation)>> backupCsrDownloadImpl(&ultCsr->downloadAllocationImpl);
ultCsr->downloadAllocationImpl = [&downloadAllocationTrack](GraphicsAllocation &gfxAllocation) {
downloadAllocationTrack[&gfxAllocation]++;
@@ -2859,7 +2859,7 @@ HWTEST_F(EventTests, GivenEventIsReadyToDownloadAllAlocationsWhenDownloadAllocat
auto status = event->queryStatus();
EXPECT_EQ(ZE_RESULT_SUCCESS, status);
EXPECT_FALSE(static_cast<UltCommandStreamReceiver<FamilyType> *>(event->csr)->downloadAllocationsCalled);
EXPECT_FALSE(static_cast<UltCommandStreamReceiver<FamilyType> *>(event->csrs[0])->downloadAllocationsCalled);
event->destroy();
}
@@ -2977,7 +2977,7 @@ struct MockEventCompletion : public L0::EventImp<uint32_t> {
totalEventSize = eventPool->getEventSize();
eventPoolOffset = index * totalEventSize;
hostAddress = reinterpret_cast<void *>(baseHostAddr + eventPoolOffset);
csr = neoDevice->getDefaultEngine().commandStreamReceiver;
csrs[0] = neoDevice->getDefaultEngine().commandStreamReceiver;
maxKernelCount = eventPool->getMaxKernelCount();
maxPacketCount = eventPool->getEventMaxPackets();
@@ -3008,6 +3008,25 @@ TEST_F(EventTests, WhenQueryingStatusAfterHostSignalThenDontAccessMemoryAndRetur
EXPECT_EQ(event->assignKernelEventCompletionDataCounter, 0u);
}
TEST_F(EventTests, whenAppendAdditionalCsrThenStoreUniqueCsr) {
auto csr1 = reinterpret_cast<NEO::CommandStreamReceiver *>(0x1234);
auto csr2 = reinterpret_cast<NEO::CommandStreamReceiver *>(0x5678);
auto event = whiteboxCast(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device));
EXPECT_EQ(event->csrs.size(), 1u);
event->appendAdditionalCsr(csr1);
EXPECT_EQ(event->csrs.size(), 2u);
event->appendAdditionalCsr(csr2);
EXPECT_EQ(event->csrs.size(), 3u);
event->appendAdditionalCsr(csr1);
EXPECT_EQ(event->csrs.size(), 3u);
event->destroy();
}
TEST_F(EventTests, WhenQueryingStatusAfterHostSignalThatFailedThenAccessMemoryAndReturnSuccess) {
auto event = std::make_unique<MockEventCompletion>(eventPool.get(), 1u, device);
event->shouldHostEventSetValueFail = true;
@@ -3116,12 +3135,12 @@ TEST_F(EventSynchronizeTest, whenEventSetCsrThenCorrectCsrSet) {
auto defaultCsr = neoDevice->getDefaultEngine().commandStreamReceiver;
const auto mockCsr = std::make_unique<MockCommandStreamReceiver>(*neoDevice->getExecutionEnvironment(), 0, neoDevice->getDeviceBitfield());
EXPECT_EQ(event->csr, defaultCsr);
EXPECT_EQ(event->csrs[0], defaultCsr);
event->setCsr(mockCsr.get());
EXPECT_EQ(event->csr, mockCsr.get());
EXPECT_EQ(event->csrs[0], mockCsr.get());
event->reset();
EXPECT_EQ(event->csr, defaultCsr);
EXPECT_EQ(event->csrs[0], defaultCsr);
}
template <int32_t multiTile, int32_t signalRemainingPackets>