Remove device enqueue part 3

- isSchedulerKernel

Related-To: NEO-6559
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>

opencl/source/helpers/cl_preemption_helper.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,13 +18,11 @@ PreemptionMode ClPreemptionHelper::taskPreemptionMode(Device &device, const Mult
         auto kernel = di.getKernel();
 
         const KernelDescriptor *kernelDescriptor = nullptr;
-        bool schedulerKernel = false;
         if (kernel != nullptr) {
             kernelDescriptor = &kernel->getDescriptor();
-            schedulerKernel = kernel->isSchedulerKernel;
         }
 
-        PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device, kernelDescriptor, schedulerKernel);
+        PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device, kernelDescriptor);
         PreemptionMode taskMode = PreemptionHelper::taskPreemptionMode(devMode, flags);
         if (devMode > taskMode) {
             devMode = taskMode;

opencl/source/helpers/hardware_commands_helper.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -112,7 +112,7 @@ struct HardwareCommandsHelper : public PerThreadDataHelper {
         size_t &sizePerThreadDataTotal,
         size_t &localWorkItems);
 
-    inline static bool resetBindingTablePrefetch(Kernel &kernel);
+    inline static bool resetBindingTablePrefetch();
 
     static size_t getSizeRequiredCS();
     static size_t getSizeRequiredForCacheFlush(const CommandQueue &commandQueue, const Kernel *kernel, uint64_t postSyncAddress);

opencl/source/helpers/hardware_commands_helper_base.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -292,7 +292,7 @@ size_t HardwareCommandsHelper<GfxFamily>::sendIndirectState(
     uint64_t offsetInterfaceDescriptor = offsetInterfaceDescriptorTable + interfaceDescriptorIndex * sizeof(INTERFACE_DESCRIPTOR_DATA);
 
     auto bindingTablePrefetchSize = std::min(31u, static_cast<uint32_t>(kernel.getNumberOfBindingTableStates()));
-    if (resetBindingTablePrefetch(kernel)) {
+    if (resetBindingTablePrefetch()) {
         bindingTablePrefetchSize = 0;
     }
 

opencl/source/helpers/hardware_commands_helper_bdw_and_later.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -150,8 +150,8 @@ size_t HardwareCommandsHelper<GfxFamily>::sendCrossThreadData(
 }
 
 template <typename GfxFamily>
-bool HardwareCommandsHelper<GfxFamily>::resetBindingTablePrefetch(Kernel &kernel) {
-    return kernel.isSchedulerKernel || !EncodeSurfaceState<GfxFamily>::doBindingTablePrefetch();
+bool HardwareCommandsHelper<GfxFamily>::resetBindingTablePrefetch() {
+    return !EncodeSurfaceState<GfxFamily>::doBindingTablePrefetch();
 }
 
 template <typename GfxFamily>

opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -132,8 +132,8 @@ size_t HardwareCommandsHelper<GfxFamily>::sendCrossThreadData(
 }
 
 template <typename GfxFamily>
-bool HardwareCommandsHelper<GfxFamily>::resetBindingTablePrefetch(Kernel &kernel) {
-    return kernel.isSchedulerKernel;
+bool HardwareCommandsHelper<GfxFamily>::resetBindingTablePrefetch() {
+    return false;
 }
 
 template <typename GfxFamily>

opencl/source/kernel/kernel.cpp

@@ -67,9 +67,8 @@ class Surface;
 
 uint32_t Kernel::dummyPatchLocation = 0xbaddf00d;
 
-Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg, bool schedulerKernel)
+Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg)
     : isParentKernel(kernelInfoArg.kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue),
-      isSchedulerKernel(schedulerKernel),
       executionEnvironment(programArg->getExecutionEnvironment()),
       program(programArg),
       clDevice(clDeviceArg),
@@ -1916,7 +1915,7 @@ void Kernel::createReflectionSurface() {
     }
 
     if (DebugManager.flags.ForceDispatchScheduler.get()) {
-        if (this->isSchedulerKernel && kernelReflectionSurface == nullptr) {
+        if (kernelReflectionSurface == nullptr) {
             kernelReflectionSurface = executionEnvironment.memoryManager->allocateGraphicsMemoryWithProperties(
                 {pClDevice->getRootDeviceIndex(), MemoryConstants::pageSize,
                  GraphicsAllocation::AllocationType::DEVICE_QUEUE_BUFFER,

opencl/source/kernel/kernel.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -325,7 +325,6 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
 
     bool isBuiltIn = false;
     const bool isParentKernel;
-    const bool isSchedulerKernel;
 
     uint32_t getThreadArbitrationPolicy() const {
         return threadArbitrationPolicy;
@@ -504,7 +503,7 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
     void patchWithImplicitSurface(void *ptrToPatchInCrossThreadData, GraphicsAllocation &allocation, const ArgDescPointer &arg);
 
     void getParentObjectCounts(ObjectCounts &objectCount);
-    Kernel(Program *programArg, const KernelInfo &kernelInfo, ClDevice &clDevice, bool schedulerKernel = false);
+    Kernel(Program *programArg, const KernelInfo &kernelInfo, ClDevice &clDevice);
     void provideInitializationHints();
 
     void patchBlocksCurbeWithConstantValues();

opencl/source/scheduler/scheduler_kernel.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -55,7 +55,7 @@ class SchedulerKernel : public Kernel {
     static BuiltinCode loadSchedulerKernel(Device *device);
 
   protected:
-    SchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg) : Kernel(programArg, kernelInfoArg, clDeviceArg, true) {
+    SchedulerKernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg) : Kernel(programArg, kernelInfoArg, clDeviceArg) {
         computeGws();
     };
 

opencl/test/unit_test/gen8/test_preemption_gen8.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,7 +20,7 @@ using Gen8PreemptionEnqueueKernelTest = PreemptionEnqueueKernelTest;
 using Gen8ClPreemptionTests = DevicePreemptionTests;
 
 GEN8TEST_F(Gen8ClPreemptionTests, GivenEmptyFlagsWhenSettingPreemptionLevelFlagsThenThreadGroupPreemptionIsAllowed) {
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
 }
 
@@ -70,7 +70,7 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenValidKernelForPreemptionWhenEnq
     pDevice->resetCommandStreamReceiver(mockCsr);
 
     MockKernelWithInternals mockKernel(*pClDevice);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*pDevice, &mockKernel.mockKernel->getDescriptor(), mockKernel.mockKernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*pDevice, &mockKernel.mockKernel->getDescriptor());
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
 
     UserEvent userEventObj;
@@ -92,7 +92,7 @@ GEN8TEST_F(Gen8PreemptionEnqueueKernelTest, givenDisabledPreemptionWhenEnqueueKe
     pDevice->resetCommandStreamReceiver(mockCsr);
 
     MockKernelWithInternals mockKernel(*pClDevice);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*pDevice, &mockKernel.mockKernel->getDescriptor(), mockKernel.mockKernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(*pDevice, &mockKernel.mockKernel->getDescriptor());
     EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(pDevice->getPreemptionMode(), flags));
 
     size_t gws[3] = {1, 0, 0};

opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -413,50 +413,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, givenKernelWithFourBindingTabl
     }
 }
 
-HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, givenKernelThatIsSchedulerWhenIndirectStateIsEmittedThenInterfaceDescriptorContainsZeroBindingTableEntryCount) {
-    using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
-    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
-    CommandQueueHw<FamilyType> cmdQ(pContext, pClDevice, 0, false);
-
-    auto &commandStream = cmdQ.getCS(1024);
-    auto pWalkerCmd = static_cast<GPGPU_WALKER *>(commandStream.getSpace(sizeof(GPGPU_WALKER)));
-    *pWalkerCmd = FamilyType::cmdInitGpgpuWalker;
-
-    auto expectedBindingTableCount = 3u;
-    mockKernelWithInternal->mockKernel->numberOfBindingTableStates = expectedBindingTableCount;
-    auto isScheduler = const_cast<bool *>(&mockKernelWithInternal->mockKernel->isSchedulerKernel);
-    *isScheduler = true;
-
-    auto &dsh = cmdQ.getIndirectHeap(IndirectHeap::DYNAMIC_STATE, 8192);
-    auto &ioh = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
-    auto &ssh = cmdQ.getIndirectHeap(IndirectHeap::SURFACE_STATE, 8192);
-    const size_t localWorkSize = 256;
-    const size_t localWorkSizes[3]{localWorkSize, 1, 1};
-    uint32_t interfaceDescriptorIndex = 0;
-    auto isCcsUsed = EngineHelpers::isCcs(cmdQ.getGpgpuEngine().osContext->getEngineType());
-    auto kernelUsesLocalIds = HardwareCommandsHelper<FamilyType>::kernelUsesLocalIds(*mockKernelWithInternal->mockKernel);
-
-    HardwareCommandsHelper<FamilyType>::sendIndirectState(
-        commandStream,
-        dsh,
-        ioh,
-        ssh,
-        *mockKernelWithInternal->mockKernel,
-        mockKernelWithInternal->mockKernel->getKernelStartOffset(true, kernelUsesLocalIds, isCcsUsed),
-        mockKernelWithInternal->mockKernel->getKernelInfo().getMaxSimdSize(),
-        localWorkSizes,
-        0,
-        interfaceDescriptorIndex,
-        pDevice->getPreemptionMode(),
-        pWalkerCmd,
-        nullptr,
-        true,
-        *pDevice);
-
-    auto interfaceDescriptor = reinterpret_cast<INTERFACE_DESCRIPTOR_DATA *>(dsh.getCpuBase());
-    EXPECT_EQ(0u, interfaceDescriptor->getBindingTableEntryCount());
-}
-
 HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, givenKernelWith100BindingTableEntriesWhenIndirectStateIsEmittedThenInterfaceDescriptorHas31BindingTableEntriesSet) {
     using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
     using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
@@ -552,7 +508,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, whenSendingIndirectStateThenKe
     modifiedKernelInfo.kernelDescriptor.kernelAttributes.workgroupDimensionsOrder[2] = 0;
     modifiedKernelInfo.kernelDescriptor.kernelAttributes.simdSize = 16;
     modifiedKernelInfo.kernelDescriptor.kernelAttributes.numLocalIdChannels = 3;
-    MockKernel mockKernel(kernel->getProgram(), modifiedKernelInfo, *pClDevice, false);
+    MockKernel mockKernel(kernel->getProgram(), modifiedKernelInfo, *pClDevice);
     uint32_t interfaceDescriptorIndex = 0;
     auto isCcsUsed = EngineHelpers::isCcs(cmdQ.getGpgpuEngine().osContext->getEngineType());
     auto kernelUsesLocalIds = HardwareCommandsHelper<FamilyType>::kernelUsesLocalIds(mockKernel);

opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp

@@ -526,24 +526,6 @@ TEST(KernelReflectionSurfaceTestSingle, GivenNonParentKernelWhenCreatingKernelRe
     EXPECT_EQ(nullptr, reflectionSurface);
 }
 
-TEST(KernelReflectionSurfaceTestSingle, GivenNonSchedulerKernelWithForcedSchedulerDispatchWhenCreatingKernelReflectionSurfaceThenKernelReflectionSurfaceIsNotCreated) {
-    DebugManagerStateRestore dbgRestorer;
-    DebugManager.flags.ForceDispatchScheduler.set(true);
-
-    MockClDevice device{new MockDevice};
-    MockProgram program(toClDeviceVector(device));
-    KernelInfo info;
-    MockKernel kernel(&program, info, device);
-
-    EXPECT_FALSE(kernel.isParentKernel);
-
-    kernel.createReflectionSurface();
-
-    auto reflectionSurface = kernel.getKernelReflectionSurface();
-
-    EXPECT_EQ(nullptr, reflectionSurface);
-}
-
 TEST(KernelReflectionSurfaceTestSingle, GivenNoKernelArgsWhenObtainingKernelReflectionSurfaceThenParamsAreCorrect) {
     REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
     MockContext context;

opencl/test/unit_test/kernel/parent_kernel_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -25,7 +25,7 @@ class MockKernelWithArgumentAccess : public Kernel {
     class ObjectCountsPublic : public Kernel::ObjectCounts {
     };
 
-    MockKernelWithArgumentAccess(Program *programArg, KernelInfo &kernelInfoArg, ClDevice &clDeviceArg) : Kernel(programArg, kernelInfoArg, clDeviceArg, false) {
+    MockKernelWithArgumentAccess(Program *programArg, KernelInfo &kernelInfoArg, ClDevice &clDeviceArg) : Kernel(programArg, kernelInfoArg, clDeviceArg) {
     }
 
     void getParentObjectCountsPublic(MockKernelWithArgumentAccess::ObjectCountsPublic &objectCount) {

opencl/test/unit_test/mocks/mock_kernel.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -108,7 +108,6 @@ class MockKernel : public Kernel {
     using Kernel::hasDirectStatelessAccessToHostMemory;
     using Kernel::hasDirectStatelessAccessToSharedBuffer;
     using Kernel::hasIndirectStatelessAccessToHostMemory;
-    using Kernel::isSchedulerKernel;
     using Kernel::kernelArgHandlers;
     using Kernel::kernelArgRequiresCacheFlush;
     using Kernel::kernelArguments;
@@ -181,8 +180,8 @@ class MockKernel : public Kernel {
         }
     };
 
-    MockKernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg, bool scheduler = false)
-        : Kernel(programArg, kernelInfoArg, clDeviceArg, scheduler) {
+    MockKernel(Program *programArg, const KernelInfo &kernelInfoArg, ClDevice &clDeviceArg)
+        : Kernel(programArg, kernelInfoArg, clDeviceArg) {
     }
 
     ~MockKernel() override {
@@ -520,7 +519,7 @@ class MockParentKernel : public Kernel {
         return parent;
     }
 
-    MockParentKernel(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, *programArg->getDevices()[0], false) {
+    MockParentKernel(Program *programArg, const KernelInfo &kernelInfoArg) : Kernel(programArg, kernelInfoArg, *programArg->getDevices()[0]) {
     }
 
     ~MockParentKernel() override {

opencl/test/unit_test/preemption/preemption_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -35,14 +35,14 @@ class MidThreadPreemptionTests : public DevicePreemptionTests {
 
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowedByKmdThenThreadGroupPreemptionIsDisabled) {
     waTable->flags.waDisablePerCtxtPreemptionGranularityControl = 1;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowByDeviceThenThreadGroupPreemptionIsDisabled) {
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidThread, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -50,14 +50,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowByDeviceThenThreadGroupPreemptio
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowByReadWriteFencesWaThenThreadGroupPreemptionIsDisabled) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = true;
     waTable->flags.waDisableLSQCROPERFforOCL = 1;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
-    EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
-    EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
-}
-
-TEST_F(ThreadGroupPreemptionTests, GivenDisallowBySchedulerKernelThenThreadGroupPreemptionIsDisabled) {
-    kernel.reset(new MockKernel(program.get(), *kernelInfo, *device, true));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -65,7 +58,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDisallowBySchedulerKernelThenThreadGroup
 TEST_F(ThreadGroupPreemptionTests, GivenDisallowByVmeKernelThenThreadGroupPreemptionIsDisabled) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_FALSE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -77,14 +70,14 @@ TEST_F(ThreadGroupPreemptionTests, GivenDefaultThenThreadGroupPreemptionIsEnable
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenDefaultModeForNonKernelRequestThenThreadGroupPreemptionIsEnabled) {
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr, false);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOnThenThreadGroupPreemptionIsBeingSelected) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = false;
     waTable->flags.waDisableLSQCROPERFforOCL = 1;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -92,20 +85,20 @@ TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaI
 TEST_F(ThreadGroupPreemptionTests, givenKernelWithEnvironmentPatchSetWhenLSQCWaIsTurnedOffThenThreadGroupPreemptionIsBeingSelected) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = true;
     waTable->flags.waDisableLSQCROPERFforOCL = 0;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowThreadGroupPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenDefaultThenMidBatchPreemptionIsEnabled) {
     device->setPreemptionMode(PreemptionMode::MidBatch);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr, false);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
 TEST_F(ThreadGroupPreemptionTests, GivenDisabledThenPreemptionIsDisabled) {
     device->setPreemptionMode(PreemptionMode::Disabled);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr, false);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr);
     EXPECT_EQ(PreemptionMode::Disabled, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
 
@@ -129,31 +122,16 @@ TEST_F(ThreadGroupPreemptionTests, GivenValidKernelsInMdiAndDisabledPremptionThe
     EXPECT_EQ(PreemptionMode::Disabled, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
 }
 
-TEST_F(ThreadGroupPreemptionTests, GivenAtLeastOneInvalidKernelInMdiThenPreemptionIsDisabled) {
-    MockKernel schedulerKernel(program.get(), *kernelInfo, *device, true);
-    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::createPreemptionLevelFlags(device->getDevice(), &schedulerKernel.getDescriptor(), schedulerKernel.isSchedulerKernel);
-    EXPECT_EQ(PreemptionMode::MidBatch, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
-
-    MultiDispatchInfo multiDispatchInfo;
-    multiDispatchInfo.push(*dispatchInfo);
-    multiDispatchInfo.push(schedulerDispatchInfo);
-    multiDispatchInfo.push(*dispatchInfo);
-
-    EXPECT_EQ(PreemptionMode::MidBatch, ClPreemptionHelper::taskPreemptionMode(device->getDevice(), multiDispatchInfo));
-}
-
 TEST_F(MidThreadPreemptionTests, GivenMidThreadPreemptionThenMidThreadPreemptionIsEnabled) {
     device->setPreemptionMode(PreemptionMode::MidThread);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
 TEST_F(MidThreadPreemptionTests, GivenNullKernelThenMidThreadPreemptionIsEnabled) {
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr, false);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), nullptr);
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -162,14 +140,14 @@ TEST_F(MidThreadPreemptionTests, GivenMidThreadPreemptionDeviceSupportPreemption
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
 TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByDeviceThenMidThreadPreemptionIsEnabled) {
     device->setPreemptionMode(PreemptionMode::ThreadGroup);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_TRUE(PreemptionHelper::allowMidThreadPreemption(flags));
     EXPECT_EQ(PreemptionMode::ThreadGroup, PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags));
 }
@@ -177,7 +155,7 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByDeviceThenMid
 TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByKernelThenMidThreadPreemptionIsEnabled) {
     device->setPreemptionMode(PreemptionMode::MidThread);
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = true;
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
@@ -186,14 +164,14 @@ TEST_F(MidThreadPreemptionTests, GivenDisallowMidThreadPreemptionByVmeKernelThen
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
     kernelInfo->kernelDescriptor.kernelAttributes.flags.usesVme = true;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     EXPECT_FALSE(PreemptionHelper::allowMidThreadPreemption(flags));
 }
 
 TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByDeviceThenThreadGroupPreemptionIsEnabled) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
     device->setPreemptionMode(PreemptionMode::ThreadGroup);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
 }
@@ -201,7 +179,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByDeviceThe
 TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByKernelThenThreadGroupPreemptionIsEnabled) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = true;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::ThreadGroup, outMode);
 }
@@ -211,7 +189,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByVmeKernel
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = false;
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     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);
@@ -220,7 +198,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionDisallowMidThreadByVmeKernel
 TEST_F(MidThreadPreemptionTests, GivenDeviceSupportsMidThreadPreemptionThenMidThreadPreemptionIsEnabled) {
     kernelInfo->kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = false;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -231,7 +209,7 @@ TEST_F(MidThreadPreemptionTests, GivenTaskPreemptionAllowDeviceSupportsPreemptio
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
     device->sharedDeviceInfo.vmeAvcSupportsPreemption = true;
     device->setPreemptionMode(PreemptionMode::MidThread);
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -242,7 +220,7 @@ TEST_F(ThreadGroupPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsT
     EXPECT_EQ(PreemptionMode::ThreadGroup, device->getPreemptionMode());
 
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidThread, outMode);
 }
@@ -253,7 +231,7 @@ TEST_F(MidThreadPreemptionTests, GivenDebugKernelPreemptionWhenDeviceSupportsMid
     EXPECT_EQ(PreemptionMode::MidThread, device->getPreemptionMode());
 
     kernel.reset(new MockKernel(program.get(), *kernelInfo, *device));
-    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor(), kernel->isSchedulerKernel);
+    PreemptionFlags flags = PreemptionHelper::createPreemptionLevelFlags(device->getDevice(), &kernel->getDescriptor());
     PreemptionMode outMode = PreemptionHelper::taskPreemptionMode(device->getPreemptionMode(), flags);
     EXPECT_EQ(PreemptionMode::MidBatch, outMode);
 }

opencl/test/unit_test/program/program_nonuniform.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -107,7 +107,7 @@ TEST(KernelNonUniform, WhenSettingAllowNonUniformThenGettingAllowNonUniformRetur
     MockProgram program(toClDeviceVector(device));
     struct KernelMock : Kernel {
         KernelMock(Program *program, KernelInfo &kernelInfos, ClDevice &clDeviceArg)
-            : Kernel(program, kernelInfos, clDeviceArg, false) {
+            : Kernel(program, kernelInfos, clDeviceArg) {
         }
     };
     KernelMock k{&program, kernelInfo, device};