Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create ClPreemptionHelper

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2021-09-22 22:24:59 +00:00
committed by Compute-Runtime-Automation
parent 754fcae321
commit 80b49e4a47
11 changed files with 116 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
opencl/source/command_queue/enqueue_common.h
View File

@ -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,

3
opencl/source/command_queue/hardware_interface_base.inl
View File

@ -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

2
opencl/source/helpers/CMakeLists.txt
View File

@ -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

45
opencl/source/helpers/cl_preemption_helper.cpp Normal file
View File

@ -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

22
opencl/source/helpers/cl_preemption_helper.h Normal file
View File

@ -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

3
opencl/source/helpers/task_information.cpp
View File

@ -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

9
opencl/test/unit_test/gen8/test_preemption_gen8.cpp
View File

@ -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};

7
opencl/test/unit_test/gen9/test_preemption_gen9.cpp
View File

@ -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);

57
opencl/test/unit_test/preemption/preemption_tests.cpp
View File

@ -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);
}

37
shared/source/command_stream/preemption.cpp
View File

@ -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) {

5
shared/source/command_stream/preemption.h
View File

@ -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>