From 806da85ec6a8efeee20b32ecc25cf7612f0bbe9b Mon Sep 17 00:00:00 2001 From: Bartosz Dunajski Date: Fri, 26 Apr 2024 14:39:26 +0000 Subject: [PATCH] refactor: prework to pass interrupt hint Related-To: NEO-8179 Signed-off-by: Bartosz Dunajski --- level_zero/core/source/event/event_impl.inl | 2 +- .../sources/cmdlist/test_in_order_cmdlist.cpp | 33 ++++++++++++ .../command_stream/command_stream_receiver.h | 2 +- .../linux/drm_direct_submission.inl | 2 +- .../os_interface/linux/drm_command_stream.h | 2 +- .../os_interface/linux/drm_command_stream.inl | 6 +-- .../os_interface/linux/drm_memory_manager.cpp | 3 +- shared/source/os_interface/linux/drm_neo.cpp | 15 ++++-- shared/source/os_interface/linux/drm_neo.h | 4 +- .../source/os_interface/linux/memory_info.cpp | 2 +- .../os_interface/linux/os_context_linux.cpp | 4 +- shared/test/common/libult/linux/drm_mock.cpp | 4 +- shared/test/common/libult/linux/drm_mock.h | 2 +- .../libult/ult_command_stream_receiver.h | 8 ++- .../linux/mock_drm_command_stream_receiver.h | 4 +- .../linux/device_command_stream_fixture.cpp | 6 +-- .../linux/device_command_stream_fixture.h | 2 +- .../command_stream_receiver_tests.cpp | 3 +- ...and_stream_xehp_and_later_prelim_tests.cpp | 51 +++++++++++++++++++ .../linux/drm_query_prelim_tests.cpp | 6 +-- .../linux/drm_vm_bind_prelim_tests.cpp | 2 +- 21 files changed, 129 insertions(+), 34 deletions(-) diff --git a/level_zero/core/source/event/event_impl.inl b/level_zero/core/source/event/event_impl.inl index e9a2630950..d60239e8f5 100644 --- a/level_zero/core/source/event/event_impl.inl +++ b/level_zero/core/source/event/event_impl.inl @@ -520,7 +520,7 @@ ze_result_t EventImp::waitForUserFence(uint64_t timeout) { uint64_t waitAddress = castToUint64(ptrOffset(inOrderExecInfo->getBaseHostAddress(), this->inOrderAllocationOffset)); - if (!csrs[0]->waitUserFence(getInOrderExecSignalValueWithSubmissionCounter(), waitAddress, timeout)) { + if (!csrs[0]->waitUserFence(getInOrderExecSignalValueWithSubmissionCounter(), waitAddress, timeout, isKmdWaitModeEnabled(), this->externalInterruptId)) { return ZE_RESULT_NOT_READY; } diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist.cpp index d21912a949..3874db51b9 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist.cpp @@ -387,6 +387,39 @@ HWTEST2_F(InOrderCmdListTests, givenDebugFlagSetWhenEventHostSyncCalledThenCallW EXPECT_EQ(2u, ultCsr->waitUserFenecParams.callCount); } +HWTEST2_F(InOrderCmdListTests, givenUserInterruptEventWhenWaitingThenWaitForUserFenceWithParams, IsAtLeastXeHpCore) { + auto immCmdList = createImmCmdList(); + + auto eventPool = createEvents(2, false); + events[0]->enableKmdWaitMode(); + events[0]->enableInterruptMode(); + + events[1]->enableKmdWaitMode(); + events[1]->enableInterruptMode(); + events[1]->externalInterruptId = 0x123; + + immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[0]->toHandle(), 0, nullptr, launchParams, false); + immCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, events[1]->toHandle(), 0, nullptr, launchParams, false); + + auto ultCsr = static_cast *>(device->getNEODevice()->getDefaultEngine().commandStreamReceiver); + + ultCsr->waitUserFenecParams.forceRetStatusEnabled = true; + + EXPECT_EQ(0u, ultCsr->waitUserFenecParams.callCount); + + EXPECT_EQ(ZE_RESULT_SUCCESS, events[0]->hostSynchronize(2)); + + EXPECT_EQ(1u, ultCsr->waitUserFenecParams.callCount); + EXPECT_EQ(NEO::InterruptId::notUsed, ultCsr->waitUserFenecParams.externalInterruptId); + EXPECT_TRUE(ultCsr->waitUserFenecParams.userInterrupt); + + EXPECT_EQ(ZE_RESULT_SUCCESS, events[1]->hostSynchronize(2)); + + EXPECT_EQ(2u, ultCsr->waitUserFenecParams.callCount); + EXPECT_EQ(events[1]->externalInterruptId, ultCsr->waitUserFenecParams.externalInterruptId); + EXPECT_TRUE(ultCsr->waitUserFenecParams.userInterrupt); +} + HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenHostResetOrSignalEventCalledThenReturnError, IsAtLeastSkl) { auto immCmdList = createImmCmdList(); diff --git a/shared/source/command_stream/command_stream_receiver.h b/shared/source/command_stream/command_stream_receiver.h index 0473e81577..4d11aa7bad 100644 --- a/shared/source/command_stream/command_stream_receiver.h +++ b/shared/source/command_stream/command_stream_receiver.h @@ -454,7 +454,7 @@ class CommandStreamReceiver { bool isRecyclingTagForHeapStorageRequired() const { return heapStorageRequiresRecyclingTag; } - virtual bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout) { return false; } + virtual bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout, bool userInterrupt, uint32_t externalInterruptId) { return false; } void requestPreallocation(); void releasePreallocationRequest(); diff --git a/shared/source/direct_submission/linux/drm_direct_submission.inl b/shared/source/direct_submission/linux/drm_direct_submission.inl index 41f6e021f0..556080a22a 100644 --- a/shared/source/direct_submission/linux/drm_direct_submission.inl +++ b/shared/source/direct_submission/linux/drm_direct_submission.inl @@ -93,7 +93,7 @@ inline DrmDirectSubmission::~DrmDirectSubmission() { auto osContextLinux = static_cast(&this->osContext); auto &drm = osContextLinux->getDrm(); auto completionFenceCpuAddress = reinterpret_cast(this->completionFenceAllocation->getUnderlyingBuffer()) + TagAllocationLayout::completionFenceOffset; - drm.waitOnUserFences(*osContextLinux, completionFenceCpuAddress, this->completionFenceValue, this->activeTiles, -1, this->immWritePostSyncOffset); + drm.waitOnUserFences(*osContextLinux, completionFenceCpuAddress, this->completionFenceValue, this->activeTiles, -1, this->immWritePostSyncOffset, false, NEO::InterruptId::notUsed); } this->deallocateResources(); if (this->pciBarrierPtr) { diff --git a/shared/source/os_interface/linux/drm_command_stream.h b/shared/source/os_interface/linux/drm_command_stream.h index c7a6cfe035..7fae3fbf9a 100644 --- a/shared/source/os_interface/linux/drm_command_stream.h +++ b/shared/source/os_interface/linux/drm_command_stream.h @@ -64,7 +64,7 @@ class DrmCommandStreamReceiver : public DeviceCommandStreamReceiver { SubmissionStatus printBOsForSubmit(ResidencyContainer &allocationsForResidency, GraphicsAllocation &cmdBufferAllocation); - bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout) override; + bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout, bool userInterrupt, uint32_t externalInterruptId) override; using CommandStreamReceiver::pageTableManager; diff --git a/shared/source/os_interface/linux/drm_command_stream.inl b/shared/source/os_interface/linux/drm_command_stream.inl index 793f1fd642..1aa1f2da7e 100644 --- a/shared/source/os_interface/linux/drm_command_stream.inl +++ b/shared/source/os_interface/linux/drm_command_stream.inl @@ -318,7 +318,7 @@ bool DrmCommandStreamReceiver::waitForFlushStamp(FlushStamp &flushSta auto waitValue = static_cast(flushStamp); if (isUserFenceWaitActive()) { uint64_t tagAddress = castToUint64(const_cast(getTagAddress())); - return waitUserFence(waitValue, tagAddress, kmdWaitTimeout); + return waitUserFence(waitValue, tagAddress, kmdWaitTimeout, false, NEO::InterruptId::notUsed); } else { this->drm->waitHandle(waitValue, kmdWaitTimeout); } @@ -368,8 +368,8 @@ SubmissionStatus DrmCommandStreamReceiver::flushInternal(const BatchB } template -bool DrmCommandStreamReceiver::waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout) { - int ret = drm->waitOnUserFences(static_cast(*this->osContext), hostAddress, waitValue, this->activePartitions, timeout, this->immWritePostSyncWriteOffset); +bool DrmCommandStreamReceiver::waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout, bool userInterrupt, uint32_t externalInterruptId) { + int ret = drm->waitOnUserFences(static_cast(*this->osContext), hostAddress, waitValue, this->activePartitions, timeout, this->immWritePostSyncWriteOffset, userInterrupt, externalInterruptId); return (ret == 0); } diff --git a/shared/source/os_interface/linux/drm_memory_manager.cpp b/shared/source/os_interface/linux/drm_memory_manager.cpp index 8fa6932382..17253e768f 100644 --- a/shared/source/os_interface/linux/drm_memory_manager.cpp +++ b/shared/source/os_interface/linux/drm_memory_manager.cpp @@ -2221,7 +2221,8 @@ void DrmMemoryManager::waitOnCompletionFence(GraphicsAllocation *allocation) { if (allocation->isUsedByOsContext(osContextId)) { Drm &drm = getDrm(csr->getRootDeviceIndex()); - drm.waitOnUserFences(static_cast(*osContext), completionFenceAddress, allocationTaskCount, csr->getActivePartitions(), -1, csr->getImmWritePostSyncWriteOffset()); + drm.waitOnUserFences(static_cast(*osContext), completionFenceAddress, allocationTaskCount, csr->getActivePartitions(), -1, + csr->getImmWritePostSyncWriteOffset(), false, NEO::InterruptId::notUsed); } } } else { diff --git a/shared/source/os_interface/linux/drm_neo.cpp b/shared/source/os_interface/linux/drm_neo.cpp index 1546925e9f..1961babb67 100644 --- a/shared/source/os_interface/linux/drm_neo.cpp +++ b/shared/source/os_interface/linux/drm_neo.cpp @@ -960,8 +960,8 @@ void Drm::getPrelimVersion(std::string &prelimVersion) { ifs.close(); } -int Drm::waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags) { - return ioctlHelper->waitUserFence(ctxId, address, value, static_cast(dataWidth), timeout, flags, false, NEO::InterruptId::notUsed); +int Drm::waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags, bool userInterrupt, uint32_t externalInterruptId) { + return ioctlHelper->waitUserFence(ctxId, address, value, static_cast(dataWidth), timeout, flags, userInterrupt, externalInterruptId); } bool Drm::querySystemInfo() { @@ -1165,7 +1165,7 @@ void Drm::waitForBind(uint32_t vmHandleId) { auto fenceValue = this->fenceVal[vmHandleId]; lock.unlock(); - waitUserFence(0u, fenceAddress, fenceValue, ValueWidth::u64, -1, ioctlHelper->getWaitUserFenceSoftFlag()); + waitUserFence(0u, fenceAddress, fenceValue, ValueWidth::u64, -1, ioctlHelper->getWaitUserFenceSoftFlag(), false, NEO::InterruptId::notUsed); } bool Drm::isSetPairAvailable() { @@ -1557,7 +1557,7 @@ PhysicalDevicePciSpeedInfo Drm::getPciSpeedInfo() const { return pciSpeedInfo; } -int Drm::waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uint64_t value, uint32_t numActiveTiles, int64_t timeout, uint32_t postSyncOffset) { +int Drm::waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uint64_t value, uint32_t numActiveTiles, int64_t timeout, uint32_t postSyncOffset, bool userInterrupt, uint32_t externalInterruptId) { auto &drmContextIds = osContext.getDrmContextIds(); UNRECOVERABLE_IF(numActiveTiles > drmContextIds.size()); auto completionFenceCpuAddress = address; @@ -1566,7 +1566,7 @@ int Drm::waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uin for (auto drmIterator = 0u; drmIterator < numActiveTiles; drmIterator++) { if (*reinterpret_cast(completionFenceCpuAddress) < value) { static constexpr uint16_t flags = 0; - int retVal = waitUserFence(drmContextIds[drmIterator], completionFenceCpuAddress, value, Drm::ValueWidth::u64, selectedTimeout, flags); + int retVal = waitUserFence(drmContextIds[drmIterator], completionFenceCpuAddress, value, Drm::ValueWidth::u64, selectedTimeout, flags, userInterrupt, externalInterruptId); if (debugManager.flags.PrintCompletionFenceUsage.get()) { std::cout << "Completion fence waited." << " Status: " << retVal @@ -1583,6 +1583,11 @@ int Drm::waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uin << ", current value: " << *reinterpret_cast(completionFenceCpuAddress) << ", wait value: " << value << std::endl; } + + if (externalInterruptId != NEO::InterruptId::notUsed) { + break; + } + completionFenceCpuAddress = ptrOffset(completionFenceCpuAddress, postSyncOffset); } diff --git a/shared/source/os_interface/linux/drm_neo.h b/shared/source/os_interface/linux/drm_neo.h index 90dbf27602..ce6c98534c 100644 --- a/shared/source/os_interface/linux/drm_neo.h +++ b/shared/source/os_interface/linux/drm_neo.h @@ -220,9 +220,9 @@ class Drm : public DriverModel { u32, u64 }; - MOCKABLE_VIRTUAL int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags); + MOCKABLE_VIRTUAL int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags, bool userInterrupt, uint32_t externalInterruptId); - int waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uint64_t value, uint32_t numActiveTiles, int64_t timeout, uint32_t postSyncOffset); + int waitOnUserFences(const OsContextLinux &osContext, uint64_t address, uint64_t value, uint32_t numActiveTiles, int64_t timeout, uint32_t postSyncOffset, bool userInterrupt, uint32_t externalInterruptId); void setNewResourceBoundToVM(BufferObject *bo, uint32_t vmHandleId); diff --git a/shared/source/os_interface/linux/memory_info.cpp b/shared/source/os_interface/linux/memory_info.cpp index ed7ae75666..d06bd1ee36 100644 --- a/shared/source/os_interface/linux/memory_info.cpp +++ b/shared/source/os_interface/linux/memory_info.cpp @@ -87,7 +87,7 @@ uint32_t MemoryInfo::getLocalMemoryRegionIndex(DeviceBitfield deviceBitfield) co auto &productHelper = this->drm.getRootDeviceEnvironment().getHelper(); bool bankOverrideRequired{gfxCoreHelper.isBankOverrideRequired(hwInfo, productHelper)}; - uint32_t tileIndex{bankOverrideRequired ? 0u : Math::log2(deviceBitfield.to_ulong())}; + uint32_t tileIndex{bankOverrideRequired ? 0u : Math::log2(static_cast(deviceBitfield.to_ulong()))}; if (debugManager.flags.OverrideDrmRegion.get() != -1) { tileIndex = debugManager.flags.OverrideDrmRegion.get(); } diff --git a/shared/source/os_interface/linux/os_context_linux.cpp b/shared/source/os_interface/linux/os_context_linux.cpp index 591f386961..e77c00e8b9 100644 --- a/shared/source/os_interface/linux/os_context_linux.cpp +++ b/shared/source/os_interface/linux/os_context_linux.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2023 Intel Corporation + * Copyright (C) 2018-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -108,7 +108,7 @@ void OsContextLinux::waitForBind(uint32_t drmIterator) { auto fenceValue = this->fenceVal[drmIterator]; lock.unlock(); - drm.waitUserFence(0u, fenceAddress, fenceValue, Drm::ValueWidth::u64, -1, drm.getIoctlHelper()->getWaitUserFenceSoftFlag()); + drm.waitUserFence(0u, fenceAddress, fenceValue, Drm::ValueWidth::u64, -1, drm.getIoctlHelper()->getWaitUserFenceSoftFlag(), false, NEO::InterruptId::notUsed); } else { drm.waitForBind(drmIterator); diff --git a/shared/test/common/libult/linux/drm_mock.cpp b/shared/test/common/libult/linux/drm_mock.cpp index e32fcdf004..9f27cefe40 100644 --- a/shared/test/common/libult/linux/drm_mock.cpp +++ b/shared/test/common/libult/linux/drm_mock.cpp @@ -324,9 +324,9 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) { return handleRemainingRequests(request, arg); } -int DrmMock::waitUserFence(uint32_t ctxIdx, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags) { +int DrmMock::waitUserFence(uint32_t ctxIdx, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags, bool userInterrupt, uint32_t externalInterruptId) { waitUserFenceParams.push_back({ctxIdx, address, value, dataWidth, timeout, flags}); - return Drm::waitUserFence(ctxIdx, address, value, dataWidth, timeout, flags); + return Drm::waitUserFence(ctxIdx, address, value, dataWidth, timeout, flags, userInterrupt, externalInterruptId); } int DrmMockEngine::handleRemainingRequests(DrmIoctl request, void *arg) { if ((request == DrmIoctl::query) && (arg != nullptr)) { diff --git a/shared/test/common/libult/linux/drm_mock.h b/shared/test/common/libult/linux/drm_mock.h index 65a94cd3f5..d62a38cf18 100644 --- a/shared/test/common/libult/linux/drm_mock.h +++ b/shared/test/common/libult/linux/drm_mock.h @@ -68,7 +68,7 @@ class DrmMock : public Drm { return errnoRetVal; } - int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags) override; + int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags, bool userInterrupt, uint32_t externalInterruptId) override; void writeConfigFile(const char *name, int deviceID) { std::ofstream tempfile(name, std::ios::binary); diff --git a/shared/test/common/libult/ult_command_stream_receiver.h b/shared/test/common/libult/ult_command_stream_receiver.h index 28f37f2798..2dc4dee993 100644 --- a/shared/test/common/libult/ult_command_stream_receiver.h +++ b/shared/test/common/libult/ult_command_stream_receiver.h @@ -29,6 +29,8 @@ struct WaitUserFenceParams { uint64_t latestWaitedValue = 0; int64_t latestWaitedTimeout = 0; uint32_t callCount = 0; + uint32_t externalInterruptId = NEO::InterruptId::notUsed; + bool userInterrupt = false; bool forceRetStatusEnabled = false; bool forceRetStatusValue = true; }; @@ -461,17 +463,19 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw, publ BaseClass::stopDirectSubmission(blocking); } - bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout) override { + bool waitUserFence(TaskCountType waitValue, uint64_t hostAddress, int64_t timeout, bool userInterrupt, uint32_t externalInterruptId) override { waitUserFenecParams.callCount++; waitUserFenecParams.latestWaitedAddress = hostAddress; waitUserFenecParams.latestWaitedValue = waitValue; waitUserFenecParams.latestWaitedTimeout = timeout; + waitUserFenecParams.userInterrupt = timeout; + waitUserFenecParams.externalInterruptId = externalInterruptId; if (waitUserFenecParams.forceRetStatusEnabled) { return waitUserFenecParams.forceRetStatusValue; } - return BaseClass::waitUserFence(waitValue, hostAddress, timeout); + return BaseClass::waitUserFence(waitValue, hostAddress, timeout, userInterrupt, externalInterruptId); } std::vector aubCommentMessages; diff --git a/shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h b/shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h index f2351b31b9..87db73d34a 100644 --- a/shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h +++ b/shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h @@ -106,12 +106,12 @@ class TestedDrmCommandStreamReceiver : public DrmCommandStreamReceiverwaitUserFence(1, commandStreamReceiver->getCompletionAddress(), -1)); + EXPECT_FALSE(commandStreamReceiver->waitUserFence(1, commandStreamReceiver->getCompletionAddress(), -1, false, InterruptId::notUsed)); } HWTEST_F(CommandStreamReceiverTest, WhenCreatingCsrThenDefaultValuesAreSet) { diff --git a/shared/test/unit_test/os_interface/linux/drm_command_stream_xehp_and_later_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_command_stream_xehp_and_later_prelim_tests.cpp index ada327436c..15c1f8ebd7 100644 --- a/shared/test/unit_test/os_interface/linux/drm_command_stream_xehp_and_later_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_command_stream_xehp_and_later_prelim_tests.cpp @@ -217,6 +217,57 @@ HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTestDrmPrelim, givenWaitUserFenceEnab EXPECT_EQ(-1, mock->context.receivedGemWaitUserFence.timeout); } +HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTestDrmPrelim, givenExternalInterruptIdWhenWaitingTheExecuteFenceWaitOnce) { + if (!FamilyType::supportsCmdSet(IGFX_XE_HP_CORE)) { + GTEST_SKIP(); + } + + auto osContextLinux = static_cast(device->getDefaultEngine().osContext); + std::vector &drmCtxIds = const_cast &>(osContextLinux->getDrmContextIds()); + size_t drmCtxSize = drmCtxIds.size(); + for (uint32_t i = 0; i < drmCtxSize; i++) { + drmCtxIds[i] = 5u + i; + } + + auto testDrmCsr = static_cast *>(csr); + testDrmCsr->useUserFenceWait = true; + testDrmCsr->activePartitions = 2u; + EXPECT_NE(0u, testDrmCsr->immWritePostSyncWriteOffset); + + auto rootExecEnvironment = executionEnvironment->rootDeviceEnvironments[0].get(); + auto &gfxCoreHelper = rootExecEnvironment->getHelper(); + auto hwInfo = rootExecEnvironment->getHardwareInfo(); + + auto osContext = std::make_unique(*mock, rootDeviceIndex, 0, + EngineDescriptorHelper::getDefaultDescriptor(gfxCoreHelper.getGpgpuEngineInstances(*rootExecEnvironment)[0], + PreemptionHelper::getDefaultPreemptionMode(*hwInfo), DeviceBitfield(3))); + + osContext->ensureContextInitialized(); + osContext->incRefInternal(); + + device->getMemoryManager()->unregisterEngineForCsr(testDrmCsr); + + device->allEngines[0].osContext = osContext.get(); + + testDrmCsr->setupContext(*osContext); + + auto tagPtr = testDrmCsr->getTagAddress(); + *tagPtr = 0; + + tagPtr = ptrOffset(tagPtr, testDrmCsr->immWritePostSyncWriteOffset); + *tagPtr = 0; + + uint64_t tagAddress = castToUint64(const_cast(testDrmCsr->getTagAddress())); + + EXPECT_EQ(0u, mock->context.gemWaitUserFenceCalled); + + testDrmCsr->waitUserFence(123, tagAddress, 1, true, NEO::InterruptId::notUsed); + EXPECT_EQ(2u, mock->context.gemWaitUserFenceCalled); + + testDrmCsr->waitUserFence(123, tagAddress, 1, true, 0x678); + EXPECT_EQ(3u, mock->context.gemWaitUserFenceCalled); +} + HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTestDrmPrelim, givenFailingIoctlWhenWaitingThenDoEarlyReturn) { if (!FamilyType::supportsCmdSet(IGFX_XE_HP_CORE)) { GTEST_SKIP(); diff --git a/shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp index 3de7d5fde8..cf6765bae9 100644 --- a/shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp @@ -502,7 +502,7 @@ TEST(DrmBufferObjectTestPrelim, givenProvidedCtxIdWhenCallingWaitUserFenceThenEx uint64_t gpuAddress = 0x1020304000ull; uint64_t value = 0x98765ull; - drm.waitUserFence(10u, gpuAddress, value, Drm::ValueWidth::u8, -1, 0u); + drm.waitUserFence(10u, gpuAddress, value, Drm::ValueWidth::u8, -1, 0u, false, NEO::InterruptId::notUsed); EXPECT_EQ(1u, drm.context.waitUserFenceCalled); const auto &waitUserFence = drm.context.receivedWaitUserFence; @@ -523,7 +523,7 @@ TEST(DrmBufferObjectTestPrelim, givenProvidedNoCtxIdWhenCallingWaitUserFenceThen uint64_t gpuAddress = 0x1020304000ull; uint64_t value = 0x98765ull; - drm.waitUserFence(0u, gpuAddress, value, Drm::ValueWidth::u16, 2, 3u); + drm.waitUserFence(0u, gpuAddress, value, Drm::ValueWidth::u16, 2, 3u, false, NEO::InterruptId::notUsed); EXPECT_EQ(1u, drm.context.waitUserFenceCalled); const auto &waitUserFence = drm.context.receivedWaitUserFence; @@ -545,7 +545,7 @@ TEST(DrmTestPrelim, givenHungContextWhenCallingWaitUserFenceThenSmallTimeoutIsPa uint64_t memory = 0; uint64_t value = 20; - drm.waitOnUserFences(osContext, reinterpret_cast(&memory), value, 1, -1, 0); + drm.waitOnUserFences(osContext, reinterpret_cast(&memory), value, 1, -1, 0, false, NEO::InterruptId::notUsed); EXPECT_EQ(osContext.getDrmContextIds().size(), drm.context.waitUserFenceCalled); const auto &waitUserFence = drm.context.receivedWaitUserFence; diff --git a/shared/test/unit_test/os_interface/linux/drm_vm_bind_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_vm_bind_prelim_tests.cpp index 55148ba9b0..f6cce6b603 100644 --- a/shared/test/unit_test/os_interface/linux/drm_vm_bind_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_vm_bind_prelim_tests.cpp @@ -127,7 +127,7 @@ TEST(DrmVmBindTest, givenBoNotRequiringExplicitResidencyWhenCallingWaitForBindTh struct DrmQueryMockToTestWaitForBind : public DrmQueryMock { using DrmQueryMock::DrmQueryMock; - int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags) override { + int waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWidth dataWidth, int64_t timeout, uint16_t flags, bool userInterrupt, uint32_t externalInterruptId) override { waitUserFenceCalled = true; return 0; }