Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Simplify Preemption interface and get device preemption once

Browse Source 
Change-Id: Iaab9b9b60a71651125df27dece1a68e9c9435143
Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2019-11-27 12:59:47 +01:00
committed by sys_ocldev
parent a0cbc21919
commit 7781650586
9 changed files with 55 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
core/command_stream/preemption.cpp
View File

@ -36,17 +36,17 @@ bool PreemptionHelper::allowMidThreadPreemption(const PreemptionFlags &flags) {
!(flags.flags.vmeKernel && !flags.flags.deviceSupportsVmePreemption);
}
PreemptionMode PreemptionHelper::taskPreemptionMode(Device &device, const PreemptionFlags &flags) {
if (device.getPreemptionMode() == PreemptionMode::Disabled) {
PreemptionMode PreemptionHelper::taskPreemptionMode(PreemptionMode devicePreemptionMode, const PreemptionFlags &flags) {
if (devicePreemptionMode == PreemptionMode::Disabled) {
return PreemptionMode::Disabled;
}
if (device.getPreemptionMode() >= PreemptionMode::MidThread &&
if (devicePreemptionMode >= PreemptionMode::MidThread &&
allowMidThreadPreemption(flags)) {
return PreemptionMode::MidThread;
}
if (device.getPreemptionMode() >= PreemptionMode::ThreadGroup &&
if (devicePreemptionMode >= PreemptionMode::ThreadGroup &&
allowThreadGroupPreemption(flags)) {
return PreemptionMode::ThreadGroup;
}
@ -79,7 +79,7 @@ PreemptionMode PreemptionHelper::taskPreemptionMode(Device &device, const MultiD
PreemptionFlags flags = {};
setPreemptionLevelFlags(flags, device, kernel);
PreemptionMode taskMode = taskPreemptionMode(device, flags);
PreemptionMode taskMode = taskPreemptionMode(devMode, flags);
if (devMode > taskMode) {
devMode = taskMode;
}

2
core/command_stream/preemption.h
View File

@ -42,7 +42,7 @@ class PreemptionHelper {
template <typename CmdFamily>
using INTERFACE_DESCRIPTOR_DATA = typename CmdFamily::INTERFACE_DESCRIPTOR_DATA;
static PreemptionMode taskPreemptionMode(Device &device, const PreemptionFlags &flags);
static PreemptionMode taskPreemptionMode(PreemptionMode devicePreemptionMode, const PreemptionFlags &flags);
static PreemptionMode taskPreemptionMode(Device &device, const MultiDispatchInfo &multiDispatchInfo);
static bool allowThreadGroupPreemption(const PreemptionFlags &flags);
static bool allowMidThreadPreemption(const PreemptionFlags &flags);

12
core/unit_tests/gen8/test_preemption_gen8.cpp
View File

@ -74,7 +74,9 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
PreemptionFlags flags = {};
MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
size_t gws[3] = {1, 0, 0};
pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@ -90,7 +92,9 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
PreemptionFlags flags = {};
PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
UserEvent userEventObj;
cl_event userEvent = &userEventObj;
@ -111,7 +115,9 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKe
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
PreemptionFlags flags = {};
PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
size_t gws[3] = {1, 0, 0};
pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);

9
core/unit_tests/gen9/test_preemption_gen9.cpp
View File

@ -213,7 +213,8 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
size_t gws[3] = {1, 0, 0};
pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@ -230,7 +231,8 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
UserEvent userEventObj;
cl_event userEvent = &userEventObj;
@ -430,7 +432,8 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKe
pDevice->resetCommandStreamReceiver(mockCsr);
MockKernelWithInternals mockKernel(*pDevice);
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, mockKernel.mockKernel));
MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
size_t gws[3] = {1, 0, 0};
pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);

38
core/unit_tests/preemption/preemption_tests.cpp
View File

@ -47,7 +47,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowByKMD) {
waTable->waDisablePerCtxtPreemptionGranularityControl = 1;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, disallowByDevice) {
@ -55,7 +55,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowByDevice) {
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, disallowByReadWriteFencesWA) {
@ -64,7 +64,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowByReadWriteFencesWA) {
waTable->waDisableLSQCROPERFforOCL = 1;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) {
@ -72,7 +72,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowBySchedulerKernel) {
kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true));
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, disallowByVmeKernel) {
@ -81,19 +81,19 @@ TEST_F(ThreadGroupPreemptionTests, disallowByVmeKernel) {
kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, simpleAllow) {
PreemptionFlags flags = {};
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, allowDefaultModeForNonKernelRequest) {
PreemptionFlags flags = {};
PreemptionHelper::setPreemptionLevelFlags(flags, *device, nullptr);
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, givenKernelWithNoEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) {
@ -102,7 +102,7 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithNoEnvironmentPatchSetWhenLSQCW
waTable->waDisableLSQCROPERFforOCL = 1;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) {
@ -111,7 +111,7 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
waTable->waDisableLSQCROPERFforOCL = 1;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOffThenThreadGroupPreemptionIsBeingSelected) {
@ -120,21 +120,21 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
waTable->waDisableLSQCROPERFforOCL = 0;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, allowMidBatch) {
PreemptionFlags flags = {};
device->setPreemptionMode(PreemptionMode::MidBatch);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, nullptr);
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, disallowWhenAdjustedDisabled) {
PreemptionFlags flags = {};
device->setPreemptionMode(PreemptionMode::Disabled);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, nullptr);
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(ThreadGroupPreemptionTests, returnDefaultDeviceModeForZeroSizedMdi) {
@ -163,7 +163,7 @@ TEST_F(ThreadGroupPreemptionTests, disallowDefaultDeviceModeWhenAtLeastOneInvali
PreemptionFlags flags = {};
PreemptionHelper::setPreemptionLevelFlags(flags, *device, &schedulerKernel);
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(*dispatchInfo);
@ -204,7 +204,7 @@ TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByDevice) {
executionEnvironment->DisableMidThreadPreemption = 0;
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*device, flags));
EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
}
TEST_F(MidThreadPreemptionTests, disallowMidThreadPreemptionByKernel) {
@ -230,7 +230,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByDevice) {
executionEnvironment->DisableMidThreadPreemption = 0;
device->setPreemptionMode(PreemptionMode::ThreadGroup);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(*device, flags);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
}
@ -239,7 +239,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByKernel) {
executionEnvironment->DisableMidThreadPreemption = 1;
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(*device, flags);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
}
@ -250,7 +250,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionDisallowMidThreadByVmeKernel) {
kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(*device, flags);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
//VME disables mid thread and thread group when device does not support it
EXPECT_EQ(PreemptionMode::MidBatch, outMode);
}
@ -260,7 +260,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionAllow) {
executionEnvironment->DisableMidThreadPreemption = 0;
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(*device, flags);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
EXPECT_EQ(PreemptionMode::MidThread, outMode);
}
@ -272,7 +272,7 @@ TEST_F(MidThreadPreemptionTests, taskPreemptionAllowDeviceSupportsPreemptionOnVm
device->deviceInfo.vmeAvcSupportsPreemption = true;
device->setPreemptionMode(PreemptionMode::MidThread);
PreemptionHelper::setPreemptionLevelFlags(flags, *device, kernel.get());
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(*device, flags);
PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
EXPECT_EQ(PreemptionMode::MidThread, outMode);
}

2
runtime/helpers/dispatch_info.h
View File

@ -85,7 +85,7 @@ struct MultiDispatchInfo {
}
}
MultiDispatchInfo(Kernel *mainKernel) : mainKernel(mainKernel) {}
explicit MultiDispatchInfo(Kernel *mainKernel) : mainKernel(mainKernel) {}
MultiDispatchInfo() = default;
MultiDispatchInfo &operator=(const MultiDispatchInfo &) = delete;

5
runtime/helpers/task_information.cpp
View File

@ -8,6 +8,7 @@
#include "runtime/helpers/task_information.h"
#include "core/command_stream/linear_stream.h"
#include "core/command_stream/preemption.h"
#include "core/helpers/aligned_memory.h"
#include "core/helpers/string.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
@ -45,6 +46,8 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) {
auto commandStreamReceiverOwnership = commandStreamReceiver.obtainUniqueOwnership();
auto &queueCommandStream = commandQueue.getCS(0);
size_t offset = queueCommandStream.getUsed();
MultiDispatchInfo multiDispatch;
Device &device = commandQueue.getDevice();
DispatchFlags dispatchFlags(
{}, //csrDependencies
@ -52,7 +55,7 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) {
{}, //pipelineSelectArgs
commandQueue.flushStamp->getStampReference(), //flushStampReference
commandQueue.getThrottle(), //throttle
PreemptionHelper::taskPreemptionMode(commandQueue.getDevice(), nullptr), //preemptionMode
PreemptionHelper::taskPreemptionMode(device, multiDispatch), //preemptionMode
GrfConfig::DefaultGrfNumber, //numGrfRequired
L3CachingSettings::l3CacheOn, //l3CacheSettings
commandQueue.getSliceCount(), //sliceCount

10
unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp
View File

@ -214,13 +214,15 @@ HWTEST_F(EnqueueHandlerTest, GivenCommandStreamWithoutKernelAndZeroSurfacesWhenE
std::unique_ptr<MockCommandQueueWithCacheFlush<FamilyType>> mockCmdQ(new MockCommandQueueWithCacheFlush<FamilyType>(context, pDevice, 0));
mockCmdQ->commandRequireCacheFlush = true;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, nullptr, 0, nullptr, nullptr);
MultiDispatchInfo multiDispatch;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, multiDispatch, 0, nullptr, nullptr);
auto requiredCmdStreamSize = alignUp(PipeControlHelper<FamilyType>::getSizeForPipeControlWithPostSyncOperation(pDevice->getHardwareInfo()),
MemoryConstants::cacheLineSize);
EXPECT_EQ(mockCmdQ->getCS(0).getUsed(), requiredCmdStreamSize);
}
HWTEST_F(EnqueueHandlerTest, givenTimestampPacketWriteEnabledAndCommandWithCacheFlushWhenEnqueueingHandlerThenObtainNewStamp) {
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
csr.timestampPacketWriteEnabled = true;
@ -232,7 +234,8 @@ HWTEST_F(EnqueueHandlerTest, givenTimestampPacketWriteEnabledAndCommandWithCache
cl_event event;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, nullptr, 0, nullptr, &event);
MultiDispatchInfo multiDispatch;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, multiDispatch, 0, nullptr, &event);
auto node1 = mockCmdQ->timestampPacketContainer->peekNodes().at(0);
EXPECT_NE(nullptr, node1);
clReleaseEvent(event);
@ -248,7 +251,8 @@ HWTEST_F(EnqueueHandlerTest, givenTimestampPacketWriteDisabledAndCommandWithCach
cl_event event;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, nullptr, 0, nullptr, &event);
MultiDispatchInfo multiDispatch;
mockCmdQ->template enqueueHandler<CL_COMMAND_MARKER>(nullptr, 0, false, multiDispatch, 0, nullptr, &event);
auto container = mockCmdQ->timestampPacketContainer.get();
EXPECT_EQ(nullptr, container);
clReleaseEvent(event);

4
unit_tests/helpers/task_information_tests.cpp
View File

@ -182,10 +182,12 @@ HWTEST_F(DispatchFlagsTests, givenCommandMapUnmapWhenSubmitThenPassCorrectDispat
MemObjOffsetArray offset = {{0, 0, 0}};
std::unique_ptr<Command> command(new CommandMapUnmap(MapOperationType::MAP, buffer, size, offset, false, *mockCmdQ));
command->submit(20, false);
PreemptionFlags flags = {};
PreemptionMode devicePreemption = mockCmdQ->getDevice().getPreemptionMode();
EXPECT_EQ(mockCmdQ->flushStamp->getStampReference(), mockCsr->passedDispatchFlags.flushStampReference);
EXPECT_EQ(mockCmdQ->getThrottle(), mockCsr->passedDispatchFlags.throttle);
EXPECT_EQ(PreemptionHelper::taskPreemptionMode(mockCmdQ->getDevice(), nullptr), mockCsr->passedDispatchFlags.preemptionMode);
EXPECT_EQ(PreemptionHelper::taskPreemptionMode(devicePreemption, flags), mockCsr->passedDispatchFlags.preemptionMode);
EXPECT_EQ(GrfConfig::DefaultGrfNumber, mockCsr->passedDispatchFlags.numGrfRequired);
EXPECT_EQ(L3CachingSettings::l3CacheOn, mockCsr->passedDispatchFlags.l3CacheSettings);
EXPECT_TRUE(mockCsr->passedDispatchFlags.blocking);