diff --git a/level_zero/core/source/cmdlist/cmdlist.cpp b/level_zero/core/source/cmdlist/cmdlist.cpp index ccf4c5d7df..41db9e53bd 100644 --- a/level_zero/core/source/cmdlist/cmdlist.cpp +++ b/level_zero/core/source/cmdlist/cmdlist.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2021 Intel Corporation + * Copyright (C) 2020-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -132,7 +132,7 @@ bool CommandList::isCopyOnly() const { } NEO::PreemptionMode CommandList::obtainFunctionPreemptionMode(Kernel *kernel) { - NEO::PreemptionFlags flags = NEO::PreemptionHelper::createPreemptionLevelFlags(*device->getNEODevice(), &kernel->getImmutableData()->getDescriptor(), false); + NEO::PreemptionFlags flags = NEO::PreemptionHelper::createPreemptionLevelFlags(*device->getNEODevice(), &kernel->getImmutableData()->getDescriptor()); return NEO::PreemptionHelper::taskPreemptionMode(device->getDevicePreemptionMode(), flags); } diff --git a/opencl/source/helpers/cl_preemption_helper.cpp b/opencl/source/helpers/cl_preemption_helper.cpp index 4eca19780c..3489a6a251 100644 --- a/opencl/source/helpers/cl_preemption_helper.cpp +++ b/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; diff --git a/opencl/source/helpers/hardware_commands_helper.h b/opencl/source/helpers/hardware_commands_helper.h index 47e7ab65a4..03ac2a29a1 100644 --- a/opencl/source/helpers/hardware_commands_helper.h +++ b/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); diff --git a/opencl/source/helpers/hardware_commands_helper_base.inl b/opencl/source/helpers/hardware_commands_helper_base.inl index 1fa9b95bf4..5bdcc94bad 100644 --- a/opencl/source/helpers/hardware_commands_helper_base.inl +++ b/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::sendIndirectState( uint64_t offsetInterfaceDescriptor = offsetInterfaceDescriptorTable + interfaceDescriptorIndex * sizeof(INTERFACE_DESCRIPTOR_DATA); auto bindingTablePrefetchSize = std::min(31u, static_cast(kernel.getNumberOfBindingTableStates())); - if (resetBindingTablePrefetch(kernel)) { + if (resetBindingTablePrefetch()) { bindingTablePrefetchSize = 0; } diff --git a/opencl/source/helpers/hardware_commands_helper_bdw_and_later.inl b/opencl/source/helpers/hardware_commands_helper_bdw_and_later.inl index d173396195..a605f2020a 100644 --- a/opencl/source/helpers/hardware_commands_helper_bdw_and_later.inl +++ b/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::sendCrossThreadData( } template -bool HardwareCommandsHelper::resetBindingTablePrefetch(Kernel &kernel) { - return kernel.isSchedulerKernel || !EncodeSurfaceState::doBindingTablePrefetch(); +bool HardwareCommandsHelper::resetBindingTablePrefetch() { + return !EncodeSurfaceState::doBindingTablePrefetch(); } template diff --git a/opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl b/opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl index d94a0bba44..ff974a9662 100644 --- a/opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl +++ b/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::sendCrossThreadData( } template -bool HardwareCommandsHelper::resetBindingTablePrefetch(Kernel &kernel) { - return kernel.isSchedulerKernel; +bool HardwareCommandsHelper::resetBindingTablePrefetch() { + return false; } template diff --git a/opencl/source/kernel/kernel.cpp b/opencl/source/kernel/kernel.cpp index e69b637ce5..72c9a65e8c 100644 --- a/opencl/source/kernel/kernel.cpp +++ b/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, diff --git a/opencl/source/kernel/kernel.h b/opencl/source/kernel/kernel.h index 0603b5c80f..3f6c6417eb 100644 --- a/opencl/source/kernel/kernel.h +++ b/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 { bool isBuiltIn = false; const bool isParentKernel; - const bool isSchedulerKernel; uint32_t getThreadArbitrationPolicy() const { return threadArbitrationPolicy; @@ -504,7 +503,7 @@ class Kernel : public ReferenceTrackedObject { 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(); diff --git a/opencl/source/scheduler/scheduler_kernel.h b/opencl/source/scheduler/scheduler_kernel.h index b7100d1402..cf89dcae81 100644 --- a/opencl/source/scheduler/scheduler_kernel.h +++ b/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(); }; diff --git a/opencl/test/unit_test/gen8/test_preemption_gen8.cpp b/opencl/test/unit_test/gen8/test_preemption_gen8.cpp index c1bc3f0075..fc2c0f891f 100644 --- a/opencl/test/unit_test/gen8/test_preemption_gen8.cpp +++ b/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}; diff --git a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp index 59b397db8e..29b64b5dda 100644 --- a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp +++ b/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 cmdQ(pContext, pClDevice, 0, false); - - auto &commandStream = cmdQ.getCS(1024); - auto pWalkerCmd = static_cast(commandStream.getSpace(sizeof(GPGPU_WALKER))); - *pWalkerCmd = FamilyType::cmdInitGpgpuWalker; - - auto expectedBindingTableCount = 3u; - mockKernelWithInternal->mockKernel->numberOfBindingTableStates = expectedBindingTableCount; - auto isScheduler = const_cast(&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::kernelUsesLocalIds(*mockKernelWithInternal->mockKernel); - - HardwareCommandsHelper::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(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::kernelUsesLocalIds(mockKernel); diff --git a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp b/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp index bde856e69d..20d210ae19 100644 --- a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp +++ b/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; diff --git a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp b/opencl/test/unit_test/kernel/parent_kernel_tests.cpp index 9f1bab6101..a25c825d80 100644 --- a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp +++ b/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) { diff --git a/opencl/test/unit_test/mocks/mock_kernel.h b/opencl/test/unit_test/mocks/mock_kernel.h index 12e60a06a5..50bfd14c48 100644 --- a/opencl/test/unit_test/mocks/mock_kernel.h +++ b/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 { diff --git a/opencl/test/unit_test/preemption/preemption_tests.cpp b/opencl/test/unit_test/preemption/preemption_tests.cpp index 97411b023a..87559f56b6 100644 --- a/opencl/test/unit_test/preemption/preemption_tests.cpp +++ b/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(1, 1, 1), Vec3(1, 1, 1), Vec3(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); } diff --git a/opencl/test/unit_test/program/program_nonuniform.cpp b/opencl/test/unit_test/program/program_nonuniform.cpp index d827108e86..d7e1b62c57 100644 --- a/opencl/test/unit_test/program/program_nonuniform.cpp +++ b/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}; diff --git a/shared/source/command_stream/preemption.cpp b/shared/source/command_stream/preemption.cpp index 6fe8e3a40f..9651db10d3 100644 --- a/shared/source/command_stream/preemption.cpp +++ b/shared/source/command_stream/preemption.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -23,7 +23,7 @@ bool PreemptionHelper::allowThreadGroupPreemption(const PreemptionFlags &flags) flags.flags.disableLSQCROPERFforOCL) { return false; } - if (flags.flags.schedulerKernel || flags.flags.vmeKernel) { + if (flags.flags.vmeKernel) { return false; } @@ -77,13 +77,12 @@ PreemptionMode PreemptionHelper::getDefaultPreemptionMode(const HardwareInfo &hw : static_cast(DebugManager.flags.ForcePreemptionMode.get()); } -PreemptionFlags PreemptionHelper::createPreemptionLevelFlags(Device &device, const KernelDescriptor *kernelDescriptor, bool schedulerKernel) { +PreemptionFlags PreemptionHelper::createPreemptionLevelFlags(Device &device, const KernelDescriptor *kernelDescriptor) { PreemptionFlags flags = {}; if (kernelDescriptor) { flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor->kernelAttributes.flags.requiresDisabledMidThreadPreemption; flags.flags.vmeKernel = kernelDescriptor->kernelAttributes.flags.usesVme; flags.flags.usesFencesForReadWriteImages = kernelDescriptor->kernelAttributes.flags.usesFencesForReadWriteImages; - flags.flags.schedulerKernel = schedulerKernel; } flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption; flags.flags.disablePerCtxtPreemptionGranularityControl = device.getHardwareInfo().workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl; diff --git a/shared/source/command_stream/preemption.h b/shared/source/command_stream/preemption.h index c6078848f1..82f0d6b7f4 100644 --- a/shared/source/command_stream/preemption.h +++ b/shared/source/command_stream/preemption.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -31,8 +31,7 @@ struct PreemptionFlags { uint32_t disablePerCtxtPreemptionGranularityControl : 1; uint32_t usesFencesForReadWriteImages : 1; uint32_t disableLSQCROPERFforOCL : 1; - uint32_t schedulerKernel : 1; - uint32_t reserved : 25; + uint32_t reserved : 26; } flags; uint32_t data; }; @@ -47,7 +46,7 @@ class PreemptionHelper { static bool allowThreadGroupPreemption(const PreemptionFlags &flags); static bool allowMidThreadPreemption(const PreemptionFlags &flags); static void adjustDefaultPreemptionMode(RuntimeCapabilityTable &deviceCapabilities, bool allowMidThread, bool allowThreadGroup, bool allowMidBatch); - static PreemptionFlags createPreemptionLevelFlags(Device &device, const KernelDescriptor *kernelDescriptor, bool schedulerKernel); + static PreemptionFlags createPreemptionLevelFlags(Device &device, const KernelDescriptor *kernelDescriptor); template static size_t getRequiredPreambleSize(const Device &device);