Rename special pipeline select mode to systolic

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>

opencl/source/command_queue/enqueue_common.h

@@ -700,7 +700,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
 
     auto mediaSamplerRequired = false;
     uint32_t numGrfRequired = GrfConfig::DefaultGrfNumber;
-    auto specialPipelineSelectMode = false;
+    auto systolicPipelineSelectMode = false;
     Kernel *kernel = nullptr;
     bool auxTranslationRequired = false;
     bool useGlobalAtomics = false;
@@ -716,7 +716,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         mediaSamplerRequired |= kernel->isVmeKernel();
         auto numGrfRequiredByKernel = static_cast<uint32_t>(kernel->getKernelInfo().kernelDescriptor.kernelAttributes.numGrfRequired);
         numGrfRequired = std::max(numGrfRequired, numGrfRequiredByKernel);
-        specialPipelineSelectMode |= kernel->requiresSpecialPipelineSelectMode();
+        systolicPipelineSelectMode |= kernel->requiresSystolicPipelineSelectMode();
         auxTranslationRequired |= kernel->isAuxTranslationRequired();
         if (kernel->hasUncacheableStatelessArgs()) {
             anyUncacheableArgs = true;
@@ -791,7 +791,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         isTextureCacheFlushNeeded(commandType));                                                    // textureCacheFlush
 
     dispatchFlags.pipelineSelectArgs.mediaSamplerRequired = mediaSamplerRequired;
-    dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode = specialPipelineSelectMode;
+    dispatchFlags.pipelineSelectArgs.systolicPipelineSelectMode = systolicPipelineSelectMode;
 
     dispatchFlags.disableEUFusion = kernel->getKernelInfo().kernelDescriptor.kernelAttributes.flags.requiresDisabledEUFusion;
 

opencl/source/helpers/task_information.cpp

@@ -223,7 +223,7 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
         }
         dispatchFlags.barrierTimestampPacketNodes = &timestampPacketDependencies->barrierNodes;
     }
-    dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode = kernel->requiresSpecialPipelineSelectMode();
+    dispatchFlags.pipelineSelectArgs.systolicPipelineSelectMode = kernel->requiresSystolicPipelineSelectMode();
     if (anyUncacheableArgs) {
         dispatchFlags.l3CacheSettings = L3CachingSettings::l3CacheOff;
     } else if (!kernel->areStatelessWritesUsed()) {

opencl/source/kernel/kernel.cpp

@@ -2178,7 +2178,7 @@ void Kernel::reconfigureKernel() {
         maxKernelWorkGroupSize >>= 1;
     }
     this->containsStatelessWrites = kernelDescriptor.kernelAttributes.flags.usesStatelessWrites;
-    this->specialPipelineSelectMode = kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode;
+    this->systolicPipelineSelectMode = kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode;
 }
 
 bool Kernel::requiresCacheFlushCommand(const CommandQueue &commandQueue) const {

opencl/source/kernel/kernel.h

@@ -283,7 +283,7 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
 
     bool getAllowNonUniform() const { return program->getAllowNonUniform(); }
     bool isVmeKernel() const { return kernelInfo.kernelDescriptor.kernelAttributes.flags.usesVme; }
-    bool requiresSpecialPipelineSelectMode() const { return specialPipelineSelectMode; }
+    bool requiresSystolicPipelineSelectMode() const { return systolicPipelineSelectMode; }
 
     void performKernelTuning(CommandStreamReceiver &commandStreamReceiver, const Vec3<size_t> &lws, const Vec3<size_t> &gws, const Vec3<size_t> &offsets, TimestampPacketContainer *timestampContainer);
     MOCKABLE_VIRTUAL bool isSingleSubdevicePreferred() const;
@@ -527,7 +527,7 @@ class Kernel : public ReferenceTrackedObject<Kernel> {
     bool usingImages = false;
     bool usingImagesOnly = false;
     bool auxTranslationRequired = false;
-    bool specialPipelineSelectMode = false;
+    bool systolicPipelineSelectMode = false;
     bool svmAllocationsRequireCacheFlush = false;
     bool isUnifiedMemorySyncRequired = true;
     bool debugEnabled = false;

opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp

@@ -1084,7 +1084,7 @@ HWTEST2_F(CommandStreamReceiverFlushTaskTests, givenSpecialPipelineSelectModeCha
     CsrSizeRequestFlags csrSizeRequest = {};
     DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
 
-    csrSizeRequest.specialPipelineSelectModeChanged = true;
+    csrSizeRequest.systolicPipelineSelectMode = true;
     commandStreamReceiver.overrideCsrSizeReqFlags(csrSizeRequest);
     size_t size = commandStreamReceiver.getCmdSizeForPipelineSelect();
 

opencl/test/unit_test/helpers/task_information_tests.cpp

@@ -294,7 +294,7 @@ HWTEST_F(DispatchFlagsTests, givenCommandComputeKernelWhenSubmitThenPassCorrectD
     std::unique_ptr<Command> command(new CommandComputeKernel(*mockCmdQ, kernelOperation, surfaces, flushDC, slmUsed, ndRangeKernel, nullptr, preemptionMode, kernel, 1));
     command->submit(20, false);
 
-    EXPECT_FALSE(mockCsr->passedDispatchFlags.pipelineSelectArgs.specialPipelineSelectMode);
+    EXPECT_FALSE(mockCsr->passedDispatchFlags.pipelineSelectArgs.systolicPipelineSelectMode);
     EXPECT_EQ(kernel.mockKernel->isVmeKernel(), mockCsr->passedDispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
     EXPECT_EQ(mockCmdQ->flushStamp->getStampReference(), mockCsr->passedDispatchFlags.flushStampReference);
     EXPECT_EQ(mockCmdQ->getThrottle(), mockCsr->passedDispatchFlags.throttle);
@@ -342,7 +342,7 @@ HWTEST_F(DispatchFlagsTests, givenClCommandCopyImageWhenSubmitThenFlushTextureCa
     std::unique_ptr<Command> command(new CommandComputeKernel(*mockCmdQ, kernelOperation, surfaces, flushDC, slmUsed, commandType, nullptr, preemptionMode, kernel, 1));
     command->submit(20, false);
 
-    EXPECT_FALSE(mockCsr->passedDispatchFlags.pipelineSelectArgs.specialPipelineSelectMode);
+    EXPECT_FALSE(mockCsr->passedDispatchFlags.pipelineSelectArgs.systolicPipelineSelectMode);
     EXPECT_EQ(kernel.mockKernel->isVmeKernel(), mockCsr->passedDispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
     EXPECT_EQ(mockCmdQ->flushStamp->getStampReference(), mockCsr->passedDispatchFlags.flushStampReference);
     EXPECT_EQ(mockCmdQ->getThrottle(), mockCsr->passedDispatchFlags.throttle);

opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp

@@ -542,12 +542,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, RenderSurfaceStateXeHPAndLaterTests, givenSpecificP
 
 using PipelineSelectTest = ::testing::Test;
 
-HWCMDTEST_F(IGFX_XE_HP_CORE, PipelineSelectTest, whenCallingIsSpecialPipelineSelectModeChangedThenReturnCorrectValue) {
+HWCMDTEST_F(IGFX_XE_HP_CORE, PipelineSelectTest, whenCallingIsSystolicPipelineSelectModeChangedThenReturnCorrectValue) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
-    bool oldPipelineSelectSpecialMode = true;
+    bool oldPipelineSelectSystolicMode = true;
-    bool newPipelineSelectSpecialMode = false;
+    bool newPipelineSelectSystolicMode = false;
 
-    auto result = PreambleHelper<FamilyType>::isSpecialPipelineSelectModeChanged(oldPipelineSelectSpecialMode, newPipelineSelectSpecialMode, *defaultHwInfo);
+    auto result = PreambleHelper<FamilyType>::isSystolicPipelineSelectModeChanged(oldPipelineSelectSystolicMode, newPipelineSelectSystolicMode, *defaultHwInfo);
     EXPECT_TRUE(result);
 }
 

opencl/test/unit_test/mocks/mock_kernel.h

@@ -243,7 +243,7 @@ class MockKernel : public Kernel {
     void makeResident(CommandStreamReceiver &commandStreamReceiver) override;
     void getResidency(std::vector<Surface *> &dst) override;
 
-    void setSpecialPipelineSelectMode(bool value) { specialPipelineSelectMode = value; }
+    void setSystolicPipelineSelectMode(bool value) { systolicPipelineSelectMode = value; }
 
     bool requiresCacheFlushCommand(const CommandQueue &commandQueue) const override;
 

opencl/test/unit_test/xe_hpc_core/pvc/command_stream_receiver_hw_tests_pvc.cpp

@@ -65,11 +65,11 @@ PVCTEST_F(PvcCommandStreamReceiverFlushTaskTests, givenNotExistPolicyWhenFlushin
     EXPECT_EQ(notExistPolicy, commandStreamReceiver.streamProperties.stateComputeMode.threadArbitrationPolicy.value);
 }
 
-PVCTEST_F(PvcCommandStreamReceiverFlushTaskTests, givenRevisionBAndAboveWhenLastSpecialPipelineSelectModeIsTrueAndFlushTaskIsCalledThenDontReprogramPipelineSelect) {
+PVCTEST_F(PvcCommandStreamReceiverFlushTaskTests, givenRevisionBAndAboveWhenLastSystolicPipelineSelectModeIsTrueAndFlushTaskIsCalledThenDontReprogramPipelineSelect) {
     auto hwInfo = pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
     auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
 
-    flushTaskFlags.pipelineSelectArgs.specialPipelineSelectMode = true;
+    flushTaskFlags.pipelineSelectArgs.systolicPipelineSelectMode = true;
     flushTaskFlags.pipelineSelectArgs.mediaSamplerRequired = false;
 
     struct {
@@ -90,8 +90,8 @@ PVCTEST_F(PvcCommandStreamReceiverFlushTaskTests, givenRevisionBAndAboveWhenLast
 
         flushTask(commandStreamReceiver);
 
-        EXPECT_EQ(testInput.expectedValue, commandStreamReceiver.lastSpecialPipelineSelectMode);
+        EXPECT_EQ(testInput.expectedValue, commandStreamReceiver.lastSystolicPipelineSelectMode);
-        commandStreamReceiver.lastSpecialPipelineSelectMode = false;
+        commandStreamReceiver.lastSystolicPipelineSelectMode = false;
     }
 }
 

shared/source/command_container/command_encoder_xehp_and_later.inl

@@ -65,9 +65,9 @@ void EncodeDispatchKernel<Family>::encode(CommandContainer &container, EncodeDis
         threadDimsVec = {threadDims[0], threadDims[1], threadDims[2]};
     }
 
-    bool specialModeRequired = kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode;
+    bool systolicModeRequired = kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode;
-    if (PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(container.lastPipelineSelectModeRequired, specialModeRequired, hwInfo)) {
+    if (PreambleHelper<Family>::isSystolicPipelineSelectModeChanged(container.lastPipelineSelectModeRequired, systolicModeRequired, hwInfo)) {
-        container.lastPipelineSelectModeRequired = specialModeRequired;
+        container.lastPipelineSelectModeRequired = systolicModeRequired;
         EncodeComputeMode<Family>::adjustPipelineSelect(container, kernelDescriptor);
     }
 
@@ -596,9 +596,9 @@ template <typename Family>
 void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {
     using PIPELINE_SELECT = typename Family::PIPELINE_SELECT;
     auto pipelineSelectCmd = Family::cmdInitPipelineSelect;
-    auto isSpecialModeSelected = kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode;
+    auto isSystolicModeSelected = kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode;
 
-    PreambleHelper<Family>::appendProgramPipelineSelect(&pipelineSelectCmd, isSpecialModeSelected, container.getDevice()->getHardwareInfo());
+    PreambleHelper<Family>::appendProgramPipelineSelect(pipelineSelectCmd, isSystolicModeSelected, container.getDevice()->getHardwareInfo());
 
     pipelineSelectCmd.setPipelineSelection(PIPELINE_SELECT::PIPELINE_SELECTION_GPGPU);
 

shared/source/command_stream/command_stream_receiver.h

@@ -460,7 +460,7 @@ class CommandStreamReceiver {
     bool timestampPacketWriteEnabled = false;
     bool staticWorkPartitioningEnabled = false;
     bool nTo1SubmissionModelEnabled = false;
-    bool lastSpecialPipelineSelectMode = false;
+    bool lastSystolicPipelineSelectMode = false;
     bool requiresInstructionCacheFlush = false;
 
     bool localMemoryEnabled = false;

shared/source/command_stream/command_stream_receiver_hw_base.inl

@@ -261,9 +261,9 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
     }
 
     auto newL3Config = PreambleHelper<GfxFamily>::getL3Config(hwInfo, dispatchFlags.useSLM);
-    auto isSpecialPipelineSelectModeChanged = PreambleHelper<GfxFamily>::isSpecialPipelineSelectModeChanged(lastSpecialPipelineSelectMode,
+    auto isSystolicPipelineSelectModeChanged = PreambleHelper<GfxFamily>::isSystolicPipelineSelectModeChanged(lastSystolicPipelineSelectMode,
-                                                                                                            dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode,
+                                                                                                              dispatchFlags.pipelineSelectArgs.systolicPipelineSelectMode,
-                                                                                                            hwInfo);
+                                                                                                              hwInfo);
 
     auto requiresCoherency = hwHelper.forceNonGpuCoherencyWA(dispatchFlags.requiresCoherency);
     this->streamProperties.stateComputeMode.setProperties(requiresCoherency, dispatchFlags.numGrfRequired,
@@ -272,7 +272,7 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
     csrSizeRequestFlags.l3ConfigChanged = this->lastSentL3Config != newL3Config;
     csrSizeRequestFlags.preemptionRequestChanged = this->lastPreemptionMode != dispatchFlags.preemptionMode;
     csrSizeRequestFlags.mediaSamplerConfigChanged = this->lastMediaSamplerConfig != static_cast<int8_t>(dispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
-    csrSizeRequestFlags.specialPipelineSelectModeChanged = isSpecialPipelineSelectModeChanged;
+    csrSizeRequestFlags.systolicPipelineSelectMode = isSystolicPipelineSelectModeChanged;
 
     csrSizeRequestFlags.activePartitionsChanged = isProgramActivePartitionConfigRequired();
 
@@ -902,7 +902,7 @@ template <typename GfxFamily>
 inline size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForPipelineSelect() const {
     size_t size = 0;
     if ((csrSizeRequestFlags.mediaSamplerConfigChanged ||
-         csrSizeRequestFlags.specialPipelineSelectModeChanged ||
+         csrSizeRequestFlags.systolicPipelineSelectMode ||
          !isPreambleSent) &&
         !isPipelineSelectAlreadyProgrammed()) {
         size += PreambleHelper<GfxFamily>::getCmdSizeForPipelineSelect(peekHwInfo());

shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl

@@ -46,10 +46,10 @@ size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForL3Config() const { retur
 
 template <typename GfxFamily>
 void CommandStreamReceiverHw<GfxFamily>::programPipelineSelect(LinearStream &commandStream, PipelineSelectArgs &pipelineSelectArgs) {
-    if (csrSizeRequestFlags.mediaSamplerConfigChanged || csrSizeRequestFlags.specialPipelineSelectModeChanged || !isPreambleSent) {
+    if (csrSizeRequestFlags.mediaSamplerConfigChanged || csrSizeRequestFlags.systolicPipelineSelectMode || !isPreambleSent) {
         PreambleHelper<GfxFamily>::programPipelineSelect(&commandStream, pipelineSelectArgs, peekHwInfo());
         this->lastMediaSamplerConfig = pipelineSelectArgs.mediaSamplerRequired;
-        this->lastSpecialPipelineSelectMode = pipelineSelectArgs.specialPipelineSelectMode;
+        this->lastSystolicPipelineSelectMode = pipelineSelectArgs.systolicPipelineSelectMode;
     }
 }
 

shared/source/command_stream/csr_definitions.h

@@ -124,7 +124,7 @@ struct CsrSizeRequestFlags {
     bool preemptionRequestChanged = false;
     bool mediaSamplerConfigChanged = false;
     bool hasSharedHandles = false;
-    bool specialPipelineSelectModeChanged = false;
+    bool systolicPipelineSelectMode = false;
     bool activePartitionsChanged = false;
 };
 } // namespace NEO

shared/source/device_binary_format/zebin_decoder.cpp

@@ -1098,7 +1098,7 @@ NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<N
     kernelDescriptor.kernelAttributes.flags.useGlobalAtomics = execEnv.hasGlobalAtomics;
     kernelDescriptor.kernelAttributes.flags.useStackCalls = execEnv.hasStackCalls;
     kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages = execEnv.hasFenceForImageAccess;
-    kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = execEnv.hasDpas;
+    kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = execEnv.hasDpas;
     kernelDescriptor.kernelAttributes.flags.usesStatelessWrites = (false == execEnv.hasNoStatelessWrite);
     kernelDescriptor.kernelAttributes.barrierCount = execEnv.barrierCount;
     kernelDescriptor.kernelAttributes.bufferAddressingMode = (execEnv.has4GBBuffers) ? KernelDescriptor::Stateless : KernelDescriptor::BindfulAndStateless;

shared/source/gen12lp/adlp/os_agnostic_hw_info_config_adlp.inl

@@ -43,5 +43,5 @@ void HwInfoConfigHw<gfxProduct>::setAdditionalPipelineSelectFields(void *pipelin
 
     mask |= pipelineSelectSystolicModeEnableMaskBits;
     pipelineSelectTglplpCmd->setMaskBits(mask);
-    pipelineSelectTglplpCmd->setSpecialModeEnable(pipelineSelectArgs.specialPipelineSelectMode);
+    pipelineSelectTglplpCmd->setSpecialModeEnable(pipelineSelectArgs.systolicPipelineSelectMode);
 }

shared/source/helpers/pipeline_select_args.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2021 Intel Corporation
+ * Copyright (C) 2019-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,7 +9,7 @@
 
 namespace NEO {
 struct PipelineSelectArgs {
-    bool specialPipelineSelectMode = false;
+    bool systolicPipelineSelectMode = false;
     bool mediaSamplerRequired = false;
     bool is3DPipelineRequired = false;
 };

shared/source/helpers/preamble.h

@@ -35,7 +35,7 @@ struct PreambleHelper {
     static void programPipelineSelect(LinearStream *pCommandStream,
                                       const PipelineSelectArgs &pipelineSelectArgs,
                                       const HardwareInfo &hwInfo);
-    static void appendProgramPipelineSelect(void *cmd, bool isSpecialModeSelected, const HardwareInfo &hwInfo);
+    static void appendProgramPipelineSelect(typename GfxFamily::PIPELINE_SELECT &cmd, bool isSystolicModeSelected, const HardwareInfo &hwInfo);
     static void programPreemption(LinearStream *pCommandStream, Device &device, GraphicsAllocation *preemptionCsr, LogicalStateHelper *logicalStateHelper);
     static void addPipeControlBeforeVfeCmd(LinearStream *pCommandStream, const HardwareInfo *hwInfo, EngineGroupType engineGroupType);
     static void appendProgramVFEState(const HardwareInfo &hwInfo, const StreamProperties &streamProperties, void *cmd);
@@ -57,8 +57,8 @@ struct PreambleHelper {
     static uint32_t getL3Config(const HardwareInfo &hwInfo, bool useSLM);
     static bool isL3Configurable(const HardwareInfo &hwInfo);
     static bool isSystolicModeConfigurable(const HardwareInfo &hwInfo);
-    static bool isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+    static bool isSystolicPipelineSelectModeChanged(bool lastSystolicPipelineSelectMode, bool newSystolicPipelineSelectMode,
-                                                   const HardwareInfo &hwInfo);
+                                                    const HardwareInfo &hwInfo);
     static size_t getAdditionalCommandsSize(const Device &device);
     static std::vector<int32_t> getSupportedThreadArbitrationPolicies();
     static size_t getVFECommandsSize();

shared/source/helpers/preamble_bdw_and_later.inl

@@ -75,7 +75,7 @@ size_t PreambleHelper<GfxFamily>::getVFECommandsSize() {
 }
 
 template <typename GfxFamily>
-void PreambleHelper<GfxFamily>::appendProgramPipelineSelect(void *cmd, bool isSpecialModeSelected, const HardwareInfo &hwInfo) {}
+void PreambleHelper<GfxFamily>::appendProgramPipelineSelect(typename GfxFamily::PIPELINE_SELECT &cmd, bool isSystolicModeSelected, const HardwareInfo &hwInfo) {}
 
 template <typename GfxFamily>
 bool PreambleHelper<GfxFamily>::isSystolicModeConfigurable(const HardwareInfo &hwInfo) {
@@ -83,8 +83,8 @@ bool PreambleHelper<GfxFamily>::isSystolicModeConfigurable(const HardwareInfo &h
 }
 
 template <typename GfxFamily>
-bool PreambleHelper<GfxFamily>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+bool PreambleHelper<GfxFamily>::isSystolicPipelineSelectModeChanged(bool lastSystolicPipelineSelectMode, bool newSystolicPipelineSelectMode,
-                                                                   const HardwareInfo &hwInfo) {
+                                                                    const HardwareInfo &hwInfo) {
     return false;
 }
 } // namespace NEO

shared/source/helpers/preamble_xehp_and_later.inl

@@ -26,22 +26,20 @@ template <>
 bool PreambleHelper<Family>::isSystolicModeConfigurable(const HardwareInfo &hwInfo);
 
 template <typename Family>
-void PreambleHelper<Family>::appendProgramPipelineSelect(void *cmd, bool isSpecialModeSelected, const HardwareInfo &hwInfo) {
+void PreambleHelper<Family>::appendProgramPipelineSelect(typename Family::PIPELINE_SELECT &cmd, bool isSystolicModeSelected, const HardwareInfo &hwInfo) {
-    using PIPELINE_SELECT = typename Family::PIPELINE_SELECT;
+    auto mask = cmd.getMaskBits();
-    auto command = static_cast<PIPELINE_SELECT *>(cmd);
-    auto mask = command->getMaskBits();
 
     if (PreambleHelper<Family>::isSystolicModeConfigurable(hwInfo)) {
-        command->setSystolicModeEnable(isSpecialModeSelected);
+        cmd.setSystolicModeEnable(isSystolicModeSelected);
         mask |= pipelineSelectSystolicModeEnableMaskBits;
     }
 
     if (DebugManager.flags.OverrideSystolicPipelineSelect.get() != -1) {
-        command->setSystolicModeEnable(DebugManager.flags.OverrideSystolicPipelineSelect.get());
+        cmd.setSystolicModeEnable(DebugManager.flags.OverrideSystolicPipelineSelect.get());
         mask |= pipelineSelectSystolicModeEnableMaskBits;
     }
 
-    command->setMaskBits(mask);
+    cmd.setMaskBits(mask);
 }
 
 template <typename Family>
@@ -54,16 +52,16 @@ void PreambleHelper<Family>::programPipelineSelect(LinearStream *pCommandStream,
     PIPELINE_SELECT cmd = Family::cmdInitPipelineSelect;
 
     if (DebugManager.flags.CleanStateInPreamble.get()) {
-        auto pCmd = pCommandStream->getSpaceForCmd<PIPELINE_SELECT>();
+        auto cmdBuffer = pCommandStream->getSpaceForCmd<PIPELINE_SELECT>();
         cmd.setPipelineSelection(PIPELINE_SELECT::PIPELINE_SELECTION_3D);
-        *pCmd = cmd;
+        *cmdBuffer = cmd;
 
         PipeControlArgs args = {};
         args.stateCacheInvalidationEnable = true;
         MemorySynchronizationCommands<Family>::addSingleBarrier(*pCommandStream, args);
     }
 
-    auto pCmd = pCommandStream->getSpaceForCmd<PIPELINE_SELECT>();
+    auto cmdBuffer = pCommandStream->getSpaceForCmd<PIPELINE_SELECT>();
 
     auto mask = pipelineSelectEnablePipelineSelectMaskBits;
 
@@ -74,9 +72,9 @@ void PreambleHelper<Family>::programPipelineSelect(LinearStream *pCommandStream,
     }
     cmd.setMaskBits(mask);
 
-    appendProgramPipelineSelect(&cmd, pipelineSelectArgs.specialPipelineSelectMode, hwInfo);
+    appendProgramPipelineSelect(cmd, pipelineSelectArgs.systolicPipelineSelectMode, hwInfo);
 
-    *pCmd = cmd;
+    *cmdBuffer = cmd;
 
     if (DebugManager.flags.CleanStateInPreamble.get()) {
         PipeControlArgs args = {};

shared/source/kernel/kernel_descriptor.h

@@ -183,7 +183,7 @@ struct KernelDescriptor {
         union {
             struct {
                 // 0
-                bool usesSpecialPipelineSelectMode : 1;
+                bool usesSystolicPipelineSelectMode : 1;
                 bool usesStringMapForPrintf : 1;
                 bool usesPrintf : 1;
                 bool usesFencesForReadWriteImages : 1;

shared/source/kernel/kernel_descriptor_from_patchtokens.cpp

@@ -59,7 +59,7 @@ void populateKernelDescriptor(KernelDescriptor &dst, const SPatchExecutionEnviro
     dst.kernelAttributes.flags.requiresSubgroupIndependentForwardProgress = (0 != execEnv.SubgroupIndependentForwardProgressRequired);
     dst.kernelAttributes.flags.useGlobalAtomics = (0 != execEnv.HasGlobalAtomics);
     dst.kernelAttributes.flags.usesFencesForReadWriteImages = (0 != execEnv.UsesFencesForReadWriteImages);
-    dst.kernelAttributes.flags.usesSpecialPipelineSelectMode = (0 != execEnv.HasDPAS);
+    dst.kernelAttributes.flags.usesSystolicPipelineSelectMode = (0 != execEnv.HasDPAS);
     dst.kernelAttributes.flags.usesStatelessWrites = (0 != execEnv.StatelessWritesCount);
     dst.kernelAttributes.flags.useStackCalls = (0 != execEnv.HasStackCalls);
     dst.kernelAttributes.flags.hasRTCalls = (0 != execEnv.HasRTCalls);

shared/source/os_interface/hw_info_config.h

@@ -108,7 +108,7 @@ class HwInfoConfig {
     virtual bool getUuid(Device *device, std::array<uint8_t, HwInfoConfig::uuidSize> &uuid) const = 0;
     virtual bool isFlushTaskAllowed() const = 0;
     virtual bool programAllStateComputeCommandFields() const = 0;
-    virtual bool isSpecialPipelineSelectModeChanged(const HardwareInfo &hwInfo) const = 0;
+    virtual bool isSystolicPipelineSelectModeChanged(const HardwareInfo &hwInfo) const = 0;
     virtual bool isSystolicModeConfigurable(const HardwareInfo &hwInfo) const = 0;
     virtual bool isGlobalFenceInCommandStreamRequired(const HardwareInfo &hwInfo) const = 0;
     virtual bool isGlobalFenceInDirectSubmissionRequired(const HardwareInfo &hwInfo) const = 0;
@@ -239,7 +239,7 @@ class HwInfoConfigHw : public HwInfoConfig {
     bool getUuid(Device *device, std::array<uint8_t, HwInfoConfig::uuidSize> &uuid) const override;
     bool isFlushTaskAllowed() const override;
     bool programAllStateComputeCommandFields() const override;
-    bool isSpecialPipelineSelectModeChanged(const HardwareInfo &hwInfo) const override;
+    bool isSystolicPipelineSelectModeChanged(const HardwareInfo &hwInfo) const override;
     bool isSystolicModeConfigurable(const HardwareInfo &hwInfo) const override;
     bool isComputeDispatchAllWalkerEnableInComputeWalkerRequired(const HardwareInfo &hwInfo) const override;
     bool isGlobalFenceInCommandStreamRequired(const HardwareInfo &hwInfo) const override;

shared/source/os_interface/hw_info_config.inl

@@ -357,7 +357,7 @@ bool HwInfoConfigHw<gfxProduct>::programAllStateComputeCommandFields() const {
 }
 
 template <PRODUCT_FAMILY gfxProduct>
-bool HwInfoConfigHw<gfxProduct>::isSpecialPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
+bool HwInfoConfigHw<gfxProduct>::isSystolicPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
     return false;
 }
 

shared/source/xe_hp_core/preamble_xe_hp_core.cpp

@@ -47,9 +47,9 @@ void PreambleHelper<Family>::appendProgramVFEState(const HardwareInfo &hwInfo, c
 }
 
 template <>
-bool PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+bool PreambleHelper<Family>::isSystolicPipelineSelectModeChanged(bool lastSystolicPipelineSelectMode, bool newSystolicPipelineSelectMode,
-                                                                const HardwareInfo &hwInfo) {
+                                                                 const HardwareInfo &hwInfo) {
-    return lastSpecialPipelineSelectMode != newSpecialPipelineSelectMode;
+    return lastSystolicPipelineSelectMode != newSystolicPipelineSelectMode;
 }
 
 template <>

shared/source/xe_hpc_core/preamble_xe_hpc_core.cpp

@@ -59,11 +59,11 @@ bool PreambleHelper<Family>::isSystolicModeConfigurable(const HardwareInfo &hwIn
 }
 
 template <>
-bool PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+bool PreambleHelper<Family>::isSystolicPipelineSelectModeChanged(bool lastSystolicPipelineSelectMode, bool newSystolicPipelineSelectMode,
-                                                                const HardwareInfo &hwInfo) {
+                                                                 const HardwareInfo &hwInfo) {
 
     const auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);
-    return (lastSpecialPipelineSelectMode != newSpecialPipelineSelectMode) && hwInfoConfig.isSpecialPipelineSelectModeChanged(hwInfo);
+    return (lastSystolicPipelineSelectMode != newSystolicPipelineSelectMode) && hwInfoConfig.isSystolicPipelineSelectModeChanged(hwInfo);
 }
 
 template struct PreambleHelper<Family>;

shared/source/xe_hpc_core/pvc/os_agnostic_hw_info_config_pvc.inl

@@ -88,7 +88,7 @@ bool HwInfoConfigHw<gfxProduct>::isDisableOverdispatchAvailable(const HardwareIn
 }
 
 template <>
-bool HwInfoConfigHw<gfxProduct>::isSpecialPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
+bool HwInfoConfigHw<gfxProduct>::isSystolicPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
     return PVC::isAtMostXtA0(hwInfo);
 }
 

shared/source/xe_hpg_core/preamble_xe_hpg_core.cpp

@@ -47,9 +47,9 @@ bool PreambleHelper<Family>::isSystolicModeConfigurable(const HardwareInfo &hwIn
 }
 
 template <>
-bool PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+bool PreambleHelper<Family>::isSystolicPipelineSelectModeChanged(bool lastSystolicPipelineSelectMode, bool newSystolicPipelineSelectMode,
-                                                                const HardwareInfo &hwInfo) {
+                                                                 const HardwareInfo &hwInfo) {
-    return lastSpecialPipelineSelectMode != newSpecialPipelineSelectMode;
+    return lastSystolicPipelineSelectMode != newSystolicPipelineSelectMode;
 }
 
 template struct PreambleHelper<Family>;

shared/test/common/libult/ult_command_stream_receiver.h

@@ -96,7 +96,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
     using BaseClass::CommandStreamReceiver::lastPreemptionMode;
     using BaseClass::CommandStreamReceiver::lastSentL3Config;
     using BaseClass::CommandStreamReceiver::lastSentUseGlobalAtomics;
-    using BaseClass::CommandStreamReceiver::lastSpecialPipelineSelectMode;
+    using BaseClass::CommandStreamReceiver::lastSystolicPipelineSelectMode;
     using BaseClass::CommandStreamReceiver::lastVmeSubslicesConfig;
     using BaseClass::CommandStreamReceiver::latestFlushedTaskCount;
     using BaseClass::CommandStreamReceiver::latestSentStatelessMocsConfig;

shared/test/common/mocks/mock_hw_info_config.cpp

@@ -306,7 +306,7 @@ bool HwInfoConfigHw<IGFX_UNKNOWN>::programAllStateComputeCommandFields() const {
 }
 
 template <>
-bool HwInfoConfigHw<IGFX_UNKNOWN>::isSpecialPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
+bool HwInfoConfigHw<IGFX_UNKNOWN>::isSystolicPipelineSelectModeChanged(const HardwareInfo &hwInfo) const {
     return false;
 }
 

shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

@@ -2615,7 +2615,7 @@ TEST(PopulateKernelDescriptor, GivenMinimalExecutionEnvThenPopulateKernelDescrip
     EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.useGlobalAtomics, Defaults::hasGlobalAtomics);
     EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.useStackCalls, Defaults::hasStackCalls);
     EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages, Defaults::hasFenceForImageAccess);
-    EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode, Defaults::hasDpas);
+    EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode, Defaults::hasDpas);
     EXPECT_EQ(kernelDescriptor.kernelAttributes.flags.usesStatelessWrites, (false == Defaults::hasNoStatelessWrite));
     EXPECT_EQ(kernelDescriptor.kernelAttributes.barrierCount, static_cast<uint8_t>(Defaults::barrierCount));
     EXPECT_EQ(kernelDescriptor.kernelAttributes.binaryFormat, DeviceBinaryFormat::Zebin);

shared/test/unit_test/encoders/test_encode_dispatch_kernel_xehp_and_later.cpp

@@ -1283,7 +1283,7 @@ HWTEST2_F(CommandEncodeStatesTest,
     bool dpasModeRequired = true;
     cmdContainer->lastPipelineSelectModeRequired = false;
 
-    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = dpasModeRequired;
+    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = dpasModeRequired;
 
     bool requiresUncachedMocs = false;
     EncodeDispatchKernelArgs dispatchArgs = createDefaultDispatchKernelArgs(pDevice, dispatchInterface.get(), dims, requiresUncachedMocs);
@@ -1313,7 +1313,7 @@ HWTEST2_F(CommandEncodeStatesTest,
     bool dpasModeRequired = true;
     DebugManager.flags.OverrideSystolicPipelineSelect.set(!dpasModeRequired);
     cmdContainer->lastPipelineSelectModeRequired = false;
-    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = dpasModeRequired;
+    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = dpasModeRequired;
 
     bool requiresUncachedMocs = false;
     EncodeDispatchKernelArgs dispatchArgs = createDefaultDispatchKernelArgs(pDevice, dispatchInterface.get(), dims, requiresUncachedMocs);
@@ -1340,7 +1340,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTest,
 
     bool dpasModeRequired = true;
     cmdContainer->lastPipelineSelectModeRequired = dpasModeRequired;
-    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = dpasModeRequired;
+    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = dpasModeRequired;
 
     bool requiresUncachedMocs = false;
     EncodeDispatchKernelArgs dispatchArgs = createDefaultDispatchKernelArgs(pDevice, dispatchInterface.get(), dims, requiresUncachedMocs);

shared/test/unit_test/encoders/test_encode_grf_mode_xe_hp_and_later.cpp

@@ -107,7 +107,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenLargeGrfModeDisabledThenExpectedCommands
 
 HWTEST2_F(CommandEncodeStatesTest, givenCommandContainerWithKernelDpasThenSystolicModeEnabled, IsWithinXeGfxFamily) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
     EncodeComputeMode<FamilyType>::adjustPipelineSelect(*cmdContainer.get(), descriptor);
     GenCmdList commands;
     CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -121,7 +121,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenCommandContainerWithKernelDpasThenSystol
 
 HWTEST2_F(CommandEncodeStatesTest, givenCommandContainerWithNoKernelDpasThenSystolicModeIsNotEnabled, IsWithinXeGfxFamily) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = false;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = false;
     EncodeComputeMode<FamilyType>::adjustPipelineSelect(*cmdContainer.get(), descriptor);
     GenCmdList commands;
     CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -138,7 +138,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenDebugModeToOverrideSystolicModeToTrueWhe
     DebugManager.flags.OverrideSystolicPipelineSelect.set(1);
 
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = false;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = false;
     EncodeComputeMode<FamilyType>::adjustPipelineSelect(*cmdContainer.get(), descriptor);
     GenCmdList commands;
     CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -155,7 +155,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenDebugModeToOverrideSystolicModeToFalseWh
     DebugManager.flags.OverrideSystolicPipelineSelect.set(0);
 
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
     EncodeComputeMode<FamilyType>::adjustPipelineSelect(*cmdContainer.get(), descriptor);
     GenCmdList commands;
     CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -175,7 +175,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenLargeGrfModeEnabledThenExpectedCommandsA
 
     auto usedSpaceBefore = cmdContainer->getCommandStream()->getUsed();
 
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
     NEO::EncodeComputeMode<GfxFamily>::adjustPipelineSelect(*cmdContainer, descriptor);
     StreamProperties streamProperties{};
     streamProperties.stateComputeMode.largeGrfMode.set(1);
@@ -213,7 +213,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenLargeGrfModeEnabledAndDisabledThenExpect
 
     auto usedSpaceBefore = cmdContainer->getCommandStream()->getUsed();
 
-    descriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    descriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
     NEO::EncodeComputeMode<GfxFamily>::adjustPipelineSelect(*cmdContainer, descriptor);
     StreamProperties streamProperties{};
     streamProperties.stateComputeMode.largeGrfMode.set(1);

shared/test/unit_test/gen12lp/adlp/preamble_helper_tests_adlp.cpp

@@ -18,7 +18,7 @@ using namespace NEO;
 
 using PreambleHelperTestsAdlp = ::testing::Test;
 
-ADLPTEST_F(PreambleHelperTestsAdlp, givenSpecialPipelineSelectModeDisabledWhenProgrammingPipelineSelectThenDisableSystolicMode) {
+ADLPTEST_F(PreambleHelperTestsAdlp, givenSystolicPipelineSelectModeDisabledWhenProgrammingPipelineSelectThenDisableSystolicMode) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
     constexpr static auto bufferSize = sizeof(PIPELINE_SELECT);
 
@@ -26,7 +26,7 @@ ADLPTEST_F(PreambleHelperTestsAdlp, givenSpecialPipelineSelectModeDisabledWhenPr
     LinearStream stream{streamBuffer, sizeof(bufferSize)};
 
     DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
-    flags.pipelineSelectArgs.specialPipelineSelectMode = false;
+    flags.pipelineSelectArgs.systolicPipelineSelectMode = false;
 
     auto *pCmd = static_cast<PIPELINE_SELECT *>(stream.getSpace(0));
     PreambleHelper<FamilyType>::programPipelineSelect(&stream, flags.pipelineSelectArgs, ADLP::hwInfo);
@@ -37,7 +37,7 @@ ADLPTEST_F(PreambleHelperTestsAdlp, givenSpecialPipelineSelectModeDisabledWhenPr
     EXPECT_EQ(PIPELINE_SELECT::PIPELINE_SELECTION_GPGPU, pCmd->getPipelineSelection());
 }
 
-ADLPTEST_F(PreambleHelperTestsAdlp, givenSpecialPipelineSelectModeEnabledWhenProgrammingPipelineSelectThenEnableSystolicMode) {
+ADLPTEST_F(PreambleHelperTestsAdlp, givenSystolicPipelineSelectModeEnabledWhenProgrammingPipelineSelectThenEnableSystolicMode) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
     constexpr static auto bufferSize = sizeof(PIPELINE_SELECT);
 
@@ -45,7 +45,7 @@ ADLPTEST_F(PreambleHelperTestsAdlp, givenSpecialPipelineSelectModeEnabledWhenPro
     LinearStream stream{streamBuffer, sizeof(bufferSize)};
 
     DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
-    flags.pipelineSelectArgs.specialPipelineSelectMode = true;
+    flags.pipelineSelectArgs.systolicPipelineSelectMode = true;
 
     auto *pCmd = static_cast<PIPELINE_SELECT *>(stream.getSpace(0));
     PreambleHelper<FamilyType>::programPipelineSelect(&stream, flags.pipelineSelectArgs, ADLP::hwInfo);

shared/test/unit_test/helpers/test_hw_info_config.cpp

@@ -35,9 +35,9 @@ HWTEST_F(HwInfoConfigTest, givenHwInfoConfigWhenIsGlobalFenceInCommandStreamRequ
     EXPECT_FALSE(hwInfoConfig.isGlobalFenceInCommandStreamRequired(*defaultHwInfo));
 }
 
-HWTEST_F(HwInfoConfigTest, givenHwInfoConfigWhenIsSpecialPipelineSelectModeChangedThenFalseIsReturned) {
+HWTEST_F(HwInfoConfigTest, givenHwInfoConfigWhenIsSystolicPipelineSelectModeChangedThenFalseIsReturned) {
     const auto &hwInfoConfig = *HwInfoConfig::get(defaultHwInfo->platform.eProductFamily);
-    EXPECT_FALSE(hwInfoConfig.isSpecialPipelineSelectModeChanged(*defaultHwInfo));
+    EXPECT_FALSE(hwInfoConfig.isSystolicPipelineSelectModeChanged(*defaultHwInfo));
 }
 
 HWTEST_F(HwInfoConfigTest, givenHwInfoConfigWhenIsSystolicModeConfigurabledThenFalseIsReturned) {

shared/test/unit_test/preamble/preamble_tests.cpp

@@ -264,7 +264,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, PreambleTest, WhenAppendProgramPipelineSelectThenNot
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
     PIPELINE_SELECT cmd = FamilyType::cmdInitPipelineSelect;
     cmd.setMaskBits(pipelineSelectEnablePipelineSelectMaskBits);
-    PreambleHelper<FamilyType>::appendProgramPipelineSelect(&cmd, true, *defaultHwInfo);
+    PreambleHelper<FamilyType>::appendProgramPipelineSelect(cmd, true, *defaultHwInfo);
     EXPECT_EQ(pipelineSelectEnablePipelineSelectMaskBits, cmd.getMaskBits());
 }
 

shared/test/unit_test/xe_hp_core/xe_hp_sdv/test_preamble_xe_hp_sdv.cpp

@@ -120,9 +120,9 @@ using XeHPPipelineSelect = ::testing::Test;
 XEHPTEST_F(XeHPPipelineSelect, WhenAppendProgramPipelineSelectThenCorrectValuesSet) {
     using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
     PIPELINE_SELECT cmd = FamilyType::cmdInitPipelineSelect;
-    PreambleHelper<FamilyType>::appendProgramPipelineSelect(&cmd, true, *defaultHwInfo);
+    PreambleHelper<FamilyType>::appendProgramPipelineSelect(cmd, true, *defaultHwInfo);
     EXPECT_TRUE(cmd.getSystolicModeEnable());
-    PreambleHelper<FamilyType>::appendProgramPipelineSelect(&cmd, false, *defaultHwInfo);
+    PreambleHelper<FamilyType>::appendProgramPipelineSelect(cmd, false, *defaultHwInfo);
     EXPECT_FALSE(cmd.getSystolicModeEnable());
     EXPECT_EQ(pipelineSelectSystolicModeEnableMaskBits, cmd.getMaskBits());
 }

shared/test/unit_test/xe_hpc_core/excludes_xe_hpc_core.cpp

@@ -29,7 +29,7 @@ HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsAdjustProgrammab
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsComputeDispatchAllWalkerEnableInCfeStateRequiredThenFalseIsReturned, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsComputeDispatchAllWalkerEnableInComputeWalkerRequiredThenFalseIsReturned, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsGlobalFenceInCommandStreamRequiredThenFalseIsReturned, IGFX_XE_HPC_CORE);
-HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsSpecialPipelineSelectModeChangedThenFalseIsReturned, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsSystolicPipelineSelectModeChangedThenFalseIsReturned, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenIsSystolicModeConfigurabledThenFalseIsReturned, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenGetThreadEuRatioForScratchThen8IsReturned, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenVariousValuesWhenConvertingHwRevIdAndSteppingThenConversionIsCorrect, IGFX_XE_HPC_CORE);

shared/test/unit_test/xe_hpc_core/pvc/test_encode_dispatch_kernel_pvc.cpp

@@ -60,7 +60,7 @@ PVCTEST_F(EncodeKernelPvcTest, givenRevisionBAndAboveWhenSpecialModeRequiredThen
 
     uint32_t dims[] = {1, 1, 1};
     std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
-    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
 
     struct {
         unsigned short revId;
@@ -93,7 +93,7 @@ PVCTEST_F(EncodeKernelPvcTest, givenRevisionBAndAboveWhenSpecialModeRequiredAndA
     auto hwInfo = pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
 
     std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
-    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSpecialPipelineSelectMode = true;
+    dispatchInterface->kernelDescriptor.kernelAttributes.flags.usesSystolicPipelineSelectMode = true;
 
     struct {
         unsigned short revId;

shared/test/unit_test/xe_hpc_core/pvc/test_preamble_pvc.cpp

@@ -52,7 +52,7 @@ PVCTEST_F(PreamblePipelineSelectState, givenRevisionBAndAboveWhenCallingProgramP
     auto hwInfo = pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
 
     PipelineSelectArgs pipelineArgs;
-    pipelineArgs.specialPipelineSelectMode = true;
+    pipelineArgs.systolicPipelineSelectMode = true;
 
     struct {
         unsigned short revId;