Add debug keys to scratch register write after walker

Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

opencl/source/command_queue/gpgpu_walker_base.inl

@@ -216,6 +216,9 @@ size_t EnqueueOperation<GfxFamily>::getTotalSizeRequiredCS(uint32_t eventType, c
         expectedSizeCS += sizeof(typename GfxFamily::MI_SEMAPHORE_WAIT) * 2;
     }
 
+    if (DebugManager.flags.GpuScratchRegWriteAfterWalker.get() != -1) {
+        expectedSizeCS += sizeof(typename GfxFamily::MI_LOAD_REGISTER_IMM);
+    }
     return expectedSizeCS;
 }
 

opencl/source/command_queue/hardware_interface_base.inl

@@ -160,6 +160,12 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
         HardwareCommandsHelper<GfxFamily>::programCacheFlushAfterWalkerCommand(commandStream, commandQueue, mainKernel, postSyncAddress);
     }
 
+    if (PauseOnGpuProperties::GpuScratchRegWriteAllowed(DebugManager.flags.GpuScratchRegWriteAfterWalker.get(), commandQueue.getGpgpuCommandStreamReceiver().peekTaskCount())) {
+        uint32_t registerOffset = DebugManager.flags.GpuScratchRegWriteRegisterOffset.get();
+        uint32_t registerData = DebugManager.flags.GpuScratchRegWriteRegisterData.get();
+        LriHelper<GfxFamily>::program(commandStream, registerOffset, registerData, EncodeSetMMIO<GfxFamily>::isRemapApplicable(registerOffset));
+    }
+
     if (PauseOnGpuProperties::pauseModeAllowed(DebugManager.flags.PauseOnEnqueue.get(), commandQueue.getGpgpuCommandStreamReceiver().peekTaskCount(), PauseOnGpuProperties::PauseMode::AfterWorkload)) {
         dispatchDebugPauseCommands(commandStream, commandQueue, DebugPauseState::waitingForUserEndConfirmation, DebugPauseState::hasUserEndConfirmation);
     }
@@ -311,5 +317,4 @@ inline void HardwareInterface<GfxFamily>::dispatchDebugPauseCommands(
         }
     }
 }
-
 } // namespace NEO

opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp

@@ -1418,6 +1418,21 @@ struct PauseOnGpuTests : public EnqueueKernelTest {
         return false;
     }
 
+    template <typename FamilyType>
+    bool verifyLoadRegImm(const GenCmdList::iterator &iterator) {
+        using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
+        uint32_t expectedRegisterOffset = DebugManager.flags.GpuScratchRegWriteRegisterOffset.get();
+        uint32_t expectedRegisterData = DebugManager.flags.GpuScratchRegWriteRegisterData.get();
+        auto loadRegImm = genCmdCast<MI_LOAD_REGISTER_IMM *>(*iterator);
+
+        if ((expectedRegisterOffset == loadRegImm->getRegisterOffset()) &&
+            (expectedRegisterData == loadRegImm->getDataDword())) {
+            return true;
+        }
+
+        return false;
+    }
+
     template <typename MI_SEMAPHORE_WAIT>
     void findSemaphores(GenCmdList &cmdList) {
         auto semaphore = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
@@ -1452,6 +1467,20 @@ struct PauseOnGpuTests : public EnqueueKernelTest {
         }
     }
 
+    template <typename FamilyType>
+    void findLoadRegImms(GenCmdList &cmdList) {
+        using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
+        auto loadRegImm = find<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
+
+        while (loadRegImm != cmdList.end()) {
+            if (verifyLoadRegImm<FamilyType>(loadRegImm)) {
+                loadRegImmsFound++;
+            }
+
+            loadRegImm = find<MI_LOAD_REGISTER_IMM *>(++loadRegImm, cmdList.end());
+        }
+    }
+
     DebugManagerStateRestore restore;
 
     const size_t off[3] = {0, 0, 0};
@@ -1463,6 +1492,7 @@ struct PauseOnGpuTests : public EnqueueKernelTest {
     uint32_t semaphoreAfterWalkerFound = 0;
     uint32_t pipeControlBeforeWalkerFound = 0;
     uint32_t pipeControlAfterWalkerFound = 0;
+    uint32_t loadRegImmsFound = 0;
 };
 
 HWTEST_F(PauseOnGpuTests, givenPauseOnEnqueueFlagSetWhenDispatchWalkersThenInsertPauseCommandsAroundSpecifiedEnqueue) {
@@ -1612,3 +1642,64 @@ HWTEST_F(PauseOnGpuTests, givenPauseOnEnqueueFlagSetWhenDispatchWalkersThenDontI
 
     pCmdQ->setIsSpecialCommandQueue(false);
 }
+
+HWTEST_F(PauseOnGpuTests, givenGpuScratchWriteEnabledWhenDispatchWalkersThenInsertLoadRegisterImmCommandAroundSpecifiedEnqueue) {
+    DebugManager.flags.GpuScratchRegWriteAfterWalker.set(1);
+    DebugManager.flags.GpuScratchRegWriteRegisterData.set(0x1234);
+    DebugManager.flags.GpuScratchRegWriteRegisterOffset.set(0x5678);
+
+    MockKernelWithInternals mockKernel(*pClDevice);
+
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+
+    HardwareParse hwParser;
+
+    hwParser.parseCommands<FamilyType>(*pCmdQ);
+
+    findLoadRegImms<FamilyType>(hwParser.cmdList);
+
+    EXPECT_EQ(0u, loadRegImmsFound);
+
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+    hwParser.parseCommands<FamilyType>(*pCmdQ);
+
+    findLoadRegImms<FamilyType>(hwParser.cmdList);
+
+    EXPECT_EQ(1u, loadRegImmsFound);
+}
+
+HWTEST_F(PauseOnGpuTests, givenGpuScratchWriteEnabledWhenDispatcMultiplehWalkersThenInsertLoadRegisterImmCommandOnlyOnce) {
+    DebugManager.flags.GpuScratchRegWriteAfterWalker.set(1);
+    DebugManager.flags.GpuScratchRegWriteRegisterData.set(0x1234);
+    DebugManager.flags.GpuScratchRegWriteRegisterOffset.set(0x5678);
+
+    MockKernelWithInternals mockKernel(*pClDevice);
+
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+    pCmdQ->enqueueKernel(mockKernel.mockKernel, 1, off, gws, nullptr, 0, nullptr, nullptr);
+
+    HardwareParse hwParser;
+
+    hwParser.parseCommands<FamilyType>(*pCmdQ);
+
+    findLoadRegImms<FamilyType>(hwParser.cmdList);
+
+    EXPECT_EQ(1u, loadRegImmsFound);
+}
+
+HWTEST_F(PauseOnGpuTests, givenGpuScratchWriteEnabledWhenEstimatingCommandStreamSizeThenMiLoadRegisterImmCommandSizeIsIncluded) {
+    MockKernelWithInternals mockKernel(*pClDevice);
+    DispatchInfo dispatchInfo;
+    MultiDispatchInfo multiDispatchInfo(mockKernel.mockKernel);
+    dispatchInfo.setKernel(mockKernel.mockKernel);
+    multiDispatchInfo.push(dispatchInfo);
+
+    auto baseCommandStreamSize = EnqueueOperation<FamilyType>::getTotalSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, {}, false, false, false, *pCmdQ, multiDispatchInfo);
+    DebugManager.flags.GpuScratchRegWriteAfterWalker.set(1);
+
+    auto extendedCommandStreamSize = EnqueueOperation<FamilyType>::getTotalSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, {}, false, false, false, *pCmdQ, multiDispatchInfo);
+
+    EXPECT_EQ(baseCommandStreamSize + sizeof(typename FamilyType::MI_LOAD_REGISTER_IMM), extendedCommandStreamSize);
+}

opencl/test/unit_test/test_files/igdrcl.config

@@ -216,3 +216,6 @@ OverrideProfilingTimerResolution = -1
 PreferCopyEngineForCopyBufferToBuffer = -1
 EnableStaticPartitioning = -1
 DisableDeepBind = 0
+GpuScratchRegWriteAfterWalker = -1
+GpuScratchRegWriteRegisterData = 0
+GpuScratchRegWriteRegisterOffset = 0

shared/source/debug_settings/debug_variables_base.inl

@@ -86,6 +86,9 @@ DECLARE_DEBUG_VARIABLE(int32_t, EnableMockSourceLevelDebugger, 0, "Switches driv
 DECLARE_DEBUG_VARIABLE(int32_t, ForceBtpPrefetchMode, -1, "-1: default, 0: disable, 1: enable, Enables Btp prefetching")
 DECLARE_DEBUG_VARIABLE(int32_t, EnableHostPointerImport, -1, "-1: default - disabled, 0: disabled, 1: enabled, Experimental implementation to import Host Pointer into L0")
 DECLARE_DEBUG_VARIABLE(int32_t, OverrideProfilingTimerResolution, -1, "-1: default - disabled, 0<=: Override deviceInfo.profilingTimerResolution")
+DECLARE_DEBUG_VARIABLE(int32_t, GpuScratchRegWriteAfterWalker, -1, "-1: disabled, x: add GPU scratch register write after x walker")
+DECLARE_DEBUG_VARIABLE(int32_t, GpuScratchRegWriteRegisterOffset, 0, "register offset for GPU scratch register write after walker")
+DECLARE_DEBUG_VARIABLE(int32_t, GpuScratchRegWriteRegisterData, 0, "register data for GPU scratch register write after walker")
 
 /*LOGGING FLAGS*/
 DECLARE_DEBUG_VARIABLE(int32_t, PrintDriverDiagnostics, -1, "prints driver diagnostics messages to standard output, value corresponds to hint level")

shared/source/helpers/pause_on_gpu_properties.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2020 Intel Corporation
+ * Copyright (C) 2017-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -46,5 +46,14 @@ inline bool pauseModeAllowed(int32_t debugFlagValue, uint32_t taskCount, PauseMo
 
     return (debugFlagValue == static_cast<int32_t>(taskCount));
 }
+
+inline bool GpuScratchRegWriteAllowed(int32_t debugFlagValue, uint32_t taskCount) {
+    if (!featureEnabled(debugFlagValue)) {
+        // feature disabled
+        return false;
+    }
+
+    return (debugFlagValue == static_cast<int32_t>(taskCount));
+}
 } // namespace PauseOnGpuProperties
 } // namespace NEO