Add missing unit test

Missing ult for isDebuggerActive
Move inline function to .inl file

Related-To: NEO-7003

Signed-off-by: Dominik Dabek <dominik.dabek@intel.com>

Author: ddabek-i

level_zero/core/source/kernel/kernel_imp.cpp

@@ -44,6 +44,7 @@
 #include <memory>
 
 namespace L0 {
+#include "level_zero/core/source/kernel/patch_with_implicit_surface.inl"
 
 KernelImmutableData::KernelImmutableData(L0::Device *l0device) : device(l0device) {}
 
@@ -57,39 +58,6 @@ KernelImmutableData::~KernelImmutableData() {
     dynamicStateHeapTemplate.reset();
 }
 
-inline void patchWithImplicitSurface(ArrayRef<uint8_t> crossThreadData, ArrayRef<uint8_t> surfaceStateHeap,
-                                     uintptr_t ptrToPatchInCrossThreadData, NEO::GraphicsAllocation &allocation,
-                                     const NEO::ArgDescPointer &ptr, const NEO::Device &device, bool useGlobalAtomics,
-                                     bool implicitScaling) {
-    if (false == crossThreadData.empty()) {
-        NEO::patchPointer(crossThreadData, ptr, ptrToPatchInCrossThreadData);
-    }
-
-    if ((false == surfaceStateHeap.empty()) && (NEO::isValidOffset(ptr.bindful))) {
-        auto surfaceState = surfaceStateHeap.begin() + ptr.bindful;
-        auto addressToPatch = allocation.getGpuAddress();
-        size_t sizeToPatch = allocation.getUnderlyingBufferSize();
-
-        auto &hwInfo = device.getHardwareInfo();
-        auto &hwHelper = NEO::HwHelper::get(hwInfo.platform.eRenderCoreFamily);
-        auto isDebuggerActive = device.isDebuggerActive() || device.getDebugger() != nullptr;
-        NEO::EncodeSurfaceStateArgs args;
-        args.outMemory = surfaceState;
-        args.size = sizeToPatch;
-        args.graphicsAddress = addressToPatch;
-        args.gmmHelper = device.getGmmHelper();
-        args.allocation = &allocation;
-        args.useGlobalAtomics = useGlobalAtomics;
-        args.numAvailableDevices = device.getNumGenericSubDevices();
-        args.areMultipleSubDevicesInContext = args.numAvailableDevices > 1;
-        args.mocs = hwHelper.getMocsIndex(*args.gmmHelper, true, false) << 1;
-        args.implicitScaling = implicitScaling;
-        args.isDebuggerActive = isDebuggerActive;
-
-        hwHelper.encodeBufferSurfaceState(args);
-    }
-}
-
 void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device,
                                      uint32_t computeUnitsUsedForSratch,
                                      NEO::GraphicsAllocation *globalConstBuffer,
@@ -120,7 +88,7 @@ void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device
 
     this->crossThreadDataSize = this->kernelDescriptor->kernelAttributes.crossThreadDataSize;
 
-    ArrayRef<uint8_t> crossThredDataArrayRef;
+    ArrayRef<uint8_t> crossThreadDataArrayRef;
     if (crossThreadDataSize != 0) {
         crossThreadDataTemplate.reset(new uint8_t[crossThreadDataSize]);
 
@@ -131,9 +99,9 @@ void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device
             memset(crossThreadDataTemplate.get(), 0x00, crossThreadDataSize);
         }
 
-        crossThredDataArrayRef = ArrayRef<uint8_t>(this->crossThreadDataTemplate.get(), this->crossThreadDataSize);
+        crossThreadDataArrayRef = ArrayRef<uint8_t>(this->crossThreadDataTemplate.get(), this->crossThreadDataSize);
 
-        NEO::patchNonPointer<uint32_t>(crossThredDataArrayRef,
+        NEO::patchNonPointer<uint32_t>(crossThreadDataArrayRef,
                                        kernelDescriptor->payloadMappings.implicitArgs.simdSize, kernelDescriptor->kernelAttributes.simdSize);
     }
 
@@ -158,7 +126,7 @@ void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device
     if (NEO::isValidOffset(kernelDescriptor->payloadMappings.implicitArgs.globalConstantsSurfaceAddress.stateless)) {
         UNRECOVERABLE_IF(nullptr == globalConstBuffer);
 
-        patchWithImplicitSurface(crossThredDataArrayRef, surfaceStateHeapArrayRef,
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
                                  static_cast<uintptr_t>(globalConstBuffer->getGpuAddressToPatch()),
                                  *globalConstBuffer, kernelDescriptor->payloadMappings.implicitArgs.globalConstantsSurfaceAddress,
                                  *neoDevice, kernelDescriptor->kernelAttributes.flags.useGlobalAtomics, deviceImp->isImplicitScalingCapable());
@@ -170,7 +138,7 @@ void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device
     if (NEO::isValidOffset(kernelDescriptor->payloadMappings.implicitArgs.globalVariablesSurfaceAddress.stateless)) {
         UNRECOVERABLE_IF(globalVarBuffer == nullptr);
 
-        patchWithImplicitSurface(crossThredDataArrayRef, surfaceStateHeapArrayRef,
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
                                  static_cast<uintptr_t>(globalVarBuffer->getGpuAddressToPatch()),
                                  *globalVarBuffer, kernelDescriptor->payloadMappings.implicitArgs.globalVariablesSurfaceAddress,
                                  *neoDevice, kernelDescriptor->kernelAttributes.flags.useGlobalAtomics, deviceImp->isImplicitScalingCapable());
@@ -785,10 +753,10 @@ void KernelImp::patchCrossthreadDataWithPrivateAllocation(NEO::GraphicsAllocatio
     auto &kernelAttributes = kernelImmData->getDescriptor().kernelAttributes;
     auto device = module->getDevice();
 
-    ArrayRef<uint8_t> crossThredDataArrayRef = ArrayRef<uint8_t>(this->crossThreadData.get(), this->crossThreadDataSize);
+    ArrayRef<uint8_t> crossThreadDataArrayRef = ArrayRef<uint8_t>(this->crossThreadData.get(), this->crossThreadDataSize);
     ArrayRef<uint8_t> surfaceStateHeapArrayRef = ArrayRef<uint8_t>(this->surfaceStateHeapData.get(), this->surfaceStateHeapDataSize);
 
-    patchWithImplicitSurface(crossThredDataArrayRef, surfaceStateHeapArrayRef,
+    patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
                              static_cast<uintptr_t>(privateAllocation->getGpuAddressToPatch()),
                              *privateAllocation, kernelImmData->getDescriptor().payloadMappings.implicitArgs.privateMemoryAddress,
                              *device->getNEODevice(), kernelAttributes.flags.useGlobalAtomics, device->isImplicitScalingCapable());

level_zero/core/source/kernel/patch_with_implicit_surface.inl

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+inline void patchWithImplicitSurface(ArrayRef<uint8_t> crossThreadData, ArrayRef<uint8_t> surfaceStateHeap,
+                                     uintptr_t ptrToPatchInCrossThreadData, NEO::GraphicsAllocation &allocation,
+                                     const NEO::ArgDescPointer &ptr, const NEO::Device &device, bool useGlobalAtomics,
+                                     bool implicitScaling) {
+    if (false == crossThreadData.empty()) {
+        NEO::patchPointer(crossThreadData, ptr, ptrToPatchInCrossThreadData);
+    }
+
+    if ((false == surfaceStateHeap.empty()) && (NEO::isValidOffset(ptr.bindful))) {
+        auto surfaceState = surfaceStateHeap.begin() + ptr.bindful;
+        auto addressToPatch = allocation.getGpuAddress();
+        size_t sizeToPatch = allocation.getUnderlyingBufferSize();
+
+        auto &hwInfo = device.getHardwareInfo();
+        auto &hwHelper = NEO::HwHelper::get(hwInfo.platform.eRenderCoreFamily);
+        auto isDebuggerActive = device.isDebuggerActive() || device.getDebugger() != nullptr;
+        NEO::EncodeSurfaceStateArgs args;
+        args.outMemory = surfaceState;
+        args.size = sizeToPatch;
+        args.graphicsAddress = addressToPatch;
+        args.gmmHelper = device.getGmmHelper();
+        args.allocation = &allocation;
+        args.useGlobalAtomics = useGlobalAtomics;
+        args.numAvailableDevices = device.getNumGenericSubDevices();
+        args.areMultipleSubDevicesInContext = args.numAvailableDevices > 1;
+        args.mocs = hwHelper.getMocsIndex(*args.gmmHelper, true, false) << 1;
+        args.implicitScaling = implicitScaling;
+        args.isDebuggerActive = isDebuggerActive;
+
+        hwHelper.encodeBufferSurfaceState(args);
+    }
+}

level_zero/core/test/unit_tests/sources/kernel/test_kernel_2.cpp

@@ -5,13 +5,18 @@
  *
  */
 
+#include "shared/test/common/mocks/mock_l0_debugger.h"
+#include "shared/test/common/test_macros/hw_test.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_module.h"
-
+namespace NEO {
+extern HwHelper *hwHelperFactory[IGFX_MAX_CORE];
+}
 namespace L0 {
+#include "level_zero/core/source/kernel/patch_with_implicit_surface.inl"
 namespace ult {
 
 using KernelImp = Test<DeviceFixture>;
@@ -232,6 +237,67 @@ TEST_F(KernelImp, GivenNumChannelsZeroWhenSettingGroupSizeThenLocalIdsNotGenerat
     EXPECT_EQ(memAfter, memBefore);
 }
 
+HWTEST_F(KernelImp, givenSurfaceStateHeapWhenPatchWithImplicitSurfaceCalledThenIsDebuggerActiveIsSetCorrectly) {
+    struct MockHwHelper : NEO::HwHelperHw<FamilyType> {
+        void encodeBufferSurfaceState(EncodeSurfaceStateArgs &args) override {
+            savedSurfaceStateArgs = args;
+            ++encodeBufferSurfaceStateCalled;
+        }
+        EncodeSurfaceStateArgs savedSurfaceStateArgs;
+        size_t encodeBufferSurfaceStateCalled{0};
+    };
+    MockHwHelper hwHelper{};
+    auto hwInfo = *defaultHwInfo.get();
+    VariableBackup<HwHelper *> hwHelperFactoryBackup{&NEO::hwHelperFactory[static_cast<size_t>(hwInfo.platform.eRenderCoreFamily)]};
+    hwHelperFactoryBackup = &hwHelper;
+
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+
+    auto surfaceStateHeap = std::make_unique<uint8_t[]>(2 * sizeof(RENDER_SURFACE_STATE));
+    auto crossThreadDataArrayRef = ArrayRef<uint8_t>();
+    auto surfaceStateHeapArrayRef = ArrayRef<uint8_t>(surfaceStateHeap.get(), 2 * sizeof(RENDER_SURFACE_STATE));
+    uintptr_t ptrToPatchInCrossThreadData = 0;
+    NEO::MockGraphicsAllocation globalBuffer;
+    ArgDescPointer ptr;
+    ASSERT_EQ(hwHelper.encodeBufferSurfaceStateCalled, 0u);
+    {
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
+                                 ptrToPatchInCrossThreadData,
+                                 globalBuffer, ptr,
+                                 *neoDevice, false, false);
+        EXPECT_EQ(hwHelper.encodeBufferSurfaceStateCalled, 0u);
+    }
+    {
+        ptr.bindful = 1;
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
+                                 ptrToPatchInCrossThreadData,
+                                 globalBuffer, ptr,
+                                 *neoDevice, false, false);
+        ASSERT_EQ(hwHelper.encodeBufferSurfaceStateCalled, 1u);
+        EXPECT_FALSE(hwHelper.savedSurfaceStateArgs.isDebuggerActive);
+    }
+    {
+        neoDevice->setDebuggerActive(true);
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
+                                 ptrToPatchInCrossThreadData,
+                                 globalBuffer, ptr,
+                                 *neoDevice, false, false);
+        ASSERT_EQ(hwHelper.encodeBufferSurfaceStateCalled, 2u);
+        EXPECT_TRUE(hwHelper.savedSurfaceStateArgs.isDebuggerActive);
+    }
+    {
+        neoDevice->setDebuggerActive(false);
+        auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
+        neoDevice->getRootDeviceEnvironmentRef().debugger.reset(debugger);
+        patchWithImplicitSurface(crossThreadDataArrayRef, surfaceStateHeapArrayRef,
+                                 ptrToPatchInCrossThreadData,
+                                 globalBuffer, ptr,
+                                 *neoDevice, false, false);
+        ASSERT_EQ(hwHelper.encodeBufferSurfaceStateCalled, 3u);
+        EXPECT_TRUE(hwHelper.savedSurfaceStateArgs.isDebuggerActive);
+    }
+}
+
 TEST(zeKernelGetProperties, WhenGettingKernelPropertiesThenSuccessIsReturned) {
     Mock<Kernel> kernel;
 

level_zero/core/test/unit_tests/xe_hpg_core/dg2/test_module_dg2.cpp

@@ -5,18 +5,78 @@
  *
  */
 
+#include "shared/source/kernel/kernel_arg_descriptor.h"
 #include "shared/test/common/mocks/mock_compilers.h"
 #include "shared/test/common/mocks/mock_l0_debugger.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_module.h"
 
+#include "encode_surface_state_args.h"
+
 namespace L0 {
+#include "level_zero/core/source/kernel/patch_with_implicit_surface.inl"
 namespace ult {
 using KernelDebugSurfaceDG2Test = Test<ModuleFixture>;
 
-HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerAndBindfulKernelWhenAppendingKernelToCommandListThenCachePolicyIsWBP, IsDG2) {
+HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerWhenKernelInitializeCalledThenCachePolicyIsWBP, IsDG2) {
+    NEO::MockCompilerEnableGuard mock(true);
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+
+    auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
+
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(debugger);
+    auto &hwInfo = *NEO::defaultHwInfo.get();
+    auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
+    auto maxDbgSurfaceSize = hwHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
+    auto debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
+        {device->getRootDeviceIndex(), true,
+         maxDbgSurfaceSize,
+         NEO::AllocationType::DEBUG_CONTEXT_SAVE_AREA,
+         false,
+         false,
+         device->getNEODevice()->getDeviceBitfield()});
+    static_cast<L0::DeviceImp *>(device)->setDebugSurface(debugSurface);
+
+    uint8_t binary[10];
+    ze_module_desc_t moduleDesc = {};
+    moduleDesc.format = ZE_MODULE_FORMAT_NATIVE;
+    moduleDesc.pInputModule = binary;
+    moduleDesc.inputSize = 10;
+    ModuleBuildLog *moduleBuildLog = nullptr;
+
+    std::unique_ptr<MockModule> module = std::make_unique<MockModule>(device,
+                                                                      moduleBuildLog,
+                                                                      ModuleType::User);
+
+    module->debugEnabled = true;
+
+    uint32_t kernelHeap = 0;
+    KernelInfo kernelInfo;
+    kernelInfo.heapInfo.KernelHeapSize = 1;
+    kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
+
+    Mock<::L0::Kernel> kernel;
+    kernel.module = module.get();
+    kernel.immutableData.kernelInfo = &kernelInfo;
+
+    ze_kernel_desc_t desc = {};
+
+    kernel.immutableData.kernelDescriptor->payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful = sizeof(RENDER_SURFACE_STATE);
+    kernel.immutableData.surfaceStateHeapSize = 2 * sizeof(RENDER_SURFACE_STATE);
+    kernel.immutableData.surfaceStateHeapTemplate.reset(new uint8_t[2 * sizeof(RENDER_SURFACE_STATE)]);
+    module->kernelImmData = &kernel.immutableData;
+
+    kernel.initialize(&desc);
+
+    auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(kernel.surfaceStateHeapData.get());
+    debugSurfaceState = ptrOffset(debugSurfaceState, sizeof(RENDER_SURFACE_STATE));
+
+    EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_POLICY_WBP, debugSurfaceState->getL1CachePolicyL1CacheControl());
+}
+
+HWTEST2_F(KernelDebugSurfaceDG2Test, givenNoDebuggerButDebuggerActiveSetWhenPatchWithImplicitSurfaceCalledThenCachePolicyIsWBP, IsDG2) {
     NEO::MockCompilerEnableGuard mock(true);
     using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
 
@@ -67,10 +127,18 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerAndBindfulKernelWhenAppendingK
 
     kernel.initialize(&desc);
 
+    auto surfaceStateHeapRef = ArrayRef<uint8_t>(kernel.surfaceStateHeapData.get(), kernel.immutableData.surfaceStateHeapSize);
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(nullptr);
+    patchWithImplicitSurface(ArrayRef<uint8_t>(), surfaceStateHeapRef,
+                             0,
+                             *device->getDebugSurface(), kernel.immutableData.kernelDescriptor->payloadMappings.implicitArgs.systemThreadSurfaceAddress,
+                             *device->getNEODevice(), kernel.immutableData.kernelDescriptor->kernelAttributes.flags.useGlobalAtomics, device->isImplicitScalingCapable());
+
     auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(kernel.surfaceStateHeapData.get());
     debugSurfaceState = ptrOffset(debugSurfaceState, sizeof(RENDER_SURFACE_STATE));
 
     EXPECT_EQ(RENDER_SURFACE_STATE::L1_CACHE_POLICY_WBP, debugSurfaceState->getL1CachePolicyL1CacheControl());
 }
+
 } // namespace ult
 } // namespace L0