Revert "Pass info betwean gtpin and igc"

This reverts commit 5654d5673fbff18b1f3c81a8eb3c8dfeb9add9e1.

Change-Id: I2df912fef15755b2e5bd11d3e18e595d71bfad98

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(), inputArgs.GTPinInput);
+                                       fclOptions.get(), fclInternalOptions.get());
 
             if (igcOutput == nullptr) {
                 return CL_OUT_OF_HOST_MEMORY;

runtime/compiler_interface/compiler_interface.inl

@@ -49,24 +49,6 @@ 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,15 +55,4 @@ 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,7 +34,6 @@
 #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>
@@ -45,8 +44,7 @@ namespace OCLRT {
 
 extern gtpin::ocl::gtpin_events_t GTPinCallbacks;
 
-igc_init_t *pIgcInit = nullptr;
+igc_init_t *pIgcInfo = nullptr;
-const igc_info_t *pIgcInfo = nullptr;
 std::atomic<int> sequenceCount(1);
 CommandQueue *pCmdQueueForFlushTask = nullptr;
 std::deque<gtpinkexec_t> kernelExecQueue;
@@ -61,7 +59,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, &pIgcInit);
+        (*GTPinCallbacks.onContextCreate)((context_handle_t)context, &gtpinPlatformInfo, &pIgcInfo);
     }
 }
 
@@ -92,8 +90,7 @@ 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();
@@ -102,9 +99,7 @@ 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 = pIgcInfo;
+        paramsIn.igc_info = nullptr;
-        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
@@ -250,15 +245,4 @@ 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,14 +36,13 @@ gtpin::ocl::gtpin_events_t GTPinCallbacks = {0};
 } // namespace OCLRT
 
 GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, driver_services_t *pDriverServices,
-                           interface_version_t *pDriverVersion) {
+                           uint32_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->common = gtpin::GTPIN_COMMON_INTERFACE_VERSION;
+        *pDriverVersion = gtpin::ocl::GTPIN_OCL_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, gtpin::interface_version_t *pDriverVersion);
+gtpin::GTPIN_DI_STATUS GTPin_Init(gtpin::ocl::gtpin_events_t *pGtpinEvents, gtpin::driver_services_t *pDriverServices, uint32_t *pDriverVersion);
 
 #ifdef __cplusplus
 }

runtime/gtpin/gtpin_notify.h

@@ -36,7 +36,4 @@ 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,7 +26,6 @@
 #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>
 
@@ -119,7 +118,6 @@ 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,7 +31,6 @@
 #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>
 
@@ -779,13 +778,7 @@ 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,14 +246,6 @@ 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

@@ -571,13 +571,6 @@ 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,15 +596,6 @@ 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());
@@ -624,18 +608,6 @@ 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,7 +44,6 @@
 #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>
@@ -76,7 +75,6 @@ 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) {
@@ -217,9 +215,7 @@ TEST_F(GTPinTests, givenInvalidArgumentsThenGTPinInitFails) {
 }
 
 TEST_F(GTPinTests, givenIncompleteArgumentsThenGTPinInitFails) {
-    interface_version_t ver;
+    uint32_t ver = 0;
-    ver.common = 0;
-    ver.specific = 0;
 
     retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, &ver);
     EXPECT_EQ(GTPIN_DI_ERROR_INVALID_ARGUMENT, retFromGtPin);
@@ -246,24 +242,19 @@ TEST_F(GTPinTests, givenIncompleteArgumentsThenGTPinInitFails) {
 }
 
 TEST_F(GTPinTests, givenInvalidArgumentsWhenVersionArgumentIsProvidedThenGTPinInitReturnsDriverVersion) {
-    interface_version_t ver;
+    uint32_t ver = 0;
-    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.specific);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
-    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.specific);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
-    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.specific);
+    EXPECT_EQ(gtpin::ocl::GTPIN_OCL_INTERFACE_VERSION, ver);
-    EXPECT_EQ(gtpin::GTPIN_COMMON_INTERFACE_VERSION, ver.common);
 }
 
 TEST_F(GTPinTests, givenValidAndCompleteArgumentsThenGTPinInitSucceeds) {
@@ -2291,73 +2282,4 @@ 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

@@ -469,19 +469,6 @@ 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

@@ -139,15 +139,6 @@ 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> {