From 7781650586dbbd191a2546cd34f07f52ba8a800c Mon Sep 17 00:00:00 2001 From: Zbigniew Zdanowicz Date: Wed, 27 Nov 2019 12:59:47 +0100 Subject: [PATCH] Simplify Preemption interface and get device preemption once Change-Id: Iaab9b9b60a71651125df27dece1a68e9c9435143 Signed-off-by: Zbigniew Zdanowicz --- core/command_stream/preemption.cpp | 10 ++--- core/command_stream/preemption.h | 2 +- core/unit_tests/gen8/test_preemption_gen8.cpp | 12 ++++-- core/unit_tests/gen9/test_preemption_gen9.cpp | 9 +++-- .../preemption/preemption_tests.cpp | 38 +++++++++---------- runtime/helpers/dispatch_info.h | 2 +- runtime/helpers/task_information.cpp | 5 ++- .../enqueue_command_without_kernel_tests.cpp | 10 +++-- unit_tests/helpers/task_information_tests.cpp | 4 +- 9 files changed, 55 insertions(+), 37 deletions(-) diff --git a/core/command_stream/preemption.cpp b/core/command_stream/preemption.cpp index 5f18fb12c5..2a28ee91a2 100644 --- a/core/command_stream/preemption.cpp +++ b/core/command_stream/preemption.cpp @@ -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; } diff --git a/core/command_stream/preemption.h b/core/command_stream/preemption.h index 88f9a04e94..c1b4fe8f7e 100644 --- a/core/command_stream/preemption.h +++ b/core/command_stream/preemption.h @@ -42,7 +42,7 @@ class PreemptionHelper { template 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); diff --git a/core/unit_tests/gen8/test_preemption_gen8.cpp b/core/unit_tests/gen8/test_preemption_gen8.cpp index cb6c5bd17d..1dd4a575e1 100644 --- a/core/unit_tests/gen8/test_preemption_gen8.cpp +++ b/core/unit_tests/gen8/test_preemption_gen8.cpp @@ -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); diff --git a/core/unit_tests/gen9/test_preemption_gen9.cpp b/core/unit_tests/gen9/test_preemption_gen9.cpp index 7274ed561f..cbe618d5a3 100644 --- a/core/unit_tests/gen9/test_preemption_gen9.cpp +++ b/core/unit_tests/gen9/test_preemption_gen9.cpp @@ -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); diff --git a/core/unit_tests/preemption/preemption_tests.cpp b/core/unit_tests/preemption/preemption_tests.cpp index 6d48f69a8c..4541526842 100644 --- a/core/unit_tests/preemption/preemption_tests.cpp +++ b/core/unit_tests/preemption/preemption_tests.cpp @@ -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); } diff --git a/runtime/helpers/dispatch_info.h b/runtime/helpers/dispatch_info.h index eb628abf2d..f9fd9e7930 100644 --- a/runtime/helpers/dispatch_info.h +++ b/runtime/helpers/dispatch_info.h @@ -85,7 +85,7 @@ struct MultiDispatchInfo { } } - MultiDispatchInfo(Kernel *mainKernel) : mainKernel(mainKernel) {} + explicit MultiDispatchInfo(Kernel *mainKernel) : mainKernel(mainKernel) {} MultiDispatchInfo() = default; MultiDispatchInfo &operator=(const MultiDispatchInfo &) = delete; diff --git a/runtime/helpers/task_information.cpp b/runtime/helpers/task_information.cpp index 5139094eb8..0d4b4ce8da 100644 --- a/runtime/helpers/task_information.cpp +++ b/runtime/helpers/task_information.cpp @@ -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 diff --git a/unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp b/unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp index 53310bf5e1..b5a4705604 100644 --- a/unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp +++ b/unit_tests/command_queue/enqueue_command_without_kernel_tests.cpp @@ -214,13 +214,15 @@ HWTEST_F(EnqueueHandlerTest, GivenCommandStreamWithoutKernelAndZeroSurfacesWhenE std::unique_ptr> mockCmdQ(new MockCommandQueueWithCacheFlush(context, pDevice, 0)); mockCmdQ->commandRequireCacheFlush = true; - mockCmdQ->template enqueueHandler(nullptr, 0, false, nullptr, 0, nullptr, nullptr); + MultiDispatchInfo multiDispatch; + mockCmdQ->template enqueueHandler(nullptr, 0, false, multiDispatch, 0, nullptr, nullptr); auto requiredCmdStreamSize = alignUp(PipeControlHelper::getSizeForPipeControlWithPostSyncOperation(pDevice->getHardwareInfo()), MemoryConstants::cacheLineSize); EXPECT_EQ(mockCmdQ->getCS(0).getUsed(), requiredCmdStreamSize); } + HWTEST_F(EnqueueHandlerTest, givenTimestampPacketWriteEnabledAndCommandWithCacheFlushWhenEnqueueingHandlerThenObtainNewStamp) { auto &csr = pDevice->getUltCommandStreamReceiver(); csr.timestampPacketWriteEnabled = true; @@ -232,7 +234,8 @@ HWTEST_F(EnqueueHandlerTest, givenTimestampPacketWriteEnabledAndCommandWithCache cl_event event; - mockCmdQ->template enqueueHandler(nullptr, 0, false, nullptr, 0, nullptr, &event); + MultiDispatchInfo multiDispatch; + mockCmdQ->template enqueueHandler(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(nullptr, 0, false, nullptr, 0, nullptr, &event); + MultiDispatchInfo multiDispatch; + mockCmdQ->template enqueueHandler(nullptr, 0, false, multiDispatch, 0, nullptr, &event); auto container = mockCmdQ->timestampPacketContainer.get(); EXPECT_EQ(nullptr, container); clReleaseEvent(event); diff --git a/unit_tests/helpers/task_information_tests.cpp b/unit_tests/helpers/task_information_tests.cpp index 6590ec7883..821fa2e168 100644 --- a/unit_tests/helpers/task_information_tests.cpp +++ b/unit_tests/helpers/task_information_tests.cpp @@ -182,10 +182,12 @@ HWTEST_F(DispatchFlagsTests, givenCommandMapUnmapWhenSubmitThenPassCorrectDispat MemObjOffsetArray offset = {{0, 0, 0}}; std::unique_ptr 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);