Kernel Source Level debugger support 3/n

- debug kernel tests
- removed bti and debug sip surface size from sip kernel

Change-Id: I25b8668df0e29e70a5b8d21828dc36ab3ba4fded

runtime/built_ins/sip.cpp

@@ -80,10 +80,6 @@ const char *getSipLlSrc(const Device &device) {
 SipKernel::SipKernel(SipKernelType type, Program *sipProgram)
     : type(type) {
     program.reset(sipProgram);
-    if (type == SipKernelType::DbgCsr || type == SipKernelType::DbgCsrLocal) {
-        debugSurfaceBti = 0;
-        debugSurfaceSize = SipKernel::maxDbgSurfaceSize;
-    }
 }
 
 GraphicsAllocation *SipKernel::getSipAllocation() const {

runtime/built_ins/sip.h

@@ -58,14 +58,6 @@ class SipKernel {
         return type;
     }
 
-    int32_t getDebugSurfaceBti() const {
-        return debugSurfaceBti;
-    }
-
-    size_t getDebugSurfaceSize() const {
-        return debugSurfaceSize;
-    }
-
     static const size_t maxDbgSurfaceSize;
 
     GraphicsAllocation *getSipAllocation() const;
@@ -73,7 +65,5 @@ class SipKernel {
   protected:
     SipKernelType type = SipKernelType::COUNT;
     std::unique_ptr<Program> program;
-    int32_t debugSurfaceBti = -1;
-    size_t debugSurfaceSize = 0;
 };
-}
+} // namespace OCLRT

runtime/kernel/kernel.h

@@ -350,6 +350,20 @@ class Kernel : public BaseObject<_cl_kernel> {
         return isParentKernel && getProgram()->getBlockKernelManager()->getIfBlockUsesPrintf();
     }
 
+    int32_t getDebugSurfaceBti() const {
+        if (kernelInfo.patchInfo.pAllocateSystemThreadSurface) {
+            return kernelInfo.patchInfo.pAllocateSystemThreadSurface->BTI;
+        }
+        return -1;
+    }
+
+    size_t getPerThreadSystemThreadSurfaceSize() const {
+        if (kernelInfo.patchInfo.pAllocateSystemThreadSurface) {
+            return kernelInfo.patchInfo.pAllocateSystemThreadSurface->PerThreadSystemThreadSurfaceSize;
+        }
+        return 0;
+    }
+
   protected:
     struct ObjectCounts {
         uint32_t imageCount;

unit_tests/built_ins/sip_tests.cpp

@@ -110,16 +110,6 @@ TEST(Sip, getType) {
     EXPECT_EQ(SipKernelType::COUNT, undefined.getType());
 }
 
-TEST(Sip, givenCsrTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) {
-    SipKernel csr{SipKernelType::Csr, getSipProgramWithCustomBinary()};
-    EXPECT_EQ(-1, csr.getDebugSurfaceBti());
-}
-
-TEST(Sip, givenCsrTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenZeroIsReturned) {
-    SipKernel csr{SipKernelType::Csr, getSipProgramWithCustomBinary()};
-    EXPECT_EQ(0u, csr.getDebugSurfaceSize());
-}
-
 TEST(Sip, givenSipKernelClassWhenAskedForMaxDebugSurfaceSizeThenCorrectValueIsReturned) {
     EXPECT_EQ(0x49c000u, SipKernel::maxDbgSurfaceSize);
 }
@@ -136,7 +126,7 @@ TEST(DebugSip, WhenRequestingDbgCsrWithLocalMemorySipKernelThenProperCompilerInt
     EXPECT_STREQ("-cl-include-sip-kernel-local-debug -cl-include-sip-csr -cl-set-bti:0", opt);
 }
 
-TEST(DebugSip, DISABLED_givenDebugCsrSipKernelWhenAskedForDebugSurfaceBtiAndSizeThenBtiIsZeroAndSizeGreaterThanZero) {
+TEST(DebugSip, DISABLED_givenBuiltInsWhenDbgCsrSipIsRequestedThanCorrectSipKernelIsReturned) {
     auto mockDevice = std::unique_ptr<MockDevice>(Device::create<MockDevice>(nullptr));
     EXPECT_NE(nullptr, mockDevice);
     MockCompilerDebugVars igcDebugVars;
@@ -153,29 +143,9 @@ TEST(DebugSip, DISABLED_givenDebugCsrSipKernelWhenAskedForDebugSurfaceBtiAndSize
     auto &builtins = BuiltIns::getInstance();
     auto &sipKernel = builtins.getSipKernel(SipKernelType::DbgCsr, *mockDevice);
 
-    EXPECT_EQ((int32_t)0, sipKernel.getDebugSurfaceBti());
-    EXPECT_EQ(SipKernel::maxDbgSurfaceSize, sipKernel.getDebugSurfaceSize());
-
+    EXPECT_NE(nullptr, &sipKernel);
+    EXPECT_EQ(SipKernelType::DbgCsr, sipKernel.getType());
     gEnvironment->igcPopDebugVars();
 }
 
-TEST(DebugSip, givenDbgCsrTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) {
-    SipKernel csr{SipKernelType::DbgCsr, getSipProgramWithCustomBinary()};
-    EXPECT_EQ(0, csr.getDebugSurfaceBti());
-}
-
-TEST(DebugSip, givenDbgCsrTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenNonZeroIsReturned) {
-    SipKernel csr{SipKernelType::DbgCsr, getSipProgramWithCustomBinary()};
-    EXPECT_NE(0u, csr.getDebugSurfaceSize());
-}
-
-TEST(DebugSip, givenDbgCsrLocalTypeSipKernelWhenGetDebugSurfaceBtiIsCalledThenInvalidValueIsReturned) {
-    SipKernel csr{SipKernelType::DbgCsrLocal, getSipProgramWithCustomBinary()};
-    EXPECT_EQ(0, csr.getDebugSurfaceBti());
-}
-
-TEST(DebugSip, givenDbgCsrLocalTypeSipKernelWhenGetDebugSurfaceSizeIsCalledThenNonZeroIsReturned) {
-    SipKernel csr{SipKernelType::DbgCsrLocal, getSipProgramWithCustomBinary()};
-    EXPECT_NE(0u, csr.getDebugSurfaceSize());
-}
-} // namespace SipKernelTests
+} // namespace SipKernelTests

unit_tests/gen9/sip_tests.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2017, Intel Corporation
+* Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -53,8 +53,8 @@ GEN9TEST_F(gen9SipTests, DISABLED_givenDebugCsrSipKernelWithLocalMemoryWhenAsked
     auto &builtins = BuiltIns::getInstance();
     auto &sipKernel = builtins.getSipKernel(SipKernelType::DbgCsrLocal, *mockDevice);
 
-    EXPECT_EQ((int32_t)0, sipKernel.getDebugSurfaceBti());
-    EXPECT_EQ(SipKernel::maxDbgSurfaceSize, sipKernel.getDebugSurfaceSize());
+    EXPECT_NE(nullptr, &sipKernel);
+    EXPECT_EQ(SipKernelType::DbgCsrLocal, sipKernel.getType());
 
     gEnvironment->igcPopDebugVars();
 }

unit_tests/kernel/CMakeLists.txt

@@ -36,6 +36,7 @@ set(IGDRCL_SRCS_tests_kernel
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_arg_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_slm_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/debug_kernel_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/parent_kernel_tests.cpp
 )
 target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_kernel})

unit_tests/kernel/debug_kernel_tests.cpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "unit_tests/fixtures/execution_model_kernel_fixture.h"
+#include "unit_tests/mocks/mock_device.h"
+#include "unit_tests/mocks/mock_kernel.h"
+#include "unit_tests/mocks/mock_program.h"
+#include "test.h"
+
+#include <memory>
+
+using namespace OCLRT;
+
+class MockDebugKernel : public MockKernel {
+  public:
+    MockDebugKernel(Program *program, KernelInfo &kernelInfo, const Device &device) : MockKernel(program, kernelInfo, device) {
+        if (!kernelInfo.patchInfo.pAllocateSystemThreadSurface) {
+            SPatchAllocateSystemThreadSurface *patchToken = new SPatchAllocateSystemThreadSurface;
+
+            patchToken->BTI = 0;
+            patchToken->Offset = 0;
+            patchToken->PerThreadSystemThreadSurfaceSize = MockDebugKernel::perThreadSystemThreadSurfaceSize;
+            patchToken->Size = sizeof(SPatchAllocateSystemThreadSurface);
+            patchToken->Token = iOpenCL::PATCH_TOKEN_ALLOCATE_SIP_SURFACE;
+
+            kernelInfo.patchInfo.pAllocateSystemThreadSurface = patchToken;
+
+            systemThreadSurfaceAllocated = true;
+        }
+    }
+
+    ~MockDebugKernel() override {
+        if (systemThreadSurfaceAllocated) {
+            delete kernelInfo.patchInfo.pAllocateSystemThreadSurface;
+        }
+    }
+    static const uint32_t perThreadSystemThreadSurfaceSize;
+    bool systemThreadSurfaceAllocated = false;
+};
+
+const uint32_t MockDebugKernel::perThreadSystemThreadSurfaceSize = 0x100;
+
+TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetDebugSurfaceBtiIsCalledThenCorrectValueIsReturned) {
+    std::unique_ptr<MockDevice> device(new MockDevice(*platformDevices[0]));
+    MockProgram program;
+    program.enableKernelDebug();
+    std::unique_ptr<MockKernel> kernel(MockKernel::create<MockDebugKernel>(*device.get(), &program));
+
+    EXPECT_EQ(0, kernel->getDebugSurfaceBti());
+}
+
+TEST(DebugKernelTest, givenKernelCompiledForDebuggingWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenCorrectValueIsReturned) {
+    std::unique_ptr<MockDevice> device(new MockDevice(*platformDevices[0]));
+    MockProgram program;
+    program.enableKernelDebug();
+    std::unique_ptr<MockDebugKernel> kernel(MockKernel::create<MockDebugKernel>(*device.get(), &program));
+
+    EXPECT_EQ(MockDebugKernel::perThreadSystemThreadSurfaceSize, kernel->getPerThreadSystemThreadSurfaceSize());
+}
+
+TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetDebugSurfaceBtiIsCalledThenInvalidIndexValueIsReturned) {
+    std::unique_ptr<MockDevice> device(new MockDevice(*platformDevices[0]));
+    MockProgram program;
+    program.enableKernelDebug();
+    std::unique_ptr<MockKernel> kernel(MockKernel::create<MockKernel>(*device.get(), &program));
+
+    EXPECT_EQ(-1, kernel->getDebugSurfaceBti());
+}
+
+TEST(DebugKernelTest, givenKernelWithoutDebugFlagWhenGetPerThreadSystemThreadSurfaceSizeIsCalledThenZeroIsReturned) {
+    std::unique_ptr<MockDevice> device(new MockDevice(*platformDevices[0]));
+    MockProgram program;
+    program.enableKernelDebug();
+    std::unique_ptr<MockKernel> kernel(MockKernel::create<MockKernel>(*device.get(), &program));
+
+    EXPECT_EQ(0u, kernel->getPerThreadSystemThreadSurfaceSize());
+}

unit_tests/mocks/mock_kernel.cpp

@@ -62,5 +62,4 @@ void MockKernel::getResidency(std::vector<Surface *> &dst) {
     getResidencyCalls++;
     Kernel::getResidency(dst);
 }
-
 } // namespace OCLRT

unit_tests/mocks/mock_kernel.h

@@ -97,6 +97,52 @@ class MockKernel : public Kernel {
         if (Kernel::pSshLocal == mockSshLocal.data()) {
             Kernel::pSshLocal = nullptr;
         }
+
+        if (kernelInfoAllocated) {
+            delete kernelInfoAllocated->heapInfo.pKernelHeader;
+            delete kernelInfoAllocated->patchInfo.executionEnvironment;
+            delete kernelInfoAllocated->patchInfo.threadPayload;
+            delete kernelInfoAllocated;
+        }
+    }
+
+    template <typename KernelType = MockKernel>
+    static KernelType *create(Device &device, Program *program) {
+        KernelInfo *info = new KernelInfo();
+        const size_t crossThreadSize = 160;
+
+        SKernelBinaryHeaderCommon *header = new SKernelBinaryHeaderCommon;
+        header->DynamicStateHeapSize = 0;
+        header->GeneralStateHeapSize = 0;
+        header->KernelHeapSize = 0;
+        header->KernelNameSize = 0;
+        header->PatchListSize = 0;
+        header->SurfaceStateHeapSize = 0;
+        info->heapInfo.pKernelHeader = header;
+
+        SPatchThreadPayload *threadPayload = new SPatchThreadPayload;
+        threadPayload->LocalIDXPresent = 0;
+        threadPayload->LocalIDYPresent = 0;
+        threadPayload->LocalIDZPresent = 0;
+        threadPayload->HeaderPresent = 0;
+        threadPayload->Size = 128;
+
+        info->patchInfo.threadPayload = threadPayload;
+
+        SPatchExecutionEnvironment *executionEnvironment = new SPatchExecutionEnvironment;
+        executionEnvironment->HasDeviceEnqueue = 1;
+        info->patchInfo.executionEnvironment = executionEnvironment;
+
+        info->crossThreadData = new char[crossThreadSize];
+
+        auto kernel = new KernelType(program, *info, device);
+        kernel->crossThreadData = new char[crossThreadSize];
+        memset(kernel->crossThreadData, 0, crossThreadSize);
+        kernel->crossThreadDataSize = crossThreadSize;
+
+        kernel->kernelInfoAllocated = info;
+
+        return kernel;
     }
 
     uint32_t getPatchedArgumentsNum() const { return patchedArgumentsNum; }
@@ -188,6 +234,9 @@ class MockKernel : public Kernel {
 
     uint32_t makeResidentCalls = 0;
     uint32_t getResidencyCalls = 0;
+
+  protected:
+    KernelInfo *kernelInfoAllocated = nullptr;
 };
 
 //class below have enough internals to service Enqueue operation.