Add concurrent kernel execution type

SebastianLuzynski · Compute-Runtime-Automation · commit 556b6cd457ed · 2020-11-20T16:12:42.000+01:00
Related-To: NEO-4940
Signed-off-by: Sebastian Luzynski &lt;sebastian.jozef.luzynski@intel.com&gt;
diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl
@@ -369,7 +369,8 @@ void CommandQueueHw<gfxCoreFamily>::programFrontEnd(uint64_t scratchAddress, NEO
                                                     scratchAddress,
                                                     device->getMaxNumHwThreads(),
                                                     csr->getOsContext().getEngineType(),
-                                                    NEO::AdditionalKernelExecInfo::NotApplicable);
+                                                    NEO::AdditionalKernelExecInfo::NotApplicable,
+                                                    NEO::KernelExecutionType::NotApplicable);
     frontEndInit = true;
 }
 
diff --git a/opencl/source/command_queue/enqueue_common.h b/opencl/source/command_queue/enqueue_common.h
@@ -742,6 +742,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         L3CachingSettings::l3CacheOn,                                                               //l3CacheSettings
         kernel->getThreadArbitrationPolicy(),                                                       //threadArbitrationPolicy
         kernel->getAdditionalKernelExecInfo(),                                                      //additionalKernelExecInfo
+        kernel->getExecutionType(),                                                                 //kernelExecutionType
         getSliceCount(),                                                                            //sliceCount
         blocking,                                                                                   //blocking
         shouldFlushDC(commandType, printfHandler) || allocNeedsFlushDC,                             //dcFlush
@@ -955,6 +956,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
             L3CachingSettings::NotApplicable,                                    //l3CacheSettings
             ThreadArbitrationPolicy::NotPresent,                                 //threadArbitrationPolicy
             AdditionalKernelExecInfo::NotApplicable,                             //additionalKernelExecInfo
+            KernelExecutionType::NotApplicable,                                  //kernelExecutionType
             getSliceCount(),                                                     //sliceCount
             blocking,                                                            //blocking
             false,                                                               //dcFlush
diff --git a/opencl/source/device_queue/device_queue_hw_bdw_plus.inl b/opencl/source/device_queue/device_queue_hw_bdw_plus.inl
@@ -130,7 +130,9 @@ void DeviceQueueHw<GfxFamily>::addMediaStateClearCmds() {
 
     addDcFlushToPipeControlWa(pipeControl);
 
-    PreambleHelper<GfxFamily>::programVFEState(&slbCS, device->getHardwareInfo(), 0u, 0, device->getSharedDeviceInfo().maxFrontEndThreads, aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable);
+    PreambleHelper<GfxFamily>::programVFEState(&slbCS, device->getHardwareInfo(), 0u, 0, device->getSharedDeviceInfo().maxFrontEndThreads,
+                                               aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable,
+                                               KernelExecutionType::NotApplicable);
 }
 
 template <typename GfxFamily>
diff --git a/opencl/source/helpers/task_information.cpp b/opencl/source/helpers/task_information.cpp
@@ -61,6 +61,7 @@ CompletionStamp &CommandMapUnmap::submit(uint32_t taskLevel, bool terminated) {
         L3CachingSettings::NotApplicable,                                            //l3CacheSettings
         ThreadArbitrationPolicy::NotPresent,                                         //threadArbitrationPolicy
         AdditionalKernelExecInfo::NotApplicable,                                     //additionalKernelExecInfo
+        KernelExecutionType::NotApplicable,                                          //kernelExecutionType
         commandQueue.getSliceCount(),                                                //sliceCount
         true,                                                                        //blocking
         true,                                                                        //dcFlush
@@ -219,6 +220,7 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
         L3CachingSettings::l3CacheOn,                                                //l3CacheSettings
         kernel->getThreadArbitrationPolicy(),                                        //threadArbitrationPolicy
         kernel->getAdditionalKernelExecInfo(),                                       //additionalKernelExecInfo
+        kernel->getExecutionType(),                                                  //kernelExecutionType
         commandQueue.getSliceCount(),                                                //sliceCount
         true,                                                                        //blocking
         flushDC,                                                                     //dcFlush
@@ -340,6 +342,7 @@ CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminate
         L3CachingSettings::NotApplicable,                     //l3CacheSettings
         ThreadArbitrationPolicy::NotPresent,                  //threadArbitrationPolicy
         AdditionalKernelExecInfo::NotApplicable,              //additionalKernelExecInfo
+        KernelExecutionType::NotApplicable,                   //kernelExecutionType
         commandQueue.getSliceCount(),                         //sliceCount
         true,                                                 //blocking
         false,                                                //dcFlush
diff --git a/opencl/source/kernel/kernel_execution_type.h b/opencl/source/kernel/kernel_execution_type.h
@@ -10,6 +10,7 @@
 namespace NEO {
 enum class KernelExecutionType {
     Default = 0x0u,
-    Concurrent = 0x1u
+    Concurrent = 0x1u,
+    NotApplicable = 0x2u
 };
 } // namespace NEO
diff --git a/opencl/test/unit_test/command_queue/command_queue_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_tests.cpp
@@ -16,12 +16,14 @@
 
 #include "opencl/source/command_queue/command_queue_hw.h"
 #include "opencl/source/event/event.h"
+#include "opencl/source/event/user_event.h"
 #include "opencl/source/helpers/hardware_commands_helper.h"
 #include "opencl/test/unit_test/command_queue/command_queue_fixture.h"
 #include "opencl/test/unit_test/command_stream/command_stream_fixture.h"
 #include "opencl/test/unit_test/fixtures/buffer_fixture.h"
 #include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
 #include "opencl/test/unit_test/fixtures/context_fixture.h"
+#include "opencl/test/unit_test/fixtures/dispatch_flags_fixture.h"
 #include "opencl/test/unit_test/fixtures/image_fixture.h"
 #include "opencl/test/unit_test/fixtures/memory_management_fixture.h"
 #include "opencl/test/unit_test/helpers/unit_test_helper.h"
@@ -1212,3 +1214,62 @@ TEST(CommandQueue, givenCopySizeAndOffsetWhenCallingBlitEnqueueImageAllowedThenR
         EXPECT_EQ(expectedResult, queue.blitEnqueueImageAllowed(origin, region));
     }
 }
+
+using KernelExecutionTypesTests = DispatchFlagsTests;
+HWTEST_F(KernelExecutionTypesTests, givenConcurrentKernelWhileDoingNonBlockedEnqueueThenCorrectKernelTypeIsSetInCSR) {
+    using CsrType = MockCsrHw2<FamilyType>;
+    SetUpImpl<CsrType>();
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context.get(), device.get(), nullptr);
+    MockKernelWithInternals mockKernelWithInternals(*device.get());
+    auto pKernel = mockKernelWithInternals.mockKernel;
+
+    pKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL);
+    size_t gws[3] = {63, 0, 0};
+
+    mockCmdQ->enqueueKernel(pKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
+
+    auto &mockCsr = device->getUltCommandStreamReceiver<FamilyType>();
+    EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Concurrent);
+}
+
+HWTEST_F(KernelExecutionTypesTests, givenKernelWithDifferentExecutionTypeWhileDoingNonBlockedEnqueueThenKernelTypeInCSRIsChanging) {
+    using CsrType = MockCsrHw2<FamilyType>;
+    SetUpImpl<CsrType>();
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context.get(), device.get(), nullptr);
+    MockKernelWithInternals mockKernelWithInternals(*device.get());
+    auto pKernel = mockKernelWithInternals.mockKernel;
+    size_t gws[3] = {63, 0, 0};
+    auto &mockCsr = device->getUltCommandStreamReceiver<FamilyType>();
+
+    pKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL);
+    mockCmdQ->enqueueKernel(pKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
+    EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Concurrent);
+
+    mockCmdQ->enqueueMarkerWithWaitList(0, nullptr, nullptr);
+    EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Concurrent);
+
+    pKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_DEFAULT_TYPE_INTEL);
+    mockCmdQ->enqueueKernel(pKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
+
+    EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Default);
+}
+
+HWTEST_F(KernelExecutionTypesTests, givenConcurrentKernelWhileDoingBlockedEnqueueThenCorrectKernelTypeIsSetInCSR) {
+    using CsrType = MockCsrHw2<FamilyType>;
+    SetUpImpl<CsrType>();
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context.get(), device.get(), nullptr);
+    MockKernelWithInternals mockKernelWithInternals(*device.get());
+    auto pKernel = mockKernelWithInternals.mockKernel;
+
+    pKernel->setKernelExecutionType(CL_KERNEL_EXEC_INFO_CONCURRENT_TYPE_INTEL);
+    UserEvent userEvent;
+    cl_event waitlist[] = {&userEvent};
+    size_t gws[3] = {63, 0, 0};
+
+    mockCmdQ->enqueueKernel(pKernel, 1, nullptr, gws, nullptr, 1, waitlist, nullptr);
+    userEvent.setStatus(CL_COMPLETE);
+
+    auto &mockCsr = device->getUltCommandStreamReceiver<FamilyType>();
+    EXPECT_EQ(mockCsr.lastKernelExecutionType, KernelExecutionType::Concurrent);
+    mockCmdQ->isQueueBlocked();
+}
diff --git a/opencl/test/unit_test/command_stream/compute_mode_tests.h b/opencl/test/unit_test/command_stream/compute_mode_tests.h
@@ -81,6 +81,6 @@ struct ComputeModeRequirements : public ::testing::Test {
 
     CommandStreamReceiver *csr = nullptr;
     std::unique_ptr<MockDevice> device;
-    DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, ThreadArbitrationPolicy::NotPresent, AdditionalKernelExecInfo::NotApplicable, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false, false};
+    DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, ThreadArbitrationPolicy::NotPresent, AdditionalKernelExecInfo::NotApplicable, KernelExecutionType::NotApplicable, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false, false};
     GraphicsAllocation *alloc = nullptr;
 };
diff --git a/opencl/test/unit_test/libult/ult_command_stream_receiver.h b/opencl/test/unit_test/libult/ult_command_stream_receiver.h
@@ -69,6 +69,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
     using BaseClass::CommandStreamReceiver::isEnginePrologueSent;
     using BaseClass::CommandStreamReceiver::isPreambleSent;
     using BaseClass::CommandStreamReceiver::isStateSipSent;
+    using BaseClass::CommandStreamReceiver::lastKernelExecutionType;
     using BaseClass::CommandStreamReceiver::lastMediaSamplerConfig;
     using BaseClass::CommandStreamReceiver::lastPreemptionMode;
     using BaseClass::CommandStreamReceiver::lastSentCoherencyRequest;
diff --git a/shared/source/command_stream/command_stream_receiver.h b/shared/source/command_stream/command_stream_receiver.h
@@ -287,6 +287,7 @@ class CommandStreamReceiver {
     uint32_t requiredScratchSize = 0;
     uint32_t requiredPrivateScratchSize = 0;
     uint32_t lastAdditionalKernelExecInfo = AdditionalKernelExecInfo::NotSet;
+    KernelExecutionType lastKernelExecutionType = KernelExecutionType::Default;
 
     const uint32_t rootDeviceIndex;
     const DeviceBitfield deviceBitfield;
diff --git a/shared/source/command_stream/command_stream_receiver_hw_base.inl b/shared/source/command_stream/command_stream_receiver_hw_base.inl
@@ -311,6 +311,10 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
         setMediaVFEStateDirty(true);
     }
 
+    if (dispatchFlags.kernelExecutionType != KernelExecutionType::NotApplicable && lastKernelExecutionType != dispatchFlags.kernelExecutionType) {
+        setMediaVFEStateDirty(true);
+    }
+
     auto &commandStreamCSR = this->getCS(getRequiredCmdStreamSizeAligned(dispatchFlags, device));
     auto commandStreamStartCSR = commandStreamCSR.getUsed();
 
@@ -872,7 +876,10 @@ inline void CommandStreamReceiverHw<GfxFamily>::programVFEState(LinearStream &cs
         if (dispatchFlags.additionalKernelExecInfo != AdditionalKernelExecInfo::NotApplicable) {
             lastAdditionalKernelExecInfo = dispatchFlags.additionalKernelExecInfo;
         }
-        auto commandOffset = PreambleHelper<GfxFamily>::programVFEState(&csr, peekHwInfo(), requiredScratchSize, getScratchPatchAddress(), maxFrontEndThreads, getOsContext().getEngineType(), lastAdditionalKernelExecInfo);
+        if (dispatchFlags.kernelExecutionType != KernelExecutionType::NotApplicable) {
+            lastKernelExecutionType = dispatchFlags.kernelExecutionType;
+        }
+        auto commandOffset = PreambleHelper<GfxFamily>::programVFEState(&csr, peekHwInfo(), requiredScratchSize, getScratchPatchAddress(), maxFrontEndThreads, getOsContext().getEngineType(), lastAdditionalKernelExecInfo, lastKernelExecutionType);
         if (DebugManager.flags.AddPatchInfoCommentsForAUBDump.get()) {
             flatBatchBufferHelper->collectScratchSpacePatchInfo(getScratchPatchAddress(), commandOffset, csr);
         }
diff --git a/shared/source/command_stream/csr_definitions.h b/shared/source/command_stream/csr_definitions.h
@@ -14,6 +14,8 @@
 #include "shared/source/helpers/pipeline_select_args.h"
 #include "shared/source/kernel/grf_config.h"
 
+#include "opencl/source/kernel/kernel_execution_type.h"
+
 #include "csr_properties_flags.h"
 
 #include <limits>
@@ -50,7 +52,7 @@ struct DispatchFlags {
     DispatchFlags() = delete;
     DispatchFlags(CsrDependencies csrDependencies, TimestampPacketContainer *barrierTimestampPacketNodes, PipelineSelectArgs pipelineSelectArgs,
                   FlushStampTrackingObj *flushStampReference, QueueThrottle throttle, PreemptionMode preemptionMode, uint32_t numGrfRequired,
-                  uint32_t l3CacheSettings, uint32_t threadArbitrationPolicy, uint32_t additionalKernelExecInfo, uint64_t sliceCount, bool blocking, bool dcFlush,
+                  uint32_t l3CacheSettings, uint32_t threadArbitrationPolicy, uint32_t additionalKernelExecInfo, KernelExecutionType kernelExecutionType, uint64_t sliceCount, bool blocking, bool dcFlush,
                   bool useSLM, bool guardCommandBufferWithPipeControl, bool gsba32BitRequired,
                   bool requiresCoherency, bool lowPriority, bool implicitFlush,
                   bool outOfOrderExecutionAllowed, bool epilogueRequired, bool usePerDSSbackedBuffer) : csrDependencies(csrDependencies),
@@ -63,6 +65,7 @@ struct DispatchFlags {
                                                                                                         l3CacheSettings(l3CacheSettings),
                                                                                                         threadArbitrationPolicy(threadArbitrationPolicy),
                                                                                                         additionalKernelExecInfo(additionalKernelExecInfo),
+                                                                                                        kernelExecutionType(kernelExecutionType),
                                                                                                         sliceCount(sliceCount),
                                                                                                         blocking(blocking),
                                                                                                         dcFlush(dcFlush),
@@ -85,6 +88,7 @@ struct DispatchFlags {
     uint32_t l3CacheSettings = L3CachingSettings::l3CacheOn;
     uint32_t threadArbitrationPolicy = ThreadArbitrationPolicy::NotPresent;
     uint32_t additionalKernelExecInfo = AdditionalKernelExecInfo::NotApplicable;
+    KernelExecutionType kernelExecutionType = KernelExecutionType::NotApplicable;
     uint64_t sliceCount = QueueSliceCount::defaultSliceCount;
     uint64_t engineHints = 0;
     bool blocking = false;
diff --git a/shared/source/helpers/preamble.h b/shared/source/helpers/preamble.h
@@ -8,6 +8,8 @@
 #pragma once
 #include "shared/source/helpers/pipeline_select_helper.h"
 
+#include "opencl/source/kernel/kernel_execution_type.h"
+
 #include "engine_node.h"
 #include "igfxfmid.h"
 
@@ -42,7 +44,8 @@ struct PreambleHelper {
                                     uint64_t scratchAddress,
                                     uint32_t maxFrontEndThreads,
                                     aub_stream::EngineType engineType,
-                                    uint32_t additionalKernelExecInfo);
+                                    uint32_t additionalKernelExecInfo,
+                                    KernelExecutionType kernelExecutionType);
     static void programAdditionalFieldsInVfeState(VFE_STATE_TYPE *mediaVfeState, const HardwareInfo &hwInfo);
     static void programPreamble(LinearStream *pCommandStream, Device &device, uint32_t l3Config,
                                 uint32_t requiredThreadArbitrationPolicy, GraphicsAllocation *preemptionCsr, GraphicsAllocation *perDssBackedBuffer);
diff --git a/shared/source/helpers/preamble_bdw_plus.inl b/shared/source/helpers/preamble_bdw_plus.inl
@@ -9,6 +9,8 @@
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/helpers/preamble_base.inl"
 
+#include "opencl/source/kernel/kernel_execution_type.h"
+
 namespace NEO {
 
 template <typename GfxFamily>
@@ -31,7 +33,8 @@ uint64_t PreambleHelper<GfxFamily>::programVFEState(LinearStream *pCommandStream
                                                     uint64_t scratchAddress,
                                                     uint32_t maxFrontEndThreads,
                                                     aub_stream::EngineType engineType,
-                                                    uint32_t additionalExecInfo) {
+                                                    uint32_t additionalExecInfo,
+                                                    KernelExecutionType kernelExecutionType) {
     using MEDIA_VFE_STATE = typename GfxFamily::MEDIA_VFE_STATE;
 
     addPipeControlBeforeVfeCmd(pCommandStream, &hwInfo, engineType);
diff --git a/shared/test/unit_test/gen11/test_preamble_gen11.cpp b/shared/test/unit_test/gen11/test_preamble_gen11.cpp
@@ -58,7 +58,9 @@ GEN11TEST_F(Gen11PreambleVfeState, GivenWaOffWhenProgrammingVfeStateThenProgramm
     typedef typename ICLFamily::PIPE_CONTROL PIPE_CONTROL;
     testWaTable->waSendMIFLUSHBeforeVFE = 0;
     LinearStream &cs = linearStream;
-    PreambleHelper<ICLFamily>::programVFEState(&linearStream, pPlatform->getClDevice(0)->getHardwareInfo(), 0u, 0, 168u, aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable);
+    PreambleHelper<ICLFamily>::programVFEState(&linearStream, pPlatform->getClDevice(0)->getHardwareInfo(), 0u, 0, 168u,
+                                               aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable,
+                                               KernelExecutionType::NotApplicable);
 
     parseCommands<ICLFamily>(cs);
 
@@ -76,7 +78,9 @@ GEN11TEST_F(Gen11PreambleVfeState, GivenWaOnWhenProgrammingVfeStateThenProgrammi
     typedef typename ICLFamily::PIPE_CONTROL PIPE_CONTROL;
     testWaTable->waSendMIFLUSHBeforeVFE = 1;
     LinearStream &cs = linearStream;
-    PreambleHelper<ICLFamily>::programVFEState(&linearStream, pPlatform->getClDevice(0)->getHardwareInfo(), 0u, 0, 168u, aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable);
+    PreambleHelper<ICLFamily>::programVFEState(&linearStream, pPlatform->getClDevice(0)->getHardwareInfo(), 0u, 0, 168u,
+                                               aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable,
+                                               KernelExecutionType::NotApplicable);
 
     parseCommands<ICLFamily>(cs);
 
diff --git a/shared/test/unit_test/gen12lp/test_preamble_gen12lp.cpp b/shared/test/unit_test/gen12lp/test_preamble_gen12lp.cpp
diff --git a/shared/test/unit_test/gen8/test_preamble_gen8.cpp b/shared/test/unit_test/gen8/test_preamble_gen8.cpp
diff --git a/shared/test/unit_test/gen9/skl/test_preamble_skl.cpp b/shared/test/unit_test/gen9/skl/test_preamble_skl.cpp
diff --git a/shared/test/unit_test/helpers/dispatch_flags_helper.h b/shared/test/unit_test/helpers/dispatch_flags_helper.h
diff --git a/shared/test/unit_test/preamble/preamble_tests.cpp b/shared/test/unit_test/preamble/preamble_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,8 @@ void CommandQueueHw<gfxCoreFamily>::programFrontEnd(uint64_t scratchAddress, NEO`
`369`	`369`	`scratchAddress,`
`370`	`370`	`device->getMaxNumHwThreads(),`
`371`	`371`	`csr->getOsContext().getEngineType(),`
`372`		`- NEO::AdditionalKernelExecInfo::NotApplicable);`
	`372`	`+ NEO::AdditionalKernelExecInfo::NotApplicable,`
	`373`	`+ NEO::KernelExecutionType::NotApplicable);`
`373`	`374`	`frontEndInit = true;`
`374`	`375`	`}`
`375`	`376`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,9 @@ void DeviceQueueHw<GfxFamily>::addMediaStateClearCmds() {`
`130`	`130`
`131`	`131`	`addDcFlushToPipeControlWa(pipeControl);`
`132`	`132`
`133`		`- PreambleHelper<GfxFamily>::programVFEState(&slbCS, device->getHardwareInfo(), 0u, 0, device->getSharedDeviceInfo().maxFrontEndThreads, aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable);`
	`133`	`+ PreambleHelper<GfxFamily>::programVFEState(&slbCS, device->getHardwareInfo(), 0u, 0, device->getSharedDeviceInfo().maxFrontEndThreads,`
	`134`	`+ aub_stream::EngineType::ENGINE_RCS, AdditionalKernelExecInfo::NotApplicable,`
	`135`	`+ KernelExecutionType::NotApplicable);`
`134`	`136`	`}`
`135`	`137`
`136`	`138`	`template <typename GfxFamily>`