Skip to content

Commit 5986a71

Browse files
zzdanowiczCompute-Runtime-Automation
zzdanowicz
authored and
Compute-Runtime-Automation
committed
Share front end state updates between regular and immediate command lists
Related-To: NEO-5019 Signed-off-by: Zbigniew Zdanowicz <[email protected]>
1 parent 7f0619e commit 5986a71

File tree

16 files changed

+415
-22
lines changed

16 files changed

+415
-22
lines changed

‎level_zero/core/source/cmdlist/cmdlist_hw.inl‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2315,12 +2315,10 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel
23152315
using VFE_STATE_TYPE = typename GfxFamily::VFE_STATE_TYPE;
23162316

23172317
auto &hwInfo = device->getHwInfo();
2318-
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);
2319-
auto disableOverdispatch = hwInfoConfig.isDisableOverdispatchAvailable(hwInfo);
23202318

23212319
auto &kernelAttributes = kernel.getKernelDescriptor().kernelAttributes;
23222320
if (!containsAnyKernel) {
2323-
requiredStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, disableOverdispatch, -1, hwInfo);
2321+
requiredStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, true, -1, hwInfo);
23242322
requiredStreamState.pipelineSelect.setProperties(true, false, kernelAttributes.flags.usesSystolicPipelineSelectMode, hwInfo);
23252323
finalStreamState = requiredStreamState;
23262324
requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo);
@@ -2340,7 +2338,7 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel
23402338
hwInfo);
23412339
}
23422340

2343-
finalStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, disableOverdispatch, -1, hwInfo);
2341+
finalStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, true, -1, hwInfo);
23442342
bool isPatchingVfeStateAllowed = NEO::DebugManager.flags.AllowPatchingVfeStateInCommandLists.get();
23452343
if (finalStreamState.frontEndState.isDirty() && logicalStateHelperBlock) {
23462344
if (isPatchingVfeStateAllowed) {

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

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -622,18 +622,16 @@ size_t CommandQueueHw<gfxCoreFamily>::estimateLinearStreamSizeInitial(
622622
template <GFXCORE_FAMILY gfxCoreFamily>
623623
void CommandQueueHw<gfxCoreFamily>::setFrontEndStateProperties(CommandListExecutionContext &ctx) {
624624
const auto &hwInfo = this->device->getHwInfo();
625-
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);
626-
auto disableOverdispatch = hwInfoConfig.isDisableOverdispatchAvailable(hwInfo);
627625

628626
auto isEngineInstanced = csr->getOsContext().isEngineInstanced();
629627
auto &streamProperties = this->csr->getStreamProperties();
630628
if (!frontEndTrackingEnabled()) {
631629
streamProperties.frontEndState.setProperties(ctx.anyCommandListWithCooperativeKernels, ctx.anyCommandListRequiresDisabledEUFusion,
632-
disableOverdispatch, isEngineInstanced, hwInfo);
630+
true, isEngineInstanced, hwInfo);
631+
ctx.frontEndStateDirty |= (streamProperties.frontEndState.isDirty() && !this->csr->getLogicalStateHelper());
633632
} else {
634633
ctx.engineInstanced = isEngineInstanced;
635634
}
636-
ctx.frontEndStateDirty |= (streamProperties.frontEndState.isDirty() && !this->csr->getLogicalStateHelper());
637635
ctx.frontEndStateDirty |= csr->getMediaVFEStateDirty();
638636
}
639637

‎level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -97,6 +97,8 @@ void ModuleMutableCommandListFixture::setUp(uint32_t revision) {
9797
NEO::EngineGroupType engineGroupType = NEO::HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).getEngineGroupType(neoDevice->getDefaultEngine().getEngineType(), neoDevice->getDefaultEngine().getEngineUsage(), device->getHwInfo());
9898

9999
commandList.reset(whiteboxCast(CommandList::create(productFamily, device, engineGroupType, 0u, returnValue)));
100+
commandListImmediate.reset(whiteboxCast(CommandList::createImmediate(productFamily, device, &queueDesc, false, engineGroupType, returnValue)));
101+
commandListImmediate->isFlushTaskSubmissionEnabled = true;
100102

101103
mockKernelImmData = std::make_unique<MockImmutableData>(0u);
102104
createModuleFromMockBinary(0u, false, mockKernelImmData.get());
@@ -108,6 +110,7 @@ void ModuleMutableCommandListFixture::setUp(uint32_t revision) {
108110
void ModuleMutableCommandListFixture::tearDown() {
109111
commandQueue->destroy();
110112
commandList.reset(nullptr);
113+
commandListImmediate.reset(nullptr);
111114
kernel.reset(nullptr);
112115
mockKernelImmData.reset(nullptr);
113116
ModuleImmutableDataFixture::tearDown();

‎level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,7 @@ struct ModuleMutableCommandListFixture : public ModuleImmutableDataFixture {
7575

7676
std::unique_ptr<MockImmutableData> mockKernelImmData;
7777
std::unique_ptr<L0::ult::CommandList> commandList;
78+
std::unique_ptr<L0::ult::CommandList> commandListImmediate;
7879
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
7980
L0::ult::CommandQueue *commandQueue;
8081
};

‎level_zero/core/test/unit_tests/mocks/mock_cmdlist.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -146,6 +146,7 @@ struct WhiteBox<::L0::CommandList> : public ::L0::CommandListImp {
146146
using BaseClass::commandListPreemptionMode;
147147
using BaseClass::csr;
148148
using BaseClass::initialize;
149+
using BaseClass::isFlushTaskSubmissionEnabled;
149150
using BaseClass::multiReturnPointCommandList;
150151
using BaseClass::nonImmediateLogicalStateHelper;
151152
using BaseClass::partitionCount;

‎level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_6.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ HWTEST2_F(CommandListExecuteImmediate, whenExecutingCommandListImmediateWithFlus
7676
NEO::FrontEndPropertiesSupport frontEndPropertiesSupport = {};
7777
hwInfoConfig.fillFrontEndPropertiesSupportStructure(frontEndPropertiesSupport, device->getHwInfo());
7878

79-
int expectedDisableOverdispatch = hwInfoConfig.isDisableOverdispatchAvailable(*defaultHwInfo);
79+
int expectedDisableOverdispatch = frontEndPropertiesSupport.disableOverdispatch;
8080
int32_t expectedIsCoherencyRequired = scmPropertiesSupport.coherencyRequired ? hwHelper.forceNonGpuCoherencyWA(true) : -1;
8181
int expectedLargeGrfMode = scmPropertiesSupport.largeGrfMode ? 1 : -1;
8282
int expectedThreadArbitrationPolicy = scmPropertiesSupport.threadArbitrationPolicy ? NEO::ThreadArbitrationPolicy::RoundRobin : -1;

‎level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_7.cpp‎

Lines changed: 246 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1384,5 +1384,251 @@ HWTEST2_F(MultiReturnCommandListTest,
13841384
}
13851385
}
13861386

1387+
HWTEST2_F(MultiReturnCommandListTest, givenCmdQueueAndImmediateCmdListUseSameCsrWhenAppendingKernelOnBothRegularFirstThenFrontEndStateIsNotChanged, IsAtLeastSkl) {
1388+
using VFE_STATE_TYPE = typename FamilyType::VFE_STATE_TYPE;
1389+
NEO::FrontEndPropertiesSupport fePropertiesSupport = {};
1390+
NEO::HwInfoConfig::get(productFamily)->fillFrontEndPropertiesSupportStructure(fePropertiesSupport, device->getHwInfo());
1391+
1392+
EXPECT_TRUE(commandList->multiReturnPointCommandList);
1393+
EXPECT_TRUE(commandListImmediate->multiReturnPointCommandList);
1394+
1395+
auto &regularCmdListStream = *commandList->commandContainer.getCommandStream();
1396+
1397+
ze_group_count_t groupCount{1, 1, 1};
1398+
CmdListKernelLaunchParams launchParams = {};
1399+
mockKernelImmData->kernelDescriptor->kernelAttributes.flags.requiresDisabledEUFusion = 1;
1400+
1401+
size_t usedBefore = regularCmdListStream.getUsed();
1402+
ze_result_t result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams);
1403+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1404+
size_t usedAfter = regularCmdListStream.getUsed();
1405+
1406+
auto &regularCmdListRequiredState = commandList->getRequiredStreamState();
1407+
auto &regularCmdListFinalState = commandList->getFinalStreamState();
1408+
1409+
if (fePropertiesSupport.disableEuFusion) {
1410+
EXPECT_EQ(1, regularCmdListRequiredState.frontEndState.disableEUFusion.value);
1411+
EXPECT_EQ(1, regularCmdListFinalState.frontEndState.disableEUFusion.value);
1412+
} else {
1413+
EXPECT_EQ(-1, regularCmdListRequiredState.frontEndState.disableEUFusion.value);
1414+
EXPECT_EQ(-1, regularCmdListFinalState.frontEndState.disableEUFusion.value);
1415+
}
1416+
1417+
GenCmdList cmdList;
1418+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1419+
cmdList,
1420+
ptrOffset(regularCmdListStream.getCpuBase(), usedBefore),
1421+
(usedAfter - usedBefore)));
1422+
auto feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1423+
EXPECT_EQ(0u, feStateCmds.size());
1424+
1425+
auto &cmdQueueStream = commandQueue->commandStream;
1426+
auto cmdListHandle = commandList->toHandle();
1427+
1428+
usedBefore = cmdQueueStream.getUsed();
1429+
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false);
1430+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1431+
usedAfter = cmdQueueStream.getUsed();
1432+
1433+
auto cmdQueueCsr = commandQueue->getCsr();
1434+
auto &csrProperties = cmdQueueCsr->getStreamProperties();
1435+
1436+
if (fePropertiesSupport.disableEuFusion) {
1437+
EXPECT_EQ(1, csrProperties.frontEndState.disableEUFusion.value);
1438+
} else {
1439+
EXPECT_EQ(-1, csrProperties.frontEndState.disableEUFusion.value);
1440+
}
1441+
1442+
cmdList.clear();
1443+
feStateCmds.clear();
1444+
1445+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1446+
cmdList,
1447+
ptrOffset(cmdQueueStream.getCpuBase(), usedBefore),
1448+
(usedAfter - usedBefore)));
1449+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1450+
ASSERT_EQ(1u, feStateCmds.size());
1451+
auto &feState = *genCmdCast<VFE_STATE_TYPE *>(*feStateCmds[0]);
1452+
if (fePropertiesSupport.disableEuFusion) {
1453+
EXPECT_TRUE(NEO::UnitTestHelper<FamilyType>::getDisableFusionStateFromFrontEndCommand(feState));
1454+
} else {
1455+
EXPECT_FALSE(NEO::UnitTestHelper<FamilyType>::getDisableFusionStateFromFrontEndCommand(feState));
1456+
}
1457+
1458+
auto &immediateCmdListStream = *commandListImmediate->commandContainer.getCommandStream();
1459+
auto &ultCsr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
1460+
auto &csrStream = ultCsr.commandStream;
1461+
1462+
size_t csrUsedBefore = csrStream.getUsed();
1463+
usedBefore = immediateCmdListStream.getUsed();
1464+
result = commandListImmediate->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams);
1465+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1466+
usedAfter = immediateCmdListStream.getUsed();
1467+
size_t csrUsedAfter = csrStream.getUsed();
1468+
1469+
auto &immediateCmdListRequiredState = commandListImmediate->getRequiredStreamState();
1470+
auto &immediateCmdListFinalState = commandListImmediate->getFinalStreamState();
1471+
1472+
if (fePropertiesSupport.disableEuFusion) {
1473+
EXPECT_EQ(1, immediateCmdListRequiredState.frontEndState.disableEUFusion.value);
1474+
EXPECT_EQ(1, immediateCmdListFinalState.frontEndState.disableEUFusion.value);
1475+
} else {
1476+
EXPECT_EQ(-1, immediateCmdListRequiredState.frontEndState.disableEUFusion.value);
1477+
EXPECT_EQ(-1, immediateCmdListFinalState.frontEndState.disableEUFusion.value);
1478+
}
1479+
1480+
cmdList.clear();
1481+
feStateCmds.clear();
1482+
1483+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1484+
cmdList,
1485+
ptrOffset(immediateCmdListStream.getCpuBase(), usedBefore),
1486+
(usedAfter - usedBefore)));
1487+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1488+
EXPECT_EQ(0u, feStateCmds.size());
1489+
1490+
auto immediateCsr = commandListImmediate->csr;
1491+
EXPECT_EQ(cmdQueueCsr, immediateCsr);
1492+
1493+
if (fePropertiesSupport.disableEuFusion) {
1494+
EXPECT_EQ(1, csrProperties.frontEndState.disableEUFusion.value);
1495+
} else {
1496+
EXPECT_EQ(-1, csrProperties.frontEndState.disableEUFusion.value);
1497+
}
1498+
1499+
cmdList.clear();
1500+
feStateCmds.clear();
1501+
1502+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1503+
cmdList,
1504+
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
1505+
(csrUsedAfter - csrUsedBefore)));
1506+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1507+
EXPECT_EQ(0u, feStateCmds.size());
1508+
}
1509+
1510+
HWTEST2_F(MultiReturnCommandListTest, givenCmdQueueAndImmediateCmdListUseSameCsrWhenAppendingKernelOnBothImmediateFirstThenFrontEndStateIsNotChanged, IsAtLeastSkl) {
1511+
using VFE_STATE_TYPE = typename FamilyType::VFE_STATE_TYPE;
1512+
NEO::FrontEndPropertiesSupport fePropertiesSupport = {};
1513+
NEO::HwInfoConfig::get(productFamily)->fillFrontEndPropertiesSupportStructure(fePropertiesSupport, device->getHwInfo());
1514+
1515+
EXPECT_TRUE(commandList->multiReturnPointCommandList);
1516+
EXPECT_TRUE(commandListImmediate->multiReturnPointCommandList);
1517+
1518+
auto cmdQueueCsr = commandQueue->getCsr();
1519+
auto &csrProperties = cmdQueueCsr->getStreamProperties();
1520+
1521+
auto immediateCsr = commandListImmediate->csr;
1522+
EXPECT_EQ(cmdQueueCsr, immediateCsr);
1523+
1524+
ze_group_count_t groupCount{1, 1, 1};
1525+
CmdListKernelLaunchParams launchParams = {};
1526+
mockKernelImmData->kernelDescriptor->kernelAttributes.flags.requiresDisabledEUFusion = 1;
1527+
1528+
auto &immediateCmdListStream = *commandListImmediate->commandContainer.getCommandStream();
1529+
auto &ultCsr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
1530+
auto &csrStream = ultCsr.commandStream;
1531+
1532+
size_t csrUsedBefore = csrStream.getUsed();
1533+
size_t usedBefore = immediateCmdListStream.getUsed();
1534+
ze_result_t result = commandListImmediate->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams);
1535+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1536+
size_t usedAfter = immediateCmdListStream.getUsed();
1537+
size_t csrUsedAfter = csrStream.getUsed();
1538+
1539+
auto &immediateCmdListRequiredState = commandListImmediate->getRequiredStreamState();
1540+
auto &immediateCmdListFinalState = commandListImmediate->getFinalStreamState();
1541+
1542+
if (fePropertiesSupport.disableEuFusion) {
1543+
EXPECT_EQ(1, immediateCmdListRequiredState.frontEndState.disableEUFusion.value);
1544+
EXPECT_EQ(1, immediateCmdListFinalState.frontEndState.disableEUFusion.value);
1545+
} else {
1546+
EXPECT_EQ(-1, immediateCmdListRequiredState.frontEndState.disableEUFusion.value);
1547+
EXPECT_EQ(-1, immediateCmdListFinalState.frontEndState.disableEUFusion.value);
1548+
}
1549+
1550+
GenCmdList cmdList;
1551+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1552+
cmdList,
1553+
ptrOffset(immediateCmdListStream.getCpuBase(), usedBefore),
1554+
(usedAfter - usedBefore)));
1555+
auto feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1556+
EXPECT_EQ(0u, feStateCmds.size());
1557+
1558+
if (fePropertiesSupport.disableEuFusion) {
1559+
EXPECT_EQ(1, csrProperties.frontEndState.disableEUFusion.value);
1560+
} else {
1561+
EXPECT_EQ(-1, csrProperties.frontEndState.disableEUFusion.value);
1562+
}
1563+
1564+
cmdList.clear();
1565+
feStateCmds.clear();
1566+
1567+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1568+
cmdList,
1569+
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
1570+
(csrUsedAfter - csrUsedBefore)));
1571+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1572+
ASSERT_EQ(1u, feStateCmds.size());
1573+
auto &feState = *genCmdCast<VFE_STATE_TYPE *>(*feStateCmds[0]);
1574+
if (fePropertiesSupport.disableEuFusion) {
1575+
EXPECT_TRUE(NEO::UnitTestHelper<FamilyType>::getDisableFusionStateFromFrontEndCommand(feState));
1576+
} else {
1577+
EXPECT_FALSE(NEO::UnitTestHelper<FamilyType>::getDisableFusionStateFromFrontEndCommand(feState));
1578+
}
1579+
1580+
auto &regularCmdListStream = *commandList->commandContainer.getCommandStream();
1581+
1582+
usedBefore = regularCmdListStream.getUsed();
1583+
result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams);
1584+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1585+
usedAfter = regularCmdListStream.getUsed();
1586+
1587+
auto &regularCmdListRequiredState = commandList->getRequiredStreamState();
1588+
auto &regularCmdListFinalState = commandList->getFinalStreamState();
1589+
1590+
if (fePropertiesSupport.disableEuFusion) {
1591+
EXPECT_EQ(1, regularCmdListRequiredState.frontEndState.disableEUFusion.value);
1592+
EXPECT_EQ(1, regularCmdListFinalState.frontEndState.disableEUFusion.value);
1593+
} else {
1594+
EXPECT_EQ(-1, regularCmdListRequiredState.frontEndState.disableEUFusion.value);
1595+
EXPECT_EQ(-1, regularCmdListFinalState.frontEndState.disableEUFusion.value);
1596+
}
1597+
1598+
cmdList.clear();
1599+
feStateCmds.clear();
1600+
1601+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1602+
cmdList,
1603+
ptrOffset(regularCmdListStream.getCpuBase(), usedBefore),
1604+
(usedAfter - usedBefore)));
1605+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1606+
EXPECT_EQ(0u, feStateCmds.size());
1607+
1608+
auto &cmdQueueStream = commandQueue->commandStream;
1609+
auto cmdListHandle = commandList->toHandle();
1610+
1611+
usedBefore = cmdQueueStream.getUsed();
1612+
result = commandQueue->executeCommandLists(1, &cmdListHandle, nullptr, false);
1613+
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1614+
usedAfter = cmdQueueStream.getUsed();
1615+
1616+
if (fePropertiesSupport.disableEuFusion) {
1617+
EXPECT_EQ(1, csrProperties.frontEndState.disableEUFusion.value);
1618+
} else {
1619+
EXPECT_EQ(-1, csrProperties.frontEndState.disableEUFusion.value);
1620+
}
1621+
1622+
cmdList.clear();
1623+
feStateCmds.clear();
1624+
1625+
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
1626+
cmdList,
1627+
ptrOffset(cmdQueueStream.getCpuBase(), usedBefore),
1628+
(usedAfter - usedBefore)));
1629+
feStateCmds = findAll<VFE_STATE_TYPE *>(cmdList.begin(), cmdList.end());
1630+
EXPECT_EQ(0u, feStateCmds.size());
1631+
}
1632+
13871633
} // namespace ult
13881634
} // namespace L0

‎opencl/test/unit_test/command_queue/command_queue_tests.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
*/
77

88
#include "shared/source/command_stream/command_stream_receiver.h"
9+
#include "shared/source/command_stream/stream_properties.h"
910
#include "shared/source/command_stream/wait_status.h"
1011
#include "shared/source/helpers/array_count.h"
1112
#include "shared/source/helpers/basic_math.h"
@@ -2418,6 +2419,8 @@ HWTEST_F(KernelExecutionTypesTests, givenKernelWithDifferentExecutionTypeWhileDo
24182419
size_t gws[3] = {63, 0, 0};
24192420
auto &mockCsr = device->getUltCommandStreamReceiver<FamilyType>();
24202421

2422+
mockCsr.feSupportFlags.computeDispatchAllWalker = true;
2423+
24212424
pKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL);
24222425
mockCmdQ->enqueueKernel(pKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
24232426
EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Concurrent);

0 commit comments

Comments
 (0)