Enable 'Pass info between GT-Pin and IGC', after being reverted

This reverts commit ea92874a66.

Change-Id: I4994b30f059012a5e89d899665af5c24b8ac8b18

runtime/compiler_interface/compiler_interface.cpp

@@ -145,7 +145,7 @@ cl_int CompilerInterface::build(
             auto igcTranslationCtx = createIgcTranslationCtx(device, intermediateCodeType, IGC::CodeType::oclGenBin);
 
             auto igcOutput = translate(igcTranslationCtx.get(), intermediateRepresentation.get(),
-                                       fclOptions.get(), fclInternalOptions.get());
+                                       fclOptions.get(), fclInternalOptions.get(), inputArgs.GTPinInput);
 
             if (igcOutput == nullptr) {
                 return CL_OUT_OF_HOST_MEMORY;

runtime/compiler_interface/compiler_interface.inl

@@ -49,6 +49,24 @@ inline CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL> translate(TranslationC
 
     return ret;
 }
+template <typename TranslationCtx>
+inline CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL> translate(TranslationCtx *tCtx, CIFBuffer *src, CIFBuffer *options,
+                                                                    CIFBuffer *internalOptions, void *gtpinInit) {
+    if (false == OCLRT::areNotNullptr(tCtx, src, options, internalOptions)) {
+        return nullptr;
+    }
+
+    auto ret = tCtx->Translate(src, options, internalOptions, nullptr, 0, gtpinInit);
+    if (ret == nullptr) {
+        return nullptr; // assume OOM or internal error
+    }
+
+    if ((ret->GetOutput() == nullptr) || (ret->GetBuildLog() == nullptr) || (ret->GetDebugData() == nullptr)) {
+        return nullptr; // assume OOM or internal error
+    }
+
+    return ret;
+}
 
 CIF::CIFMain *createMainNoSanitize(CIF::CreateCIFMainFunc_t createFunc);
 

runtime/gtpin/gtpin_callback_stubs.cpp

@@ -55,4 +55,15 @@ void gtpinNotifyUpdateResidencyList(void *pKernel, void *pResidencyVector) {
 
 void gtpinNotifyPlatformShutdown() {
 }
+
+void *gtpinGetIgcInit() {
+    return nullptr;
+}
+
+void setIgcInfo(const void *igcInfo) {
+}
+
+const void *gtpinGetIgcInfo() {
+    return nullptr;
+}
 } // namespace OCLRT

runtime/gtpin/gtpin_callbacks.cpp

@@ -34,6 +34,7 @@
 #include "runtime/mem_obj/buffer.h"
 #include "runtime/memory_manager/surface.h"
 #include "runtime/platform/platform.h"
+#include "runtime/program/program.h"
 #include "runtime/utilities/spinlock.h"
 #include <deque>
 #include <vector>
@@ -44,7 +45,8 @@ namespace OCLRT {
 
 extern gtpin::ocl::gtpin_events_t GTPinCallbacks;
 
-igc_init_t *pIgcInfo = nullptr;
+igc_init_t *pIgcInit = nullptr;
+const igc_info_t *pIgcInfo = nullptr;
 std::atomic<int> sequenceCount(1);
 CommandQueue *pCmdQueueForFlushTask = nullptr;
 std::deque<gtpinkexec_t> kernelExecQueue;
@@ -59,7 +61,7 @@ void gtpinNotifyContextCreate(cl_context context) {
         GTPinHwHelper &gtpinHelper = GTPinHwHelper::get(genFamily);
         gtpinPlatformInfo.gen_version = (gtpin::GTPIN_GEN_VERSION)gtpinHelper.getGenVersion();
         gtpinPlatformInfo.device_id = static_cast<uint32_t>(pDevice->getHardwareInfo().pPlatform->usDeviceID);
-        (*GTPinCallbacks.onContextCreate)((context_handle_t)context, &gtpinPlatformInfo, &pIgcInfo);
+        (*GTPinCallbacks.onContextCreate)((context_handle_t)context, &gtpinPlatformInfo, &pIgcInit);
     }
 }
 
@@ -90,7 +92,8 @@ void gtpinNotifyKernelCreate(cl_kernel kernel) {
         Context *pContext = &(pKernel->getContext());
         cl_context context = (cl_context)pContext;
         auto &kernelInfo = pKernel->getKernelInfo();
-        instrument_params_in_t paramsIn;
+        instrument_params_in_t paramsIn = {};
+
         paramsIn.kernel_type = GTPIN_KERNEL_TYPE_CS;
         paramsIn.simd = (GTPIN_SIMD_WIDTH)kernelInfo.getMaxSimdSize();
         paramsIn.orig_kernel_binary = (uint8_t *)pKernel->getKernelHeap();
@@ -99,7 +102,9 @@ void gtpinNotifyKernelCreate(cl_kernel kernel) {
         paramsIn.buffer_desc.BTI = static_cast<uint32_t>(gtpinBTI);
         paramsIn.igc_hash_id = kernelInfo.heapInfo.pKernelHeader->ShaderHashCode;
         paramsIn.kernel_name = (char *)kernelInfo.name.c_str();
-        paramsIn.igc_info = nullptr;
+        paramsIn.igc_info = pIgcInfo;
+        paramsIn.debug_data = pKernel->getProgram()->getDebugData();
+        paramsIn.debug_data_size = static_cast<uint32_t>(pKernel->getProgram()->getDebugDataSize());
         instrument_params_out_t paramsOut = {0};
         (*GTPinCallbacks.onKernelCreate)((context_handle_t)(cl_context)context, &paramsIn, &paramsOut);
         // Substitute ISA of created kernel with instrumented code
@@ -245,4 +250,15 @@ void gtpinNotifyPlatformShutdown() {
         kernelExecQueue.clear();
     }
 }
+void *gtpinGetIgcInit() {
+    return pIgcInit;
+}
+
+void setIgcInfo(const void *igcInfo) {
+    pIgcInfo = reinterpret_cast<const igc_info_t *>(igcInfo);
+}
+
+const void *gtpinGetIgcInfo() {
+    return pIgcInfo;
+}
 } // namespace OCLRT

runtime/gtpin/gtpin_init.cpp

@@ -36,13 +36,14 @@ gtpin::ocl::gtpin_events_t GTPinCallbacks = {0};
 } // namespace OCLRT
 
 GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, driver_services_t *pDriverServices,
-                           uint32_t *pDriverVersion) {
+                           interface_version_t *pDriverVersion) {
     if (isGTPinInitialized) {
         return GTPIN_DI_ERROR_INSTANCE_ALREADY_CREATED;
     }
     if (pDriverVersion != nullptr) {
         // GT-Pin is asking to obtain GT-Pin Interface version that is supported
-        *pDriverVersion = gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION;
+        pDriverVersion->common = gtpin::GTPIN_COMMON_INTERFACE_VERSION;
+        pDriverVersion->specific = gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION;
 
         if ((pDriverServices == nullptr) || (pGtpinEvents == nullptr)) {
             return GTPIN_DI_SUCCESS;

runtime/gtpin/gtpin_init.h

@@ -27,7 +27,7 @@
 extern "C" {
 #endif
 
-gtpin::GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, gtpin::driver_services_t *pDriverServices, uint32_t *pDriverVersion);
+gtpin::GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, gtpin::driver_services_t *pDriverServices, gtpin::interface_version_t *pDriverVersion);
 
 #ifdef __cplusplus
 }

runtime/gtpin/gtpin_notify.h

@@ -36,4 +36,7 @@ void gtpinNotifyMakeResident(void *pKernel, void *pCommandStreamReceiver);
 void gtpinNotifyUpdateResidencyList(void *pKernel, void *pResidencyVector);
 void gtpinNotifyPlatformShutdown();
 inline bool gtpinIsGTPinInitialized() { return isGTPinInitialized; }
+void *gtpinGetIgcInit();
+void setIgcInfo(const void *igcInfo);
+const void *gtpinGetIgcInfo();
 } // namespace OCLRT

runtime/program/build.cpp

@@ -26,6 +26,7 @@
 #include "runtime/platform/platform.h"
 #include "runtime/source_level_debugger/source_level_debugger.h"
 #include "runtime/helpers/validators.h"
+#include "runtime/gtpin/gtpin_notify.h"
 #include "program.h"
 #include <cstring>
 
@@ -121,6 +122,7 @@ cl_int Program::build(
             inputArgs.InternalOptionsSize = (uint32_t)internalOptions.length();
             inputArgs.pTracingOptions = nullptr;
             inputArgs.TracingOptionsCount = 0;
+            inputArgs.GTPinInput = gtpinGetIgcInit();
             DBG_LOG(LogApiCalls,
                     "Build Options", inputArgs.pOptions,
                     "\nBuild Internal Options", inputArgs.pInternalOptions);

runtime/program/process_gen_binary.cpp

@@ -31,6 +31,7 @@
 #include "runtime/helpers/string.h"
 #include "runtime/kernel/kernel.h"
 #include "runtime/memory_manager/memory_manager.h"
+#include "runtime/gtpin/gtpin_notify.h"
 
 #include <algorithm>
 
@@ -790,7 +791,13 @@ cl_int Program::parsePatchList(KernelInfo &kernelInfo) {
                     "\n  .Offset", pPatchToken->Offset,
                     "\n  .PerThreadSystemThreadSurfaceSize", pPatchToken->PerThreadSystemThreadSurfaceSize);
         } break;
-
+        case PATCH_TOKEN_GTPIN_INFO: {
+            setIgcInfo(ptrOffset(pCurPatchListPtr, sizeof(SPatchItemHeader)));
+            DBG_LOG(LogPatchTokens,
+                    "\n.PATCH_TOKEN_GTPIN_INFO", pPatch->Token,
+                    "\n  .Size", pPatch->Size);
+            break;
+        }
         default:
             printDebugString(DebugManager.flags.PrintDebugMessages.get(), stderr, " Program::parsePatchList. Unknown Patch Token: %d\n", pPatch->Token);
             if (false == isSafeToSkipUnhandledToken(pPatch->Token)) {

runtime/program/program.h

@@ -246,6 +246,14 @@ class Program : public BaseObject<_cl_program> {
         return kernelDebugEnabled;
     }
 
+    char *getDebugData() {
+        return debugData;
+    }
+
+    size_t getDebugDataSize() {
+        return debugDataSize;
+    }
+
   protected:
     Program();
 

unit_tests/compiler_interface/compiler_interface_tests.cpp

@@ -578,6 +578,13 @@ struct TranslationCtxMock {
 
         return CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL>(ret);
     }
+    CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL> Translate(CIF::Builtins::BufferSimple *src,
+                                                                 CIF::Builtins::BufferSimple *options,
+                                                                 CIF::Builtins::BufferSimple *internalOptions,
+                                                                 CIF::Builtins::BufferSimple *tracingOptions,
+                                                                 uint32_t tracingOptionsCount, void *gtpinInit) {
+        return this->Translate(src, options, internalOptions, tracingOptions, tracingOptionsCount);
+    }
 };
 
 TEST(TranslateTest, whenArgsAreValidAndTranslatorReturnsValidOutputThenValidOutputIsReturned) {
@@ -603,6 +610,15 @@ TEST(TranslateTest, whenTranslatorReturnsNullptrThenNullptrIsReturned) {
     EXPECT_EQ(nullptr, ret);
 }
 
+TEST(TranslateTest, givenNullPtrAsGtPinInputWhenTranslatorReturnsNullptrThenNullptrIsReturned) {
+    TranslationCtxMock mockTranslationCtx;
+    mockTranslationCtx.returnNullptr = true;
+    auto mockCifBuffer = std::make_unique<MockCIFBuffer>();
+
+    auto ret = OCLRT::translate(&mockTranslationCtx, mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), nullptr);
+    EXPECT_EQ(nullptr, ret);
+}
+
 TEST(TranslateTest, whenTranslatorReturnsInvalidOutputThenNullptrIsReturned) {
     TranslationCtxMock mockTranslationCtx;
     auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
@@ -615,6 +631,18 @@ TEST(TranslateTest, whenTranslatorReturnsInvalidOutputThenNullptrIsReturned) {
     }
 }
 
+TEST(TranslateTest, givenNullPtrAsGtPinInputWhenTranslatorReturnsInvalidOutputThenNullptrIsReturned) {
+    TranslationCtxMock mockTranslationCtx;
+    auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());
+    for (uint32_t i = 1; i <= (1 << 3) - 1; ++i) {
+        mockTranslationCtx.returnNullptrDebugData = (i & 1) != 0;
+        mockTranslationCtx.returnNullptrLog = (i & (1 << 1)) != 0;
+        mockTranslationCtx.returnNullptrOutput = (i & (1 << 2)) != 0;
+        auto ret = OCLRT::translate(&mockTranslationCtx, mockCifBuffer.get(), mockCifBuffer.get(), mockCifBuffer.get(), nullptr);
+        EXPECT_EQ(nullptr, ret);
+    }
+}
+
 TEST(TranslateTest, whenAnyArgIsNullThenNullptrIsReturnedAndTranslatorIsNotInvoked) {
     TranslationCtxMock mockTranslationCtx;
     auto mockCifBuffer = CIF::RAII::UPtr_t<MockCIFBuffer>(new MockCIFBuffer());

unit_tests/gtpin/gtpin_tests.cpp

@@ -44,6 +44,7 @@
 #include "unit_tests/mocks/mock_context.h"
 #include "unit_tests/mocks/mock_device.h"
 #include "unit_tests/mocks/mock_kernel.h"
+#include "unit_tests/program/program_tests.h"
 #include "test.h"
 #include "gtest/gtest.h"
 #include <deque>
@@ -75,6 +76,7 @@ void OnContextCreate(context_handle_t context, platform_info_t *platformInfo, ig
     currContext = context;
     kernelResources.clear();
     ContextCreateCallbackCount++;
+    *igcInit = reinterpret_cast<igc_init_t *>(0x1234);
 }
 
 void OnContextDestroy(context_handle_t context) {
@@ -215,7 +217,9 @@ TEST_F(GTPinTests, givenInvalidArgumentsThenGTPinInitFails) {
 }
 
 TEST_F(GTPinTests, givenIncompleteArgumentsThenGTPinInitFails) {
-    uint32_t ver = 0;
+    interface_version_t ver;
+    ver.common = 0;
+    ver.specific = 0;
 
     retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, &ver);
     EXPECT_EQ(GTPIN_DI_ERROR_INVALID_ARGUMENT, retFromGtPin);
@@ -242,19 +246,24 @@ TEST_F(GTPinTests, givenIncompleteArgumentsThenGTPinInitFails) {
 }
 
 TEST_F(GTPinTests, givenInvalidArgumentsWhenVersionArgumentIsProvidedThenGTPinInitReturnsDriverVersion) {
-    uint32_t ver = 0;
+    interface_version_t ver;
+    ver.common = 0;
+    ver.specific = 0;
 
     retFromGtPin = GTPin_Init(nullptr, nullptr, &ver);
     EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
-    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver.specific);
+    EXPECT_EQ(gtpin::GTPIN_COMMON_INTERFACE_VERSION, ver.common);
 
     retFromGtPin = GTPin_Init(&gtpinCallbacks, nullptr, &ver);
     EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
-    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver.specific);
+    EXPECT_EQ(gtpin::GTPIN_COMMON_INTERFACE_VERSION, ver.common);
 
     retFromGtPin = GTPin_Init(nullptr, &driverServices, &ver);
     EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
-    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver.specific);
+    EXPECT_EQ(gtpin::GTPIN_COMMON_INTERFACE_VERSION, ver.common);
 }
 
 TEST_F(GTPinTests, givenValidAndCompleteArgumentsThenGTPinInitSucceeds) {
@@ -2272,4 +2281,73 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelSubitIsCalledThenCo
 
     kernelResources.clear();
 }
+TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnContextCreateIsCalledThenGtpinInitIsSet) {
+    gtpinCallbacks.onContextCreate = OnContextCreate;
+    gtpinCallbacks.onContextDestroy = OnContextDestroy;
+    gtpinCallbacks.onKernelCreate = OnKernelCreate;
+    gtpinCallbacks.onKernelSubmit = OnKernelSubmit;
+    gtpinCallbacks.onCommandBufferCreate = OnCommandBufferCreate;
+    gtpinCallbacks.onCommandBufferComplete = OnCommandBufferComplete;
+    retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, nullptr);
+    auto context = std::make_unique<MockContext>();
+    gtpinNotifyContextCreate(context.get());
+    EXPECT_NE(gtpinGetIgcInit(), nullptr);
+}
+
+TEST_F(ProgramTests, givenGenBinaryWithGtpinInfoWhenProcessGenBinaryCalledThenGtpinInfoIsSet) {
+    cl_int retVal = CL_INVALID_BINARY;
+    char genBin[1024] = {1, 2, 3, 4, 5, 6, 7, 8, 9, '\0'};
+    size_t binSize = 10;
+
+    std::unique_ptr<Program> pProgram(Program::createFromGenBinary(nullptr, &genBin[0], binSize, false, &retVal));
+    EXPECT_NE(nullptr, pProgram.get());
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ((uint32_t)CL_PROGRAM_BINARY_TYPE_EXECUTABLE, (uint32_t)pProgram->getProgramBinaryType());
+
+    cl_device_id deviceId = pContext->getDevice(0);
+    Device *pDevice = castToObject<Device>(deviceId);
+    char *pBin = &genBin[0];
+    retVal = CL_INVALID_BINARY;
+    binSize = 0;
+
+    // Prepare simple program binary containing patch token PATCH_TOKEN_GLOBAL_MEMORY_OBJECT_KERNEL_ARGUMENT
+    SProgramBinaryHeader *pBHdr = (SProgramBinaryHeader *)pBin;
+    pBHdr->Magic = iOpenCL::MAGIC_CL;
+    pBHdr->Version = iOpenCL::CURRENT_ICBE_VERSION;
+    pBHdr->Device = pDevice->getHardwareInfo().pPlatform->eRenderCoreFamily;
+    pBHdr->GPUPointerSizeInBytes = 8;
+    pBHdr->NumberOfKernels = 1;
+    pBHdr->SteppingId = 0;
+    pBHdr->PatchListSize = 0;
+    pBin += sizeof(SProgramBinaryHeader);
+    binSize += sizeof(SProgramBinaryHeader);
+
+    SKernelBinaryHeaderCommon *pKHdr = (SKernelBinaryHeaderCommon *)pBin;
+    pKHdr->CheckSum = 0;
+    pKHdr->ShaderHashCode = 0;
+    pKHdr->KernelNameSize = 8;
+    pKHdr->PatchListSize = 8;
+    pKHdr->KernelHeapSize = 0;
+    pKHdr->GeneralStateHeapSize = 0;
+    pKHdr->DynamicStateHeapSize = 0;
+    pKHdr->SurfaceStateHeapSize = 0;
+    pKHdr->KernelUnpaddedSize = 0;
+    pBin += sizeof(SKernelBinaryHeaderCommon);
+    binSize += sizeof(SKernelBinaryHeaderCommon);
+
+    strcpy(pBin, "TstCopy");
+    pBin += pKHdr->KernelNameSize;
+    binSize += pKHdr->KernelNameSize;
+
+    iOpenCL::SPatchItemHeader *pPatch = (iOpenCL::SPatchItemHeader *)pBin;
+    pPatch->Token = iOpenCL::PATCH_TOKEN_GTPIN_INFO;
+    pPatch->Size = sizeof(iOpenCL::SPatchItemHeader);
+    binSize += sizeof(iOpenCL::SPatchItemHeader);
+
+    // Decode prepared program binary
+    pProgram->storeGenBinary(&genBin[0], binSize);
+    retVal = pProgram->processGenBinary();
+    EXPECT_NE(gtpinGetIgcInfo(), nullptr);
+    ASSERT_EQ(CL_SUCCESS, retVal);
+}
 } // namespace ULT

unit_tests/mocks/mock_compilers.cpp

@@ -474,6 +474,19 @@ IGC::OclTranslationOutputBase *MockIgcOclTranslationCtx::TranslateImpl(
     return out;
 }
 
+IGC::OclTranslationOutputBase *MockIgcOclTranslationCtx::TranslateImpl(
+    CIF::Version_t outVersion,
+    CIF::Builtins::BufferSimple *src,
+    CIF::Builtins::BufferSimple *options,
+    CIF::Builtins::BufferSimple *internalOptions,
+    CIF::Builtins::BufferSimple *tracingOptions,
+    uint32_t tracingOptionsCount,
+    void *gtpinInput) {
+    auto out = new MockOclTranslationOutput();
+    translate(true, src, options, internalOptions, out);
+    return out;
+}
+
 MockOclTranslationOutput::MockOclTranslationOutput() {
     this->log = new MockCIFBuffer();
     this->output = new MockCIFBuffer();

unit_tests/mocks/mock_compilers.h

@@ -141,6 +141,15 @@ struct MockIgcOclTranslationCtx : MockCIF<IGC::IgcOclTranslationCtxTagOCL> {
         CIF::Builtins::BufferSimple *internalOptions,
         CIF::Builtins::BufferSimple *tracingOptions,
         uint32_t tracingOptionsCount) override;
+
+    IGC::OclTranslationOutputBase *TranslateImpl(
+        CIF::Version_t outVersion,
+        CIF::Builtins::BufferSimple *src,
+        CIF::Builtins::BufferSimple *options,
+        CIF::Builtins::BufferSimple *internalOptions,
+        CIF::Builtins::BufferSimple *tracingOptions,
+        uint32_t tracingOptionsCount,
+        void *gtpinInput) override;
 };
 
 struct MockOclTranslationOutput : MockCIF<IGC::OclTranslationOutputTagOCL> {