Handle when gtpin kernel start offset is not zero

Change-Id: I3e8365455a23b0f271c5c1211dda6e2f4241a4e9

Author: MaciejPlewka

runtime/gtpin/gtpin_callbacks.cpp

@@ -126,6 +126,7 @@ void gtpinNotifyKernelSubmit(cl_kernel kernel, void *pCmdQueue) {
         // Notify GT-Pin that kernel was submited for execution
         (*GTPinCallbacks.onKernelSubmit)(commandBuffer, kernelId, &kernelOffset, &resource);
         // Create new record in Kernel Execution Queue describing submited kernel
+        pKernel->setStartOffset(kernelOffset);
         gtpinkexec_t kExec;
         kExec.pKernel = pKernel;
         kExec.gtpinResource = (cl_mem)resource;
@@ -250,4 +251,4 @@ void gtpinNotifyPlatformShutdown() {
         kernelExecQueue.clear();
     }
 }
-}
+} // namespace OCLRT

runtime/helpers/kernel_commands.inl

@@ -319,7 +319,7 @@ size_t KernelCommandsHelper<GfxFamily>::sendIndirectState(
     if (kernelAllocation) {
         kernelStartOffset = kernelInfo.getGraphicsAllocation()->getGpuAddressToPatch();
     }
-
+    kernelStartOffset += kernel.getStartOffset();
     const auto &patchInfo = kernelInfo.patchInfo;
 
     auto dstBindingTablePointer = pushBindingTableAndSurfaceStates(ssh, kernel);

runtime/kernel/kernel.cpp

@@ -726,6 +726,12 @@ void Kernel::setKernelId(uint64_t newKernelId) {
     KernelInfo *pKernelInfo = const_cast<KernelInfo *>(&kernelInfo);
     pKernelInfo->kernelId = newKernelId;
 }
+uint32_t Kernel::getStartOffset() const {
+    return this->startOffset;
+}
+void Kernel::setStartOffset(uint32_t offset) {
+    this->startOffset = offset;
+}
 
 const void *Kernel::getSurfaceStateHeap() const {
     return kernelInfo.usesSsh

runtime/kernel/kernel.h

@@ -171,6 +171,8 @@ class Kernel : public BaseObject<_cl_kernel> {
     bool isKernelHeapSubstituted() const;
     uint64_t getKernelId() const;
     void setKernelId(uint64_t newKernelId);
+    uint32_t getStartOffset() const;
+    void setStartOffset(uint32_t offset);
 
     const std::vector<SimpleKernelArgInfo> &getKernelArguments() const {
         return kernelArguments;
@@ -487,6 +489,7 @@ class Kernel : public BaseObject<_cl_kernel> {
 
     bool usingSharedObjArgs;
     uint32_t patchedArgumentsNum = 0;
+    uint32_t startOffset = 0;
 
     std::vector<PatchInfoData> patchInfoDataList;
     std::unique_ptr<ImageTransformer> imageTransformer;

unit_tests/gtpin/gtpin_tests.cpp

@@ -39,6 +39,10 @@
 #include "unit_tests/fixtures/platform_fixture.h"
 #include "unit_tests/helpers/kernel_binary_helper.h"
 #include "unit_tests/helpers/test_files.h"
+#include "unit_tests/helpers/variable_backup.h"
+#include "unit_tests/mocks/mock_command_queue.h"
+#include "unit_tests/mocks/mock_context.h"
+#include "unit_tests/mocks/mock_kernel.h"
 #include "test.h"
 #include "gtest/gtest.h"
 #include <deque>
@@ -59,6 +63,7 @@ int KernelCreateCallbackCount = 0;
 int KernelSubmitCallbackCount = 0;
 int CommandBufferCreateCallbackCount = 0;
 int CommandBufferCompleteCallbackCount = 0;
+uint32_t kernelOffset = 0;
 bool returnNullResource = false;
 
 context_handle_t currContext = nullptr;
@@ -98,7 +103,7 @@ void OnKernelSubmit(command_buffer_handle_t cb, uint64_t kernelId, uint32_t *ent
         EXPECT_EQ(GTPIN_DI_SUCCESS, st);
         EXPECT_NE(nullptr, bufAddress);
     }
-    *entryOffset = 0;
+    *entryOffset = kernelOffset;
     *resource = currResource;
     kernelResources.push_back(currResource);
 
@@ -122,15 +127,10 @@ void OnCommandBufferComplete(command_buffer_handle_t cb) {
 
     CommandBufferCompleteCallbackCount++;
 }
-
 class GTPinFixture : public ContextFixture, public MemoryManagementFixture {
     using ContextFixture::SetUp;
 
   public:
-    GTPinFixture() {
-    }
-
-  protected:
     void SetUp() override {
         MemoryManagementFixture::SetUp();
         pPlatform = platform();
@@ -152,6 +152,7 @@ class GTPinFixture : public ContextFixture, public MemoryManagementFixture {
         gtpinCallbacks.onCommandBufferComplete = nullptr;
 
         OCLRT::isGTPinInitialized = false;
+        kernelOffset = 0;
     }
 
     void TearDown() override {
@@ -2183,4 +2184,45 @@ TEST(GTPinOfflineTests, givenGtPinInDisabledStateWhenCallbacksFromEnqueuePathAre
     gtpinNotifyFlushTask(dummyCompletedTask);
     EXPECT_FALSE(gtpinIsGTPinInitialized());
 }
+TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCorrectOffsetisSetInKernel) {
+    gtpinCallbacks.onContextCreate = OnContextCreate;
+    gtpinCallbacks.onContextDestroy = OnContextDestroy;
+    gtpinCallbacks.onKernelCreate = OnKernelCreate;
+    gtpinCallbacks.onKernelSubmit = OnKernelSubmit;
+    gtpinCallbacks.onCommandBufferCreate = OnCommandBufferCreate;
+    gtpinCallbacks.onCommandBufferComplete = OnCommandBufferComplete;
+    retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, nullptr);
+    VariableBackup<bool> returnNullResourceBckp(&returnNullResource);
+    VariableBackup<uint32_t> kernelOffsetBckp(&kernelOffset);
+    EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
+
+    char surfaceStateHeap[0x80];
+    SKernelBinaryHeaderCommon kernelHeader;
+    std::unique_ptr<MockContext> context(new MockContext(pDevice));
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    std::unique_ptr<KernelInfo> pKernelInfo(KernelInfo::create());
+    kernelHeader.SurfaceStateHeapSize = sizeof(surfaceStateHeap);
+    pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
+    pKernelInfo->heapInfo.pKernelHeader = &kernelHeader;
+    pKernelInfo->usesSsh = true;
+
+    std::unique_ptr<MockProgram> pProgramm(new MockProgram(context.get(), false));
+    std::unique_ptr<MockCommandQueue> cmdQ(new MockCommandQueue(context.get(), pDevice, nullptr));
+    std::unique_ptr<MockKernel> pKernel(new MockKernel(pProgramm.get(), *pKernelInfo, *pDevice));
+
+    pKernel->setSshLocal(nullptr, sizeof(surfaceStateHeap));
+
+    kernelOffset = 0x1234;
+    EXPECT_NE(pKernel->getStartOffset(), kernelOffset);
+    returnNullResource = true;
+    cl_context ctxt = (cl_context)((Context *)context.get());
+    currContext = (gtpin::context_handle_t)ctxt;
+    gtpinNotifyKernelSubmit(pKernel.get(), cmdQ.get());
+    EXPECT_EQ(pKernel->getStartOffset(), kernelOffset);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    kernelResources.clear();
+}
 } // namespace ULT