Add method to set systolic mode

Resolves: NEO-6040

Signed-off-by: Szymon Morek [email protected]

Author: smorek-intel

opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp

@@ -504,3 +504,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, RenderSurfaceStateXeHPAndLaterTests, givenSpecificP
 
     EXPECT_EQ(FamilyType::RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, rssCmd.getCoherencyType());
 }
+
+HWCMDTEST_F(IGFX_XE_HP_CORE, PreambleFixture, whenCallingIsSpecialPipelineSelectModeChangedThenReturnCorrectValue) {
+    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
+    bool oldPipelineSelectSpecialMode = true;
+    bool newPipelineSelectSpecialMode = false;
+
+    auto result = PreambleHelper<FamilyType>::isSpecialPipelineSelectModeChanged(oldPipelineSelectSpecialMode, newPipelineSelectSpecialMode, *defaultHwInfo);
+    EXPECT_TRUE(result);
+}

opencl/test/unit_test/libult/ult_command_stream_receiver.h

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

shared/source/command_container/command_encoder_xehp_and_later.inl

@@ -71,7 +71,7 @@ void EncodeDispatchKernel<Family>::encode(CommandContainer &container,
 
     if (kernelDescriptor.extendedInfo) {
         bool specialModeRequired = kernelDescriptor.extendedInfo->specialPipelineSelectModeRequired();
-        if (container.lastPipelineSelectModeRequired != specialModeRequired) {
+        if (PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(container.lastPipelineSelectModeRequired, specialModeRequired, hwInfo)) {
             container.lastPipelineSelectModeRequired = specialModeRequired;
             EncodeComputeMode<Family>::adjustPipelineSelect(container, kernelDescriptor);
         }
@@ -565,18 +565,10 @@ 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.extendedInfo && kernelDescriptor.extendedInfo->specialPipelineSelectModeRequired();
 
-    if (kernelDescriptor.extendedInfo && kernelDescriptor.extendedInfo->specialPipelineSelectModeRequired()) {
-        pipelineSelectCmd.setSystolicModeEnable(true);
-    } else {
-        pipelineSelectCmd.setSystolicModeEnable(false);
-    }
-
-    if (DebugManager.flags.OverrideSystolicPipelineSelect.get() != -1) {
-        pipelineSelectCmd.setSystolicModeEnable(DebugManager.flags.OverrideSystolicPipelineSelect.get());
-    }
+    PreambleHelper<Family>::appendProgramPipelineSelect(&pipelineSelectCmd, isSpecialModeSelected, container.getDevice()->getHardwareInfo());
 
-    pipelineSelectCmd.setMaskBits(pipelineSelectSystolicModeEnableMaskBits);
     pipelineSelectCmd.setPipelineSelection(PIPELINE_SELECT::PIPELINE_SELECTION_GPGPU);
 
     auto buffer = container.getCommandStream()->getSpace(sizeof(pipelineSelectCmd));

shared/source/command_stream/command_stream_receiver_hw_base.inl

@@ -266,12 +266,15 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
     }
 
     auto newL3Config = PreambleHelper<GfxFamily>::getL3Config(peekHwInfo(), dispatchFlags.useSLM);
+    auto isSpecialPipelineSelectModeChanged = PreambleHelper<GfxFamily>::isSpecialPipelineSelectModeChanged(lastSpecialPipelineSelectMode,
+                                                                                                            dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode,
+                                                                                                            peekHwInfo());
 
     csrSizeRequestFlags.l3ConfigChanged = this->lastSentL3Config != newL3Config;
     csrSizeRequestFlags.coherencyRequestChanged = this->lastSentCoherencyRequest != static_cast<int8_t>(dispatchFlags.requiresCoherency);
     csrSizeRequestFlags.preemptionRequestChanged = this->lastPreemptionMode != dispatchFlags.preemptionMode;
     csrSizeRequestFlags.mediaSamplerConfigChanged = this->lastMediaSamplerConfig != static_cast<int8_t>(dispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
-    csrSizeRequestFlags.specialPipelineSelectModeChanged = this->lastSpecialPipelineSelectMode != dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode;
+    csrSizeRequestFlags.specialPipelineSelectModeChanged = isSpecialPipelineSelectModeChanged;
 
     if (dispatchFlags.numGrfRequired == GrfConfig::NotApplicable) {
         dispatchFlags.numGrfRequired = lastSentNumGrfRequired;

shared/source/helpers/preamble.h

@@ -37,6 +37,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 programThreadArbitration(LinearStream *pCommandStream, uint32_t requiredThreadArbitrationPolicy);
     static void programPreemption(LinearStream *pCommandStream, Device &device, GraphicsAllocation *preemptionCsr);
     static void addPipeControlBeforeVfeCmd(LinearStream *pCommandStream, const HardwareInfo *hwInfo, EngineGroupType engineGroupType);
@@ -58,6 +59,9 @@ struct PreambleHelper {
     static void programSemaphoreDelay(LinearStream *pCommandStream);
     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,
+                                                   const HardwareInfo &hwInfo);
     static size_t getAdditionalCommandsSize(const Device &device);
     static size_t getThreadArbitrationCommandsSize();
     static std::vector<uint32_t> getSupportedThreadArbitrationPolicies();

shared/source/helpers/preamble_bdw_and_later.inl

@@ -75,4 +75,17 @@ size_t PreambleHelper<GfxFamily>::getVFECommandsSize() {
     return sizeof(MEDIA_VFE_STATE) + sizeof(PIPE_CONTROL);
 }
 
+template <typename GfxFamily>
+void PreambleHelper<GfxFamily>::appendProgramPipelineSelect(void *cmd, bool isSpecialModeSelected, const HardwareInfo &hwInfo) {}
+
+template <typename GfxFamily>
+bool PreambleHelper<GfxFamily>::isSystolicModeConfigurable(const HardwareInfo &hwInfo) {
+    return false;
+}
+
+template <typename GfxFamily>
+bool PreambleHelper<GfxFamily>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+                                                                   const HardwareInfo &hwInfo) {
+    return false;
+}
 } // namespace NEO

shared/source/helpers/preamble_xehp_and_later.inl

@@ -22,6 +22,28 @@
 
 namespace NEO {
 
+template <>
+bool PreambleHelper<Family>::isSystolicModeConfigurable(const HardwareInfo &hwInfo);
+
+template <>
+void PreambleHelper<Family>::appendProgramPipelineSelect(void *cmd, bool isSpecialModeSelected, const HardwareInfo &hwInfo) {
+    using PIPELINE_SELECT = typename Family::PIPELINE_SELECT;
+    auto command = static_cast<PIPELINE_SELECT *>(cmd);
+    auto mask = command->getMaskBits();
+
+    if (PreambleHelper<Family>::isSystolicModeConfigurable(hwInfo)) {
+        command->setSystolicModeEnable(isSpecialModeSelected);
+        mask |= pipelineSelectSystolicModeEnableMaskBits;
+    }
+
+    if (DebugManager.flags.OverrideSystolicPipelineSelect.get() != -1) {
+        command->setSystolicModeEnable(DebugManager.flags.OverrideSystolicPipelineSelect.get());
+        mask |= pipelineSelectSystolicModeEnableMaskBits;
+    }
+
+    command->setMaskBits(mask);
+}
+
 template <>
 void PreambleHelper<Family>::programPipelineSelect(LinearStream *pCommandStream,
                                                    const PipelineSelectArgs &pipelineSelectArgs,
@@ -45,17 +67,13 @@ void PreambleHelper<Family>::programPipelineSelect(LinearStream *pCommandStream,
     auto pCmd = pCommandStream->getSpaceForCmd<PIPELINE_SELECT>();
 
     auto mask = pipelineSelectEnablePipelineSelectMaskBits |
-                pipelineSelectMediaSamplerDopClockGateMaskBits |
-                pipelineSelectSystolicModeEnableMaskBits;
+                pipelineSelectMediaSamplerDopClockGateMaskBits;
 
     cmd.setMaskBits(mask);
     cmd.setPipelineSelection(PIPELINE_SELECT::PIPELINE_SELECTION_GPGPU);
     cmd.setMediaSamplerDopClockGateEnable(!pipelineSelectArgs.mediaSamplerRequired);
-    cmd.setSystolicModeEnable(pipelineSelectArgs.specialPipelineSelectMode);
 
-    if (DebugManager.flags.OverrideSystolicPipelineSelect.get() != -1) {
-        cmd.setSystolicModeEnable(DebugManager.flags.OverrideSystolicPipelineSelect.get());
-    }
+    appendProgramPipelineSelect(&cmd, pipelineSelectArgs.specialPipelineSelectMode, hwInfo);
 
     *pCmd = cmd;
 

shared/source/xe_hp_core/preamble_xe_hp_core.cpp

@@ -36,6 +36,17 @@ void PreambleHelper<Family>::appendProgramVFEState(const HardwareInfo &hwInfo, c
     }
 }
 
+template <>
+bool PreambleHelper<Family>::isSpecialPipelineSelectModeChanged(bool lastSpecialPipelineSelectMode, bool newSpecialPipelineSelectMode,
+                                                                const HardwareInfo &hwInfo) {
+    return lastSpecialPipelineSelectMode != newSpecialPipelineSelectMode;
+}
+
+template <>
+bool PreambleHelper<Family>::isSystolicModeConfigurable(const HardwareInfo &hwInfo) {
+    return true;
+}
+
 template struct PreambleHelper<Family>;
 
 } // namespace NEO

shared/test/common/xe_hp_core/xehp/test_preamble_xehp.cpp

@@ -114,3 +114,15 @@ XEHPTEST_F(XeHPPreambleVfeState, WhenProgramVFEStateIsCalledThenCorrectCfeStateA
     EXPECT_EQ(1u, cfeCmd.getNumberOfWalkers());
     EXPECT_EQ(expectedAddress, cfeCmd.getScratchSpaceBuffer());
 }
+
+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);
+    EXPECT_TRUE(cmd.getSystolicModeEnable());
+    PreambleHelper<FamilyType>::appendProgramPipelineSelect(&cmd, false, *defaultHwInfo);
+    EXPECT_FALSE(cmd.getSystolicModeEnable());
+    EXPECT_EQ(pipelineSelectSystolicModeEnableMaskBits, cmd.getMaskBits());
+}

shared/test/unit_test/preamble/preamble_tests.cpp

@@ -259,6 +259,19 @@ HWCMDTEST_F(IGFX_GEN8_CORE, PreambleTest, WhenGetScratchSpaceAddressOffsetForVfe
               offset + reinterpret_cast<uintptr_t>(preambleStream.getCpuBase()));
 }
 
+HWCMDTEST_F(IGFX_GEN8_CORE, PreambleTest, WhenIsSystolicModeConfigurableThenReturnFalse) {
+    auto result = PreambleHelper<FamilyType>::isSystolicModeConfigurable(*defaultHwInfo);
+    EXPECT_FALSE(result);
+}
+
+HWCMDTEST_F(IGFX_GEN8_CORE, PreambleTest, WhenAppendProgramPipelineSelectThenNothingChanged) {
+    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
+    PIPELINE_SELECT cmd = FamilyType::cmdInitPipelineSelect;
+    cmd.setMaskBits(pipelineSelectEnablePipelineSelectMaskBits);
+    PreambleHelper<FamilyType>::appendProgramPipelineSelect(&cmd, true, *defaultHwInfo);
+    EXPECT_EQ(pipelineSelectEnablePipelineSelectMaskBits, cmd.getMaskBits());
+}
+
 HWTEST_F(PreambleTest, givenSetForceSemaphoreDelayBetweenWaitsWhenProgramSemaphoreDelayThenSemaWaitPollRegisterIsProgrammed) {
     using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
     DebugManagerStateRestore debugManagerStateRestore;