GTPin v3 gpu_inst_count tool update

 * Updated GTPin download and unpack script
 * Rewritten instruction count tool with GTPin v3 
 * Tests were enabled. Tests were not changed for this tool, Passrate 3/3

Author: idubinov

.github/workflows/sdk_build_and_test.yml

@@ -93,3 +93,8 @@ jobs:
         if: always()
         run: |
           python ./tests/run.py -s cl_gpu_metrics
+
+      - name: Build-and-test-gpu-inst-count
+        if: always()
+        run: |
+          python ./tests/run.py -s gpu_inst_count

VERSION

@@ -1 +1 @@
-0.49.16
+0.49.17

build_utils/CMakeLists.txt

@@ -423,9 +423,7 @@ macro(FindGTPinLibrary_legacy TARGET)
                         DEPENDS ${GTPIN_LIB_PATH}/GTPIN/libgcc_s.so.1
                                 ${GTPIN_LIB_PATH}/GTPIN/libged.so
                                 ${GTPIN_LIB_PATH}/GTPIN/libgtpin.so
-                                ${GTPIN_LIB_PATH}/GTPIN/libgtpin_core.so
-                                ${GTPIN_LIB_PATH}/GTPIN/libiga_wrapper.so
-                                ${GTPIN_LIB_PATH}/GTPIN/libstdc++.so.6)
+                                ${GTPIN_LIB_PATH}/GTPIN/libgtpin_core.so)
       add_custom_command(OUTPUT ${GTPIN_LIB_PATH}/GTPIN/libgcc_s.so.1
                                 ${GTPIN_LIB_PATH}/GTPIN/libged.so
                                 ${GTPIN_LIB_PATH}/GTPIN/libgtpin.so
@@ -542,13 +540,27 @@ macro(GetGTPinPackage TARGET)
       endif()
     endif()
     include(FetchContent)
-    FetchContent_Declare(
-      gtpin_package
-      URL ${GTPIN_LINK}
-    )
+    if(${CMAKE_VERSION} VERSION_LESS "3.24.0")
+      FetchContent_Declare(
+        gtpin_package
+        URL ${GTPIN_LINK}
+      )
+    else()
+      FetchContent_Declare(
+        gtpin_package
+        URL ${GTPIN_LINK}
+        DOWNLOAD_EXTRACT_TIMESTAMP YES
+      )
+    endif()
     message(STATUS "Download GTPin package link: ${GTPIN_LINK}")
     FetchContent_MakeAvailable(gtpin_package)
-    set(GTPIN_PATH ${gtpin_package_SOURCE_DIR})
+    if(UNIX)
+      set(GTPIN_PATH ${gtpin_package_SOURCE_DIR})
+    elseif(WIN32)
+      set(GTPIN_PATH ${gtpin_package_SOURCE_DIR}/Profilers)
+    else()
+      message(FATAL_ERROR "Graphics Technology Pin (GT Pin) is not supported for the platform")
+    endif()
     message(STATUS "GTPin Technology Pin (GT Pin) unpacked: ${GTPIN_PATH}")
   else()
     if(NOT IS_ABSOLUTE ${GTPIN_PATH})

build_utils/get_gtpin_headers_legacy.py

@@ -75,4 +75,4 @@ def main():
      "gt_basic_utils.h"])
 
 if __name__ == "__main__":
-  main()
+  main()

build_utils/get_gtpin_libs_legacy.py

@@ -51,4 +51,4 @@ def main():
     build_utils.copy(src_path, build_path, gtpin_dlls)
 
 if __name__ == "__main__":
-  main()
+  main()

samples/gpu_inst_count/CMakeLists.txt

@@ -7,28 +7,34 @@ SetCompilerFlags()
 SetBuildType()
 
 # Tool Library
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-add_library(gput_inst_count SHARED "${PROJECT_SOURCE_DIR}/../../loader/init.cc" tool.cc)
+add_library(gput_inst_count SHARED 
+  "${PROJECT_SOURCE_DIR}/tool.cc"
+  "${PROJECT_SOURCE_DIR}/../../loader/init.cc"
+  "${PROJECT_SOURCE_DIR}/gpu_inst_count.cc"
+  )
 target_include_directories(gput_inst_count
   PRIVATE "${PROJECT_SOURCE_DIR}/../../utils")
 if(CMAKE_INCLUDE_PATH)
   target_include_directories(gput_inst_count
     PUBLIC "${CMAKE_INCLUDE_PATH}")
 endif()
 
-FindIGALibrary(gput_inst_count)
-GetIGAHeaders(gput_inst_count)
+add_subdirectory(gtpin_dev_kit)
+FindGTPinDevKitHeaders(gput_inst_count)
+target_link_libraries(gput_inst_count gtpin_dev_kit)
 
-FindGTPinLibrary_legacy(gput_inst_count)
-GetGTPinHeaders_legacy(gput_inst_count)
+FindGTPinLibrary(gput_inst_count)
+FindGTPinHeaders(gput_inst_count)
+FindGTPinUtils(gput_inst_count)
 
 # Loader
-
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTOOL_NAME=gput_inst_count")
 add_executable(gpu_inst_count "${PROJECT_SOURCE_DIR}/../../loader/loader.cc")
 target_include_directories(gpu_inst_count
   PRIVATE "${PROJECT_SOURCE_DIR}/../../utils")
 if(UNIX)
   target_link_libraries(gpu_inst_count
     dl)
-endif()
+endif()

samples/gpu_inst_count/README.md

@@ -1,9 +1,12 @@
 # GPU Instruction Count
+
 ## Overview
+
 This sample is a simple LD_PRELOAD based tool that allows to collect dynamic execution count for every OpenCL(TM) kernel instruction.
 
 As a result, assembly listing annotated with dynamic instruction count for each kernel will be printed.
-```
+
+```console
 === GEMM (runs 4 times) ===
 [     32768] 0x0000: (W)      mov (8|M0)               r5.0<1>:ud    r0.0<1;1,0>:ud
 [     32768] 0x0010: (W)      or (1|M0)                cr0.0<1>:ud   cr0.0<0;1,0>:ud   0x4C0:uw         {Switch}
@@ -72,62 +75,88 @@ As a result, assembly listing annotated with dynamic instruction count for each
 [     32768] 0x0398:          illegal
 [     32768] 0x03A8:          illegal
 ```
+
 ## Supported OS
+
 - Linux
 - Windows (*under development*)
 
 ## Prerequisites
+
 - [CMake](https://cmake.org/) (version 3.12 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Graphics Technology Pin (GT Pin)](https://software.intel.com/content/www/us/en/develop/articles/gtpin.html)
 
 ## Build and Run
+
 ### Linux
+
 Run the following commands to build the sample:
+
 ```sh
 cd <pti>/samples/gpu_inst_count
 mkdir build
 cd build
 cmake -DCMAKE_BUILD_TYPE=Release [-DGTPIN_PATH=<gtpin>/Profilers] ..
 make
 ```
+
 Use this command line to run the tool:
+
 ```sh
 ./gpu_inst_count <target_application>
 ```
+
 One may use [cl_gemm](../cl_gemm), [ze_gemm](../ze_gemm) or [dpc_gemm](../dpc_gemm) as target application:
+
 ```sh
 ./gpu_inst_count ../../cl_gemm/build/cl_gemm
 ./gpu_inst_count ../../ze_gemm/build/ze_gemm
 ./gpu_inst_count ../../dpc_gemm/build/dpc_gemm
 ```
+
 ### Windows
+
 Use Microsoft* Visual Studio x64 command prompt to run the following commands and build the sample:
+
 ```sh
 cd <pti>\samples\gpu_inst_count
 mkdir build
 cd build
-cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DGTPIN_PATH=<gtpin>\Profilers -DCMAKE_LIBRARY_PATH=<iga_lib_path> ..
+cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release ..
 nmake
 ```
+
 Use this command line to run the tool:
+
 ```sh
 set PATH=%PATH%;<gtpin>\Profilers\Lib\intel64
 gpu_inst_count.exe <target_application>
 ```
+
+CMake unpacks GTPin into "_deps\gtpin_package-src\Profilers":
+
+```sh
+set PATH=%PATH%;_deps\gtpin_package-src\Profilers\Lib\intel64
+gpu_inst_count.exe <target_application>
+```
+
 One may use [cl_gemm](../cl_gemm), [ze_gemm](../ze_gemm) or [dpc_gemm](../dpc_gemm) as target application:
+
 ```sh
 set PATH=%PATH%;<gtpin>\Profilers\Lib\intel64
 gpu_inst_count.exe ..\..\cl_gemm\build\cl_gemm.exe
 gpu_inst_count.exe ..\..\ze_gemm\build\ze_gemm.exe
 gpu_inst_count.exe ..\..\dpc_gemm\build\dpc_gemm.exe
 ```
-**Note**: to build this sample one may need to generate *.lib file from IGA *.dll (see [here](https://stackoverflow.com/questions/9946322/how-to-generate-an-import-library-lib-file-from-a-dll) for details) and provide the path to this *.lib to cmake with `-DCMAKE_LIBRARY_PATH`.
+
+**Note**: to build this sample one may need to generate \*.lib file from IGA \*.dll (see [here](https://stackoverflow.com/questions/9946322/how-to-generate-an-import-library-lib-file-from-a-dll) for details) and provide the path to this \*.lib to cmake with `-DCMAKE_LIBRARY_PATH`.
 
 Also one may need to add an actual path to IGA *.dll into PATH before sample run, e.g.:
-```
+
+```sh
 set PATH=%PATH%;<gtpin>\Profilers\Lib\intel64
 set PATH=%PATH%;<iga_dll_path>
 gpu_inst_count.exe ..\..\cl_gemm\build\cl_gemm.exe
-```
+```

samples/gpu_inst_count/gpu_inst_count.cc

@@ -0,0 +1,132 @@
+
+#include "gpu_inst_count.hpp"
+
+using namespace gtpin_prof;
+using namespace gtpin;
+
+/********************
+ * Requered functions - should be implemented
+ */
+
+PROF_STATUS GpuInstCountKernel::Accumulate(std::shared_ptr<ResultData> profilingResult,
+                                           GTPinProfileRecord* record) {
+  auto gpuInstCountRec = reinterpret_cast<GpuInstCountRecord*>(record);
+  auto gpuInstCountResult = std::dynamic_pointer_cast<GpuInstCountResultData>(profilingResult);
+
+  /// Accumulate data from GpuInstCountRec to GpuInstCountResult here.
+  /// For each profiling results may be several records, data should be
+  /// accumulated, not just transferred
+  gpuInstCountResult->count += gpuInstCountRec->count;
+
+  return PROF_STATUS_SUCCESS;
+}
+
+PROF_STATUS GpuInstCountKernel::AnalyzeKernel(IGtKernelInstrument& instrumentor) {
+  const IGtKernel& kernel = instrumentor.Kernel();
+  const IGtCfg& cfg = instrumentor.Cfg();
+  const IGtGenArch& genArch = GTPin_GetCore()->GenArch();
+
+  SetRecordSize(sizeof(GpuInstCountRecord));
+  SetDefautBuckets(instrumentor);
+
+  for (auto bblPtr : cfg.Bbls()) {
+    for (auto insPtr : bblPtr->Instructions()) {
+      const IGtIns& ins = *insPtr;
+      const InstructionOffset offset = cfg.GetInstructionOffset(ins);
+
+      bblData.emplace(offset, bblPtr->FirstIns());
+    }
+  }
+  /// Set number of records and store required data based on information from
+  /// instrumentor
+  SetRecordsNum(bblData.size());
+
+  return PROF_STATUS_SUCCESS;
+}
+
+PROF_STATUS GpuInstCountKernel::Instrument(IGtKernelInstrument& instrumentor) {
+  const IGtKernel& kernel = instrumentor.Kernel();
+  const IGtCfg& cfg = instrumentor.Cfg();
+  const IGtGenCoder& coder = instrumentor.Coder();
+  IGtVregFactory& vregs = coder.VregFactory();
+  IGtInsFactory& insF = coder.InstructionFactory();
+
+  const IGtGenArch& genArch = GTPin_GetCore()->GenArch();
+  uint32_t grfRegSize = insF.GenModel().GrfRegSize();  // bytes
+
+  GtGenProcedure proc;
+
+  size_t bblIdx = 0;
+  for (auto it = bblData.begin(); it != bblData.end(); it++, bblIdx++) {
+    GtGenProcedure proc;
+    PointOfInterest poi(instrumentor, m_profileArray, bblIdx);
+    poi.InstructionCounterAnalysis(offsetof(GpuInstCountRecord, count));
+    poi.ClosePOI(proc);
+    instrumentor.InstrumentInstruction(it->second, GtIpoint::Before(), proc);
+  }
+
+  return PROF_STATUS_SUCCESS;
+}
+
+/********************
+ * Optional functions - may be changed or not, base on tool behaviour
+ */
+
+PROF_STATUS GpuInstCountKernel::InitResultData(std::shared_ptr<InvocationData> invocationData,
+                                               IGtKernelDispatch& dispatcher,
+                                               const GTPinKernelExecDesriptor& execDescr,
+                                               const std::shared_ptr<IToolFactory> factory) {
+  auto invData = std::dynamic_pointer_cast<GpuInstCountInvocationData>(invocationData);
+  PTI_ASSERT((invData != nullptr) && "Invocation data was wrongly initialized. Check factory.");
+
+  size_t idx = 0;
+  for (auto it = bblData.begin(); it != bblData.end(); it++, idx++) {
+    auto resData = factory->MakeResultData();
+    auto gpuInstCountResult = std::dynamic_pointer_cast<GpuInstCountResultData>(resData);
+    gpuInstCountResult->instructionOffset = it->first;
+    invData->data.push_back(gpuInstCountResult);
+  }
+
+  return PROF_STATUS_SUCCESS;
+};
+
+PROF_STATUS GpuInstCountKernel::PostProcData(std::shared_ptr<InvocationData> invocationData) {
+  return PROF_STATUS_SUCCESS;
+}
+
+/**
+ * GpuInstCount implementations
+ */
+std::vector<const char*> GpuInstCount::SetGtpinKnobs() const {
+  return std::vector<const char*>{"--no_empty_profile_dir"};
+};
+
+/**
+ * GpuInstCountFactory implementations
+ */
+std::shared_ptr<GTPinProfileKernel> GpuInstCountFactory::MakeKernel(
+    IGtKernelInstrument& instrumentor, std::shared_ptr<KernelData> kernelData) {
+  return std::make_shared<GpuInstCountKernel>(instrumentor, kernelData);
+}
+
+GTPinProfileRecord* GpuInstCountFactory::MakeRecord() {
+  GpuInstCountRecord* rec = new GpuInstCountRecord();
+  return rec;
+};
+
+std::shared_ptr<ProfilerData> GpuInstCountFactory::MakeProfilerData() {
+  return std::make_shared<GpuInstCountProfilerData>();
+};
+
+std::shared_ptr<KernelData> GpuInstCountFactory::MakeKernelData(IGtKernelInstrument& instrumentor) {
+  return std::make_shared<GpuInstCountKernelData>(instrumentor);
+};
+
+std::shared_ptr<InvocationData> GpuInstCountFactory::MakeInvocationData(
+    const GTPinKernelExecDesriptor& execDescr) {
+  return std::make_shared<GpuInstCountInvocationData>(execDescr);
+};
+
+std::shared_ptr<ResultData> GpuInstCountFactory::MakeResultData() {
+  return std::make_shared<GpuInstCountResultData>();
+};