Skip to content

Commit 3b35ba5

Browse files
zzdanowiczCompute-Runtime-Automation
zzdanowicz
authored and
Compute-Runtime-Automation
committed
Adapt command stream receiver to multiple active partitions
Related-To: NEO-6244 Signed-off-by: Zbigniew Zdanowicz <[email protected]>
1 parent 3bb2985 commit 3b35ba5

40 files changed

+208
-202
lines changed

‎level_zero/core/source/cmdqueue/cmdqueue.cpp‎

Lines changed: 6 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ ze_result_t CommandQueueImp::initialize(bool copyOnly, bool isInternal) {
6060
void CommandQueueImp::reserveLinearStreamSize(size_t size) {
6161
UNRECOVERABLE_IF(commandStream == nullptr);
6262
if (commandStream->getAvailableSpace() < size) {
63-
buffers.switchBuffers(csr, partitionCount, addressOffset);
63+
buffers.switchBuffers(csr);
6464
NEO::GraphicsAllocation *nextBufferAllocation = buffers.getCurrentBufferAllocation();
6565
commandStream->replaceBuffer(nextBufferAllocation->getUnderlyingBuffer(),
6666
defaultQueueCmdBufferSize);
@@ -79,14 +79,15 @@ void CommandQueueImp::submitBatchBuffer(size_t offset, NEO::ResidencyContainer &
7979
commandStream->getGraphicsAllocation()->updateTaskCount(csr->peekTaskCount() + 1, csr->getOsContext().getContextId());
8080
commandStream->getGraphicsAllocation()->updateResidencyTaskCount(csr->peekTaskCount() + 1, csr->getOsContext().getContextId());
8181

82+
csr->setActivePartitions(partitionCount);
8283
csr->submitBatchBuffer(batchBuffer, csr->getResidencyAllocations());
8384
buffers.setCurrentFlushStamp(csr->peekTaskCount(), csr->obtainCurrentFlushStamp());
8485
}
8586

8687
ze_result_t CommandQueueImp::synchronize(uint64_t timeout) {
8788
if ((timeout == std::numeric_limits<uint64_t>::max()) && useKmdWaitFunction) {
8889
auto &waitPair = buffers.getCurrentFlushStamp();
89-
csr->waitForTaskCountWithKmdNotifyFallback(waitPair.first, waitPair.second, false, false, partitionCount, addressOffset);
90+
csr->waitForTaskCountWithKmdNotifyFallback(waitPair.first, waitPair.second, false, false);
9091
postSyncOperations();
9192
return ZE_RESULT_SUCCESS;
9293
} else {
@@ -105,12 +106,7 @@ ze_result_t CommandQueueImp::synchronizeByPollingForTaskCount(uint64_t timeout)
105106
timeoutMicroseconds = NEO::TimeoutControls::maxTimeout;
106107
}
107108

108-
bool ready = false;
109-
if (partitionCount > 1) {
110-
ready = csr->waitForCompletionWithTimeout(csr->getTagAddress(), enableTimeout, timeoutMicroseconds, taskCountToWait, partitionCount, addressOffset);
111-
} else {
112-
ready = csr->waitForCompletionWithTimeout(enableTimeout, timeoutMicroseconds, taskCountToWait);
113-
}
109+
bool ready = csr->waitForCompletionWithTimeout(enableTimeout, timeoutMicroseconds, taskCountToWait);
114110
if (!ready) {
115111
return ZE_RESULT_NOT_READY;
116112
}
@@ -196,7 +192,7 @@ void CommandQueueImp::CommandBufferManager::destroy(NEO::MemoryManager *memoryMa
196192
}
197193
}
198194

199-
void CommandQueueImp::CommandBufferManager::switchBuffers(NEO::CommandStreamReceiver *csr, uint32_t partitionCount, uint32_t offsetSize) {
195+
void CommandQueueImp::CommandBufferManager::switchBuffers(NEO::CommandStreamReceiver *csr) {
200196
if (bufferUse == BUFFER_ALLOCATION::FIRST) {
201197
bufferUse = BUFFER_ALLOCATION::SECOND;
202198
} else {
@@ -206,7 +202,7 @@ void CommandQueueImp::CommandBufferManager::switchBuffers(NEO::CommandStreamRece
206202
auto completionId = flushId[bufferUse];
207203
if (completionId.second != 0u) {
208204
UNRECOVERABLE_IF(csr == nullptr);
209-
csr->waitForTaskCountWithKmdNotifyFallback(completionId.first, completionId.second, false, false, partitionCount, offsetSize);
205+
csr->waitForTaskCountWithKmdNotifyFallback(completionId.first, completionId.second, false, false);
210206
}
211207
}
212208

‎level_zero/core/source/cmdqueue/cmdqueue_hw.inl‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -139,6 +139,7 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::executeCommandLists(
139139
}
140140

141141
bool directSubmissionEnabled = isCopyOnlyCommandQueue ? csr->isBlitterDirectSubmissionEnabled() : csr->isDirectSubmissionEnabled();
142+
partitionCount = csr->getActivePartitions();
142143

143144
L0::Fence *fence = nullptr;
144145

@@ -417,7 +418,7 @@ ze_result_t CommandQueueHw<gfxCoreFamily>::executeCommandLists(
417418
workPartitionAddress);
418419
NEO::EncodeSetMMIO<GfxFamily>::encodeIMM(child,
419420
NEO::PartitionRegisters<GfxFamily>::addressOffsetCCSOffset,
420-
addressOffset,
421+
CommonConstants::partitionAddressOffset,
421422
true);
422423
}
423424

‎level_zero/core/source/cmdqueue/cmdqueue_imp.h‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ struct CommandQueueImp : public CommandQueue {
3737

3838
ze_result_t initialize(Device *device, size_t sizeRequested);
3939
void destroy(NEO::MemoryManager *memoryManager);
40-
void switchBuffers(NEO::CommandStreamReceiver *csr, uint32_t partitionCount, uint32_t offsetSize);
40+
void switchBuffers(NEO::CommandStreamReceiver *csr);
4141

4242
NEO::GraphicsAllocation *getCurrentBufferAllocation() {
4343
return buffers[bufferUse];
@@ -62,9 +62,6 @@ struct CommandQueueImp : public CommandQueue {
6262
MemoryConstants::cacheLineSize +
6363
NEO::CSRequirements::csOverfetchSize;
6464

65-
static constexpr uint32_t addressOffsetDwords = 2u;
66-
static constexpr uint32_t addressOffset = sizeof(uint32_t) * addressOffsetDwords;
67-
6865
CommandQueueImp() = delete;
6966
CommandQueueImp(Device *device, NEO::CommandStreamReceiver *csr, const ze_command_queue_desc_t *desc);
7067

‎level_zero/core/source/fence/fence.cpp‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -42,26 +42,28 @@ ze_result_t FenceImp::queryStatus() {
4242
if (queryVal == Fence::STATE_CLEARED) {
4343
break;
4444
}
45-
hostAddr = ptrOffset(hostAddr, CommandQueueImp::addressOffset);
45+
hostAddr = ptrOffset(hostAddr, CommonConstants::partitionAddressOffset);
4646
}
4747
return queryVal == Fence::STATE_CLEARED ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
4848
}
4949

5050
void FenceImp::initialize() {
5151
NEO::AllocationProperties properties(
52-
cmdQueue->getDevice()->getRootDeviceIndex(), MemoryConstants::cacheLineSize, NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, cmdQueue->getDevice()->getNEODevice()->getDeviceBitfield());
53-
properties.alignment = MemoryConstants::cacheLineSize;
52+
cmdQueue->getDevice()->getRootDeviceIndex(), MemoryConstants::pageSize, NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, cmdQueue->getDevice()->getNEODevice()->getDeviceBitfield());
53+
properties.alignment = MemoryConstants::pageSize;
5454
allocation = cmdQueue->getDevice()->getDriverHandle()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
5555
UNRECOVERABLE_IF(allocation == nullptr);
56+
5657
reset();
5758
}
5859

5960
ze_result_t FenceImp::reset() {
61+
constexpr uint32_t maxPartitionCount = 16;
6062
volatile uint32_t *hostAddress = static_cast<uint32_t *>(allocation->getUnderlyingBuffer());
61-
for (uint32_t i = 0; i < partitionCount; i++) {
63+
for (uint32_t i = 0; i < maxPartitionCount; i++) {
6264
*hostAddress = Fence::STATE_CLEARED;
6365
NEO::CpuIntrinsics::clFlush(const_cast<uint32_t *>(hostAddress));
64-
hostAddress = ptrOffset(hostAddress, CommandQueueImp::addressOffset);
66+
hostAddress = ptrOffset(hostAddress, CommonConstants::partitionAddressOffset);
6567
}
6668
partitionCount = 1;
6769
return ZE_RESULT_SUCCESS;

‎level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue.cpp‎

Lines changed: 49 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -1521,42 +1521,36 @@ using CommandQueueSynchronizeTest = Test<ContextFixture>;
15211521
template <typename GfxFamily>
15221522
struct SynchronizeCsr : public NEO::UltCommandStreamReceiver<GfxFamily> {
15231523
~SynchronizeCsr() override {
1524-
delete tagAddress;
1524+
delete[] tagAddress;
15251525
}
15261526

15271527
SynchronizeCsr(const NEO::ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
15281528
: NEO::UltCommandStreamReceiver<GfxFamily>(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment), 0, deviceBitfield) {
1529-
tagAddress = new uint32_t;
1530-
}
1531-
1532-
bool waitForCompletionWithTimeout(volatile uint32_t *pollAddress, bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait, uint32_t partitionCount, uint32_t offsetSize) override {
1533-
enableTimeoutSet = enableTimeout;
1534-
partitionCountSet = partitionCount;
1535-
offsetSizeSet = offsetSize;
1536-
waitForComplitionCalledTimes++;
1537-
return true;
1529+
tagAddress = new uint32_t[tagSize];
1530+
memset(tagAddress, 0xFFFFFFFF, tagSize * sizeof(uint32_t));
15381531
}
15391532

15401533
bool waitForCompletionWithTimeout(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait) override {
15411534
enableTimeoutSet = enableTimeout;
15421535
waitForComplitionCalledTimes++;
1536+
partitionCountSet = this->activePartitions;
15431537
return true;
15441538
}
15451539

1546-
void waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, bool forcePowerSavingMode, uint32_t partitionCount, uint32_t offsetSize) override {
1540+
void waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, bool forcePowerSavingMode) override {
15471541
waitForTaskCountWithKmdNotifyFallbackCalled++;
1548-
NEO::UltCommandStreamReceiver<GfxFamily>::waitForTaskCountWithKmdNotifyFallback(taskCountToWait, flushStampToWait, quickKmdSleep, forcePowerSavingMode, partitionCount, offsetSize);
1542+
NEO::UltCommandStreamReceiver<GfxFamily>::waitForTaskCountWithKmdNotifyFallback(taskCountToWait, flushStampToWait, quickKmdSleep, forcePowerSavingMode);
15491543
}
15501544

15511545
volatile uint32_t *getTagAddress() const override {
15521546
return tagAddress;
15531547
}
15541548

1549+
static constexpr size_t tagSize = 64;
15551550
uint32_t *tagAddress;
15561551
uint32_t waitForComplitionCalledTimes = 0;
15571552
uint32_t waitForTaskCountWithKmdNotifyFallbackCalled = 0;
15581553
uint32_t partitionCountSet = 0;
1559-
uint32_t offsetSizeSet = 0;
15601554
bool enableTimeoutSet = false;
15611555
};
15621556

@@ -1634,73 +1628,81 @@ HWTEST_F(CommandQueueSynchronizeTest, givenDebugOverrideEnabledWhenCallToSynchro
16341628
}
16351629

16361630
HWTEST_F(CommandQueueSynchronizeTest, givenMultiplePartitionCountWhenCallingSynchronizeThenExpectTheSameNumberCsrSynchronizeCalls) {
1637-
auto csr = std::unique_ptr<SynchronizeCsr<FamilyType>>(new SynchronizeCsr<FamilyType>(*device->getNEODevice()->getExecutionEnvironment(),
1638-
device->getNEODevice()->getDeviceBitfield()));
1639-
csr->setupContext(*device->getNEODevice()->getDefaultEngine().osContext);
1640-
16411631
const ze_command_queue_desc_t desc{};
16421632
ze_result_t returnValue;
1633+
1634+
auto csr = reinterpret_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(neoDevice->getDefaultEngine().commandStreamReceiver);
1635+
volatile uint32_t *tagAddress = csr->getTagAddress();
1636+
for (uint32_t i = 0; i < 2; i++) {
1637+
*tagAddress = 0xFF;
1638+
tagAddress = ptrOffset(tagAddress, 8);
1639+
}
16431640
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
16441641
device,
1645-
csr.get(),
1642+
neoDevice->getDefaultEngine().commandStreamReceiver,
16461643
&desc,
16471644
false,
16481645
false,
16491646
returnValue));
16501647
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
16511648
ASSERT_NE(nullptr, commandQueue);
16521649

1653-
commandQueue->partitionCount = 2;
1650+
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
1651+
ASSERT_NE(nullptr, commandList);
1652+
commandList->partitionCount = 2;
1653+
1654+
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
1655+
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false);
1656+
16541657
uint64_t timeout = std::numeric_limits<uint64_t>::max();
16551658
commandQueue->synchronize(timeout);
16561659

1657-
EXPECT_EQ(1u, csr->waitForComplitionCalledTimes);
1658-
EXPECT_EQ(2u, csr->partitionCountSet);
1659-
EXPECT_EQ(8u, csr->offsetSizeSet);
1660+
EXPECT_EQ(2u, csr->activePartitions);
16601661

16611662
L0::CommandQueue::fromHandle(commandQueue)->destroy();
16621663
}
16631664

1664-
template <typename GfxFamily>
1665-
struct TestCmdQueueCsr : public NEO::UltCommandStreamReceiver<GfxFamily> {
1666-
TestCmdQueueCsr(const NEO::ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
1667-
: NEO::UltCommandStreamReceiver<GfxFamily>(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment), 0, deviceBitfield) {
1668-
}
1669-
MOCK_METHOD3(waitForCompletionWithTimeout, bool(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait));
1670-
MOCK_METHOD6(waitForCompletionWithTimeout, bool(volatile uint32_t *pollAddress, bool enableTimeout, int64_t timeoutMicroseconds, uint32_t taskCountToWait, uint32_t partitionCount, uint32_t offsetSize));
1671-
};
1672-
1673-
HWTEST_F(CommandQueueSynchronizeTest, givenSinglePartitionCountWhenWaitFunctionFailsThenReturnNotReady) {
1674-
auto csr = std::unique_ptr<TestCmdQueueCsr<FamilyType>>(new TestCmdQueueCsr<FamilyType>(*device->getNEODevice()->getExecutionEnvironment(),
1675-
device->getNEODevice()->getDeviceBitfield()));
1676-
csr->setupContext(*device->getNEODevice()->getDefaultEngine().osContext);
1677-
1665+
HWTEST_F(CommandQueueSynchronizeTest, givenCsrHasMultipleActivePartitionWhenExecutingCmdListOnNewCmdQueueThenExpectCmdPartitionCountMatchCsrActivePartitions) {
16781666
const ze_command_queue_desc_t desc{};
16791667
ze_result_t returnValue;
1668+
1669+
auto csr = reinterpret_cast<NEO::UltCommandStreamReceiver<FamilyType> *>(neoDevice->getDefaultEngine().commandStreamReceiver);
1670+
volatile uint32_t *tagAddress = csr->getTagAddress();
1671+
for (uint32_t i = 0; i < 2; i++) {
1672+
*tagAddress = 0xFF;
1673+
tagAddress = ptrOffset(tagAddress, 8);
1674+
}
1675+
csr->activePartitions = 2u;
16801676
auto commandQueue = whitebox_cast(CommandQueue::create(productFamily,
16811677
device,
1682-
csr.get(),
1678+
neoDevice->getDefaultEngine().commandStreamReceiver,
16831679
&desc,
16841680
false,
16851681
false,
16861682
returnValue));
16871683
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
16881684
ASSERT_NE(nullptr, commandQueue);
16891685

1690-
EXPECT_CALL(*csr, waitForCompletionWithTimeout(::testing::_,
1691-
::testing::_,
1692-
::testing::_))
1693-
.Times(1)
1694-
.WillOnce(::testing::Return(false));
1686+
auto commandList = std::unique_ptr<CommandList>(whitebox_cast(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)));
1687+
ASSERT_NE(nullptr, commandList);
16951688

1696-
uint64_t timeout = std::numeric_limits<uint64_t>::max();
1697-
returnValue = commandQueue->synchronize(timeout);
1698-
EXPECT_EQ(returnValue, ZE_RESULT_NOT_READY);
1689+
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
1690+
commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false);
16991691

1700-
commandQueue->destroy();
1692+
EXPECT_EQ(2u, commandQueue->partitionCount);
1693+
1694+
L0::CommandQueue::fromHandle(commandQueue)->destroy();
17011695
}
17021696

1703-
HWTEST_F(CommandQueueSynchronizeTest, givenMultiplePartitionCountWhenWaitFunctionFailsThenReturnNotReady) {
1697+
template <typename GfxFamily>
1698+
struct TestCmdQueueCsr : public NEO::UltCommandStreamReceiver<GfxFamily> {
1699+
TestCmdQueueCsr(const NEO::ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
1700+
: NEO::UltCommandStreamReceiver<GfxFamily>(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment), 0, deviceBitfield) {
1701+
}
1702+
MOCK_METHOD3(waitForCompletionWithTimeout, bool(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait));
1703+
};
1704+
1705+
HWTEST_F(CommandQueueSynchronizeTest, givenSinglePartitionCountWhenWaitFunctionFailsThenReturnNotReady) {
17041706
auto csr = std::unique_ptr<TestCmdQueueCsr<FamilyType>>(new TestCmdQueueCsr<FamilyType>(*device->getNEODevice()->getExecutionEnvironment(),
17051707
device->getNEODevice()->getDeviceBitfield()));
17061708
csr->setupContext(*device->getNEODevice()->getDefaultEngine().osContext);
@@ -1718,15 +1720,11 @@ HWTEST_F(CommandQueueSynchronizeTest, givenMultiplePartitionCountWhenWaitFunctio
17181720
ASSERT_NE(nullptr, commandQueue);
17191721

17201722
EXPECT_CALL(*csr, waitForCompletionWithTimeout(::testing::_,
1721-
::testing::_,
1722-
::testing::_,
1723-
::testing::_,
17241723
::testing::_,
17251724
::testing::_))
17261725
.Times(1)
17271726
.WillOnce(::testing::Return(false));
17281727

1729-
commandQueue->partitionCount = 2;
17301728
uint64_t timeout = std::numeric_limits<uint64_t>::max();
17311729
returnValue = commandQueue->synchronize(timeout);
17321730
EXPECT_EQ(returnValue, ZE_RESULT_NOT_READY);

‎level_zero/core/test/unit_tests/sources/fence/test_fence.cpp‎

Lines changed: 13 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -131,21 +131,28 @@ TEST_F(FenceSynchronizeTest, givenMultiplePartitionsWhenFenceIsResetThenAllParti
131131

132132
auto fence = whitebox_cast(Fence::create(&cmdQueue, nullptr));
133133
EXPECT_NE(nullptr, fence);
134-
135-
fence->partitionCount = 2;
136134
auto alloc = &(fence->getAllocation());
137135
auto hostAddr = static_cast<uint32_t *>(alloc->getUnderlyingBuffer());
136+
137+
for (uint32_t i = 0; i < 16; i++) {
138+
EXPECT_EQ(Fence::STATE_CLEARED, *hostAddr);
139+
hostAddr = ptrOffset(hostAddr, 8);
140+
}
141+
142+
hostAddr = static_cast<uint32_t *>(alloc->getUnderlyingBuffer());
143+
fence->partitionCount = 2;
138144
*hostAddr = Fence::STATE_SIGNALED;
139-
hostAddr = ptrOffset(hostAddr, CommandQueueImp::addressOffset);
145+
hostAddr = ptrOffset(hostAddr, 8);
140146
*hostAddr = Fence::STATE_SIGNALED;
141147

142148
ze_result_t result = fence->reset();
143149
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
144150

145151
hostAddr = static_cast<uint32_t *>(alloc->getUnderlyingBuffer());
146-
EXPECT_EQ(Fence::STATE_CLEARED, *hostAddr);
147-
hostAddr = ptrOffset(hostAddr, CommandQueueImp::addressOffset);
148-
EXPECT_EQ(Fence::STATE_CLEARED, *hostAddr);
152+
for (uint32_t i = 0; i < 16; i++) {
153+
EXPECT_EQ(Fence::STATE_CLEARED, *hostAddr);
154+
hostAddr = ptrOffset(hostAddr, 8);
155+
}
149156
EXPECT_EQ(1u, fence->partitionCount);
150157

151158
fence->destroy();

‎opencl/source/command_queue/command_queue.cpp‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -199,9 +199,7 @@ void CommandQueue::waitUntilComplete(uint32_t gpgpuTaskCountToWait, uint32_t bcs
199199
getGpgpuCommandStreamReceiver().waitForTaskCountWithKmdNotifyFallback(gpgpuTaskCountToWait,
200200
flushStampToWait,
201201
useQuickKmdSleep,
202-
forcePowerSavingMode,
203-
1u,
204-
0u);
202+
forcePowerSavingMode);
205203
DEBUG_BREAK_IF(getHwTag() < gpgpuTaskCountToWait);
206204

207205
if (gtpinIsGTPinInitialized()) {
@@ -210,7 +208,7 @@ void CommandQueue::waitUntilComplete(uint32_t gpgpuTaskCountToWait, uint32_t bcs
210208

211209
if (bcsEngine) {
212210
auto bcsCsr = getBcsCommandStreamReceiver(bcsEngine->getEngineType());
213-
bcsCsr->waitForTaskCountWithKmdNotifyFallback(bcsTaskCountToWait, 0, false, false, 1u, 0u);
211+
bcsCsr->waitForTaskCountWithKmdNotifyFallback(bcsTaskCountToWait, 0, false, false);
214212
bcsCsr->waitForTaskCountAndCleanTemporaryAllocationList(bcsTaskCountToWait);
215213
}
216214

‎opencl/test/unit_test/command_stream/aub_file_stream_tests.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -319,7 +319,7 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenCallingInsertAubWa
319319
auto aubExecutionEnvironment = getEnvironment<MockAubCsr<FamilyType>>(true, true, true);
320320
auto aubCsr = aubExecutionEnvironment->template getCsr<MockAubCsr<FamilyType>>();
321321
ASSERT_FALSE(aubCsr->pollForCompletionCalled);
322-
aubCsr->waitForTaskCountWithKmdNotifyFallback(0, 0, false, false, 1, 0);
322+
aubCsr->waitForTaskCountWithKmdNotifyFallback(0, 0, false, false);
323323
EXPECT_TRUE(aubCsr->pollForCompletionCalled);
324324
}
325325

0 commit comments

Comments
 (0)