Create ClPreemptionHelper

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

opencl/source/command_queue/enqueue_common.h

@@ -29,6 +29,7 @@
 #include "opencl/source/gtpin/gtpin_notify.h"
 #include "opencl/source/helpers/cl_blit_properties.h"
 #include "opencl/source/helpers/cl_hw_helper.h"
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/source/helpers/dispatch_info_builder.h"
 #include "opencl/source/helpers/enqueue_properties.h"
 #include "opencl/source/helpers/hardware_commands_helper.h"
@@ -667,7 +668,7 @@ void CommandQueueHw<GfxFamily>::processDeviceEnqueue(DeviceQueueHw<GfxFamily> *d
                       this->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0u).getGraphicsAllocation(),
                       devQueueHw->getDebugQueue());
 
-    auto preemptionMode = PreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo);
+    auto preemptionMode = ClPreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo);
     GpgpuWalkerHelper<GfxFamily>::dispatchScheduler(
         *this->commandStream,
         *devQueueHw,
@@ -861,7 +862,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         {},                                                                                         //pipelineSelectArgs
         this->flushStamp->getStampReference(),                                                      //flushStampReference
         getThrottle(),                                                                              //throttle
-        PreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo),                       //preemptionMode
+        ClPreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo),                     //preemptionMode
         numGrfRequired,                                                                             //numGrfRequired
         L3CachingSettings::l3CacheOn,                                                               //l3CacheSettings
         kernel->getThreadArbitrationPolicy(),                                                       //threadArbitrationPolicy
@@ -1005,7 +1006,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlocked(
             allSurfaces.push_back(surface->duplicate());
         }
 
-        PreemptionMode preemptionMode = PreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo);
+        PreemptionMode preemptionMode = ClPreemptionHelper::taskPreemptionMode(getDevice(), multiDispatchInfo);
         bool slmUsed = multiDispatchInfo.usesSlm() || multiDispatchInfo.peekParentKernel();
         command = std::make_unique<CommandComputeKernel>(*this,
                                                          blockedCommandsData,

opencl/source/command_queue/hardware_interface_base.inl

@@ -13,6 +13,7 @@
 
 #include "opencl/source/command_queue/gpgpu_walker.h"
 #include "opencl/source/command_queue/hardware_interface.h"
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/source/helpers/hardware_commands_helper.h"
 #include "opencl/source/helpers/task_information.h"
 #include "opencl/source/mem_obj/buffer.h"
@@ -76,7 +77,7 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
     IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
     auto parentKernel = multiDispatchInfo.peekParentKernel();
     auto mainKernel = multiDispatchInfo.peekMainKernel();
-    auto preemptionMode = PreemptionHelper::taskPreemptionMode(commandQueue.getDevice(), multiDispatchInfo);
+    auto preemptionMode = ClPreemptionHelper::taskPreemptionMode(commandQueue.getDevice(), multiDispatchInfo);
 
     for (auto &dispatchInfo : multiDispatchInfo) {
         // Compute local workgroup sizes

opencl/source/helpers/CMakeLists.txt

@@ -16,6 +16,8 @@ set(RUNTIME_SRCS_HELPERS_BASE
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_hw_helper.h
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_hw_helper_base.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/cl_hw_helper_bdw_and_later.inl
+    ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_helper.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_helper.h
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_color.h
     ${CMAKE_CURRENT_SOURCE_DIR}/destructor_callbacks.h
     ${CMAKE_CURRENT_SOURCE_DIR}/dispatch_info.cpp

opencl/source/helpers/cl_preemption_helper.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "opencl/source/helpers/cl_preemption_helper.h"
+
+#include "opencl/source/helpers/dispatch_info.h"
+
+namespace NEO {
+
+void ClPreemptionHelper::setPreemptionLevelFlags(PreemptionFlags &flags, Device &device, Kernel *kernel) {
+    if (kernel) {
+        const auto &kernelDescriptor = kernel->getKernelInfo().kernelDescriptor;
+        flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption;
+        flags.flags.vmeKernel = kernel->isVmeKernel();
+        flags.flags.usesFencesForReadWriteImages = kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages;
+        flags.flags.schedulerKernel = kernel->isSchedulerKernel;
+    }
+    flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption;
+    flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.waDisablePerCtxtPreemptionGranularityControl;
+    flags.flags.disableLSQCROPERFforOCL = device.getHardwareInfo().workaroundTable.waDisableLSQCROPERFforOCL;
+}
+
+PreemptionMode ClPreemptionHelper::taskPreemptionMode(Device &device, const MultiDispatchInfo &multiDispatchInfo) {
+    PreemptionMode devMode = device.getPreemptionMode();
+
+    for (const auto &di : multiDispatchInfo) {
+        auto kernel = di.getKernel();
+
+        PreemptionFlags flags = {};
+        setPreemptionLevelFlags(flags, device, kernel);
+
+        PreemptionMode taskMode = PreemptionHelper::taskPreemptionMode(devMode, flags);
+        if (devMode > taskMode) {
+            devMode = taskMode;
+        }
+        PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stdout, "devMode = %d, taskMode = %d.\n",
+                           static_cast<int>(device.getPreemptionMode()), static_cast<int>(taskMode));
+    }
+    return devMode;
+}
+} // namespace NEO

opencl/source/helpers/cl_preemption_helper.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/command_stream/preemption.h"
+
+namespace NEO {
+class Kernel;
+class Device;
+struct MultiDispatchInfo;
+
+class ClPreemptionHelper {
+  public:
+    static PreemptionMode taskPreemptionMode(Device &device, const MultiDispatchInfo &multiDispatchInfo);
+    static void setPreemptionLevelFlags(PreemptionFlags &flags, Device &device, Kernel *kernel);
+};
+
+} // namespace NEO

opencl/source/helpers/task_information.cpp

@@ -23,6 +23,7 @@
 #include "opencl/source/command_queue/enqueue_common.h"
 #include "opencl/source/device_queue/device_queue.h"
 #include "opencl/source/gtpin/gtpin_notify.h"
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/source/helpers/enqueue_properties.h"
 #include "opencl/source/helpers/task_information.inl"
 #include "opencl/source/mem_obj/mem_obj.h"
@@ -56,7 +57,7 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) {
         {},                                                                          //pipelineSelectArgs
         commandQueue.flushStamp->getStampReference(),                                //flushStampReference
         commandQueue.getThrottle(),                                                  //throttle
-        PreemptionHelper::taskPreemptionMode(device, multiDispatch),                 //preemptionMode
+        ClPreemptionHelper::taskPreemptionMode(device, multiDispatch),               //preemptionMode
         GrfConfig::NotApplicable,                                                    //numGrfRequired
         L3CachingSettings::NotApplicable,                                            //l3CacheSettings
         ThreadArbitrationPolicy::NotPresent,                                         //threadArbitrationPolicy

opencl/test/unit_test/gen8/test_preemption_gen8.cpp

@@ -10,6 +10,7 @@
 #include "shared/test/common/mocks/mock_command_stream_receiver.h"
 
 #include "opencl/source/event/user_event.h"
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h"
 #include "opencl/test/unit_test/libult/ult_command_stream_receiver.h"
 
@@ -20,7 +21,7 @@ using Gen8ClPreemptionTests = DevicePreemptionTests;
 
 GEN8TEST_F(Gen8ClPreemptionTests, GivenEmptyFlagsWhenSettingPreemptionLevelFlagsThenThreadGroupPreemptionIsAllowed) {
     PreemptionFlags flags = {};
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
 }
 
@@ -54,7 +55,7 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
     MockKernelWithInternals mockKernel(*pClDevice);
     PreemptionFlags flags = {};
     MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
-    EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
+    EXPECT_EQ(PreemptionMode::ThreadGroup, ClPreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
 
     size_t gws[3] = {1, 0, 0};
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@@ -71,7 +72,7 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
 
     MockKernelWithInternals mockKernel(*pClDevice);
     PreemptionFlags flags = {};
-    PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
 
     UserEvent userEventObj;
@@ -94,7 +95,7 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKe
 
     MockKernelWithInternals mockKernel(*pClDevice);
     PreemptionFlags flags = {};
-    PreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, *pDevice, mockKernel.mockKernel);
     EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
 
     size_t gws[3] = {1, 0, 0};

opencl/test/unit_test/gen9/test_preemption_gen9.cpp

@@ -9,6 +9,7 @@
 #include "shared/test/common/cmd_parse/hw_parse.h"
 #include "shared/test/common/mocks/mock_command_stream_receiver.h"
 
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/test/unit_test/command_queue/enqueue_fixture.h"
 #include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h"
 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
@@ -160,7 +161,7 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
 
     MockKernelWithInternals mockKernel(*pClDevice);
     MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
-    EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
+    EXPECT_EQ(PreemptionMode::ThreadGroup, ClPreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
 
     size_t gws[3] = {1, 0, 0};
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
@@ -178,7 +179,7 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
 
     MockKernelWithInternals mockKernel(*pClDevice);
     MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
-    EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
+    EXPECT_EQ(PreemptionMode::ThreadGroup, ClPreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
 
     UserEvent userEventObj;
     cl_event userEvent = &userEventObj;
@@ -379,7 +380,7 @@ GEN9TEST_F(Gen9PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKe
 
     MockKernelWithInternals mockKernel(*pClDevice);
     MultiDispatchInfo multiDispatch(mockKernel.mockKernel);
-    EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
+    EXPECT_EQ(PreemptionMode::Disabled, ClPreemptionHelper::taskPreemptionMode(*pDevice, multiDispatch));
 
     size_t gws[3] = {1, 0, 0};
     pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);

opencl/test/unit_test/preemption/preemption_tests.cpp

@@ -8,6 +8,7 @@
 #include "shared/source/command_stream/preemption.h"
 #include "shared/source/kernel/kernel_descriptor_from_patchtokens.h"
 
+#include "opencl/source/helpers/cl_preemption_helper.h"
 #include "opencl/test/unit_test/fixtures/cl_preemption_fixture.h"
 
 #include "gmock/gmock.h"
@@ -35,7 +36,7 @@ class MidThreadPreemptionTests : public DevicePreemptionTests {
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowedByKmdThenThreadGroupPreemptionIsDisabled) {
     PreemptionFlags flags = {};
     waTable->waDisablePerCtxtPreemptionGranularityControl = 1;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -43,7 +44,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowedByKmdThenThreadGroupPreemption
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowByDeviceThenThreadGroupPreemptionIsDisabled) {
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -52,7 +53,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowByReadWriteFencesWaThenThreadGro
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = true;
     waTable->waDisableLSQCROPERFforOCL = 1;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -60,7 +61,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowByReadWriteFencesWaThenThreadGro
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowBySchedulerKernelThenThreadGroupPreemptionIsDisabled) {
     PreemptionFlags flags = {};
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -69,7 +70,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowByVmeKernelThenThreadGroupPreemp
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -82,7 +83,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDefaultThenThreadGroupPreemptionIsEnable
 
 TEST_F(ThreadGroupPreemptionTests, GivenDefaultModeForNonKernelRequestThenThreadGroupPreemptionIsEnabled) {
     PreemptionFlags flags = {};
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
@@ -90,7 +91,7 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = false;
     waTable->waDisableLSQCROPERFforOCL = 1;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -99,7 +100,7 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = true;
     waTable->waDisableLSQCROPERFforOCL = 0;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -107,27 +108,27 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
 TEST_F(ThreadGroupPreemptionTests, GivenDefaultThenMidBatchPreemptionIsEnabled) {
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::MidBatch);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenDisabledThenPreemptionIsDisabled) {
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::Disabled);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenZeroSizedMdiThenThreadGroupPreemptioIsEnabled) {
     MultiDispatchInfo multiDispatchInfo;
-    EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
+    EXPECT_EQ(PreemptionMode::ThreadGroup, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenValidKernelsInMdiThenThreadGroupPreemptioIsEnabled) {
     MultiDispatchInfo multiDispatchInfo;
     multiDispatchInfo.push(*dispatchInfo);
     multiDispatchInfo.push(*dispatchInfo);
-    EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
+    EXPECT_EQ(PreemptionMode::ThreadGroup, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenValidKernelsInMdiAndDisabledPremptionThenPreemptionIsDisabled) {
@@ -135,7 +136,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenValidKernelsInMdiAndDisabledPremptionThe
     MultiDispatchInfo multiDispatchInfo;
     multiDispatchInfo.push(*dispatchInfo);
     multiDispatchInfo.push(*dispatchInfo);
-    EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
+    EXPECT_EQ(PreemptionMode::Disabled, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenAtLeastOneInvalidKernelInMdiThenPreemptionIsDisabled) {
@@ -143,7 +144,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenAtLeastOneInvalidKernelInMdiThenPreempti
     DispatchInfo schedulerDispatchInfo(device.get(), &schedulerKernel, 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0));
 
     PreemptionFlags flags = {};
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), &schedulerKernel);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), &schedulerKernel);
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 
     MultiDispatchInfo multiDispatchInfo;
@@ -151,21 +152,21 @@ TEST_F(ThreadGroupPreemptionTests, GivenAtLeastOneInvalidKernelInMdiThenPreempti
     multiDispatchInfo.push(schedulerDispatchInfo);
     multiDispatchInfo.push(*dispatchInfo);
 
-    EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
+    EXPECT_EQ(PreemptionMode::MidBatch, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
 }
 
 TEST_F(MidThreadPreemptionTests, GivenMidThreadPreemptionThenMidThreadPreemptionIsEnabled) {
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::MidThread);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
 TEST_F(MidThreadPreemptionTests, GivenNullKernelThenMidThreadPreemptionIsEnabled) {
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), nullptr);
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -175,7 +176,7 @@ TEST_F(MidThreadPreemptionTests, GivenMidThreadPreemptionDeviceSupportPreemption
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -183,7 +184,7 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByDeviceThenMid
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::ThreadGroup);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -192,7 +193,7 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByKernelThenMid
     PreemptionFlags flags = {};
     device->setPreemptionMode(PreemptionMode::MidThread);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = true;
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -202,7 +203,7 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByVmeKernelThen
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -210,7 +211,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByDeviceThe
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
     device->setPreemptionMode(PreemptionMode::ThreadGroup);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
 }
@@ -219,7 +220,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByKernelThe
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = true;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
 }
@@ -230,7 +231,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByVmeKernel
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     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);
@@ -240,7 +241,7 @@ TEST_F(MidThreadPreemptionTests, GivenDeviceSupportsMidThreadPreemptionThenMidTh
     PreemptionFlags flags = {};
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -252,7 +253,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionAllowDeviceSupportsPreemptio
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -264,7 +265,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsT
 
     PreemptionFlags flags = {};
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -276,7 +277,7 @@ TEST_F(MidThreadPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsMid
 
     PreemptionFlags flags = {};
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
+    ClPreemptionHelper::setPreemptionLevelFlags(flags, device->getDevice(), kernel.get());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidBatch, outMode);
 }

shared/source/command_stream/preemption.cpp

@@ -7,13 +7,10 @@
 
 #include "shared/source/command_stream/preemption.h"
 
-#include "shared/source/built_ins/built_ins.h"
+#include "shared/source/debug_settings/debug_settings_manager.h"
 #include "shared/source/device/device.h"
 #include "shared/source/helpers/string.h"
 
-#include "opencl/source/helpers/dispatch_info.h"
-#include "opencl/source/kernel/kernel.h"
-
 namespace NEO {
 
 bool PreemptionHelper::allowThreadGroupPreemption(const PreemptionFlags &flags) {
@@ -58,38 +55,6 @@ PreemptionMode PreemptionHelper::taskPreemptionMode(PreemptionMode devicePreempt
     return PreemptionMode::MidBatch;
 };
 
-void PreemptionHelper::setPreemptionLevelFlags(PreemptionFlags &flags, Device &device, Kernel *kernel) {
-    if (kernel) {
-        const auto &kernelDescriptor = kernel->getKernelInfo().kernelDescriptor;
-        flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption;
-        flags.flags.vmeKernel = kernel->isVmeKernel();
-        flags.flags.usesFencesForReadWriteImages = kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages;
-        flags.flags.schedulerKernel = kernel->isSchedulerKernel;
-    }
-    flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption;
-    flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.waDisablePerCtxtPreemptionGranularityControl;
-    flags.flags.disableLSQCROPERFforOCL = device.getHardwareInfo().workaroundTable.waDisableLSQCROPERFforOCL;
-}
-
-PreemptionMode PreemptionHelper::taskPreemptionMode(Device &device, const MultiDispatchInfo &multiDispatchInfo) {
-    PreemptionMode devMode = device.getPreemptionMode();
-
-    for (const auto &di : multiDispatchInfo) {
-        auto kernel = di.getKernel();
-
-        PreemptionFlags flags = {};
-        setPreemptionLevelFlags(flags, device, kernel);
-
-        PreemptionMode taskMode = taskPreemptionMode(devMode, flags);
-        if (devMode > taskMode) {
-            devMode = taskMode;
-        }
-        PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stdout, "devMode = %d, taskMode = %d.\n",
-                           static_cast<int>(device.getPreemptionMode()), static_cast<int>(taskMode));
-    }
-    return devMode;
-}
-
 void PreemptionHelper::adjustDefaultPreemptionMode(RuntimeCapabilityTable &deviceCapabilities, bool allowMidThread, bool allowThreadGroup, bool allowMidBatch) {
     if (deviceCapabilities.defaultPreemptionMode >= PreemptionMode::MidThread &&
         allowMidThread) {

shared/source/command_stream/preemption.h

@@ -13,10 +13,8 @@
 #include "sku_info.h"
 
 namespace NEO {
-class Kernel;
 class Device;
 class GraphicsAllocation;
-struct MultiDispatchInfo;
 
 struct PreemptionFlags {
     PreemptionFlags() {
@@ -43,13 +41,10 @@ class PreemptionHelper {
     using INTERFACE_DESCRIPTOR_DATA = typename CmdFamily::INTERFACE_DESCRIPTOR_DATA;
 
     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);
     static void adjustDefaultPreemptionMode(RuntimeCapabilityTable &deviceCapabilities, bool allowMidThread, bool allowThreadGroup, bool allowMidBatch);
 
-    static void setPreemptionLevelFlags(PreemptionFlags &flags, Device &device, Kernel *kernel);
-
     template <typename GfxFamily>
     static size_t getRequiredPreambleSize(const Device &device);
     template <typename GfxFamily>