Introduced oneprof tool, minor fixes

Author: anton-v-gorshkov

README.md

@@ -47,6 +47,7 @@ You may obtain a copy of the License at https://opensource.org/licenses/MIT
 
 ## Profiling & Debug Tools
  - [onetrace](tools/onetrace) - host and device tracing tool for OpenCL(TM) and Level Zero backends with support of DPC++ (both for CPU and GPU) and OpenMP* GPU offload;
+ - [oneprof](tools/oneprof) - GPU HW metrics collection tool for OpenCL(TM) and Level Zero backends with support of DPC++ and OpenMP* GPU offload;
  - [ze_tracer](tools/ze_tracer) - "Swiss army knife" for Level Zero API call tracing and profiling (former ze_intercept);
  - [cl_tracer](tools/cl_tracer) - "Swiss army knife" for OpenCL(TM) API call tracing and profiling;
  - [gpuinfo](tools/gpuinfo) - provides basic information about the GPUs installed in a system, and the list of HW metrics one can collect for it;

VERSION

@@ -1 +1 @@
-0.34.1
+0.35.0

chapters/device_activity_tracing/LevelZero.md

@@ -112,4 +112,5 @@ Event pool profiling does not require any additional environment variables to be
 
 ## Tools
 - [Level Zero Tracer](../../tools/ze_tracer)
-- [Tracing and Profiling Tool for Data Parallel C++ (DPC++)](../../tools/onetrace)
+- [Tracing and Profiling Tool for Data Parallel C++ (DPC++)](../../tools/onetrace)
+- [GPU Metrics Collection Tool for Data Parallel C++ (DPC++)](../../tools/oneprof)

chapters/metrics_collection/LevelZero.md

@@ -304,4 +304,7 @@ ZET_ENABLE_METRICS=1 ./<application>
 ## Samples
 - [Level Zero Metric Info](../../samples/ze_metric_info)
 - [Level Zero Metric Query](../../samples/ze_metric_query)
-- [Level Zero Metric Streamer](../../samples/ze_metric_streamer)
+- [Level Zero Metric Streamer](../../samples/ze_metric_streamer)
+
+## Tools
+- [GPU Metrics Collection Tool for Data Parallel C++ (DPC++)](../../tools/oneprof)

chapters/runtime_api_tracing/LevelZero.md

@@ -101,4 +101,5 @@ ZE_ENABLE_TRACING_LAYER=1 ./<application>
 
 ## Tools
 - [Level Zero Tracer](../../tools/ze_tracer)
-- [Tracing and Profiling Tool for Data Parallel C++ (DPC++)](../../tools/onetrace)
+- [Tracing and Profiling Tool for Data Parallel C++ (DPC++)](../../tools/onetrace)
+- [GPU Metrics Collection Tool for Data Parallel C++ (DPC++)](../../tools/oneprof)

loader/loader.cc

@@ -110,6 +110,8 @@ int main(int argc, char* argv[]) {
     return 0;
   }
 
+  set_tool_env();
+
   int app_index = parse_args(argc, argv);
   if (app_index <= 0 || app_index >= argc) {
     if (app_index >= argc) {
@@ -129,8 +131,6 @@ int main(int argc, char* argv[]) {
   }
   app_args.push_back(nullptr);
 
-  set_tool_env();
-
 #if defined(_WIN32)
 
   BOOL ok = FALSE;

samples/ze_gemm/main.cc

@@ -178,9 +178,8 @@ static float RunAndCheck(ze_kernel_handle_t kernel,
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   double time = static_cast<double>(
-      (timestamp.global.kernelEnd - timestamp.global.kernelStart) *
-      props.timerResolution);
-  time /= NSEC_IN_SEC;
+      timestamp.global.kernelEnd - timestamp.global.kernelStart) /
+      props.timerResolution;
   std::cout << "Matrix multiplication time: " << time <<
     " sec" << std::endl;
 
@@ -238,6 +237,9 @@ static void Compute(ze_device_handle_t device,
 }
 
 int main(int argc, char* argv[]) {
+  utils::SetEnv("NEOReadDebugKeys", "1");
+  utils::SetEnv("UseCyclesPerSecondTimer", "1");
+
   ze_result_t status = ZE_RESULT_SUCCESS;
   status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);

samples/ze_metric_info/main.cc

@@ -10,48 +10,6 @@
 #include "utils.h"
 #include "ze_utils.h"
 
-static std::string GetResultType(zet_value_type_t type) {
-  switch (type) {
-    case ZET_VALUE_TYPE_UINT32:
-      return "UINT32";
-    case ZET_VALUE_TYPE_UINT64:
-      return "UINT64";
-    case ZET_VALUE_TYPE_FLOAT32:
-      return "FLOAT32";
-    case ZET_VALUE_TYPE_FLOAT64:
-      return "FLOAT64";
-    case ZET_VALUE_TYPE_BOOL8:
-      return "BOOL8";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-static std::string GetMetricType(zet_metric_type_t type) {
-  switch (type) {
-    case ZET_METRIC_TYPE_DURATION:
-      return "DURATION";
-    case ZET_METRIC_TYPE_EVENT:
-      return "EVENT";
-    case ZET_METRIC_TYPE_EVENT_WITH_RANGE:
-      return "EVENT_WITH_RANGE";
-    case ZET_METRIC_TYPE_THROUGHPUT:
-      return "THROUGHPUT";
-    case ZET_METRIC_TYPE_TIMESTAMP:
-      return "TIMESTAMP";
-    case ZET_METRIC_TYPE_FLAG:
-      return "FLAG";
-    case ZET_METRIC_TYPE_RATIO:
-      return "RATIO";
-    case ZET_METRIC_TYPE_RAW:
-      return "RAW";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
 static void PrintMetricsInfo(ze_device_handle_t device) {
   PTI_ASSERT(device != nullptr);
   ze_result_t status = ZE_RESULT_SUCCESS;
@@ -109,8 +67,8 @@ static void PrintMetricsInfo(ze_device_handle_t device) {
       std::cout << "\tMetric " << mid << ": D" << group_props.domain <<
         " / " << sampling_type << " / " << group_props.name << " / " <<
         metric_props.name << " (" << metric_props.description << ") [" <<
-        GetResultType(metric_props.resultType) << ", " <<
-        GetMetricType(metric_props.metricType) << "]" << std::endl;
+        utils::ze::GetResultType(metric_props.resultType) << ", " <<
+        utils::ze::GetMetricType(metric_props.metricType) << "]" << std::endl;
     }
   }
 }

samples/ze_metric_streamer/CMakeLists.txt

@@ -27,6 +27,9 @@ endif()
 FindL0Library(zet_metric_streamer)
 FindL0Headers(zet_metric_streamer)
 
+CheckForMDLibrary(oneprof_tool)
+CheckForMetricsLibrary(oneprof_tool)
+
 # Loader
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTOOL_NAME=zet_metric_streamer")

samples/ze_metric_streamer/ze_metric_collector.h

@@ -220,7 +220,8 @@ class ZeMetricCollector {
     PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
     ze_event_pool_desc_t event_pool_desc = {
-        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr, 0, 1};
+        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
+        ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
     ze_event_pool_handle_t event_pool = nullptr;
     status = zeEventPoolCreate(collector->context_, &event_pool_desc,
                                0, nullptr, &event_pool);

tests/run.py

@@ -52,7 +52,9 @@
           "--chrome-device-timeline",
           "--chrome-kernel-timeline",
           "--chrome-device-stages",
-          "dpc", "omp"]]
+          "dpc", "omp"],
+        ["oneprof",
+         "-i", "-m", "-k", "-a", "cl", "ze", "omp"]]
 
 def remove_python_cache(path):
   files = os.listdir(path)

tests/tools/oneprof.py

@@ -0,0 +1,100 @@
+import os
+import subprocess
+import sys
+
+from samples import cl_gemm
+from samples import dpc_gemm
+from samples import omp_gemm
+from samples import ze_gemm
+import utils
+
+def config(path):
+  p = subprocess.Popen(["cmake",\
+    "-DCMAKE_BUILD_TYPE=" + utils.get_build_flag(), ".."],\
+    cwd = path, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  p.wait()
+  stdout, stderr = utils.run_process(p)
+  if stderr and stderr.find("CMake Error") != -1:
+    return stderr
+  return None
+
+def build(path):
+  p = subprocess.Popen(["make"], cwd = path,\
+    stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  p.wait()
+  stdout, stderr = utils.run_process(p)
+  if stderr and stderr.lower().find("error") != -1:
+    return stderr
+  return None
+
+def run(path, option):
+  if option == "cl":
+    app_folder = utils.get_sample_build_path("cl_gemm")
+    app_file = os.path.join(app_folder, "cl_gemm")
+    p = subprocess.Popen(["./oneprof", "-k", "-a", app_file, "gpu", "1024", "1"],\
+      cwd = path, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  elif option == "ze":
+    app_folder = utils.get_sample_build_path("ze_gemm")
+    app_file = os.path.join(app_folder, "ze_gemm")
+    p = subprocess.Popen(["./oneprof", "-k", "-a", app_file, "1024", "1"],\
+      cwd = path, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  elif option == "omp":
+    app_folder = utils.get_sample_build_path("omp_gemm")
+    app_file = os.path.join(app_folder, "omp_gemm")
+    p = subprocess.Popen(["./oneprof", "-k", "-a", app_file, "gpu", "1024", "1"],\
+      cwd = path, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  else:
+    app_folder = utils.get_sample_build_path("dpc_gemm")
+    app_file = os.path.join(app_folder, "dpc_gemm")
+    p = subprocess.Popen(["./oneprof", option, app_file, "gpu", "1024", "1"],\
+      cwd = path, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+  stdout, stderr = utils.run_process(p)
+  if not stdout:
+    return "stdout is empty"
+  if not stderr:
+    return "stderr is empty"
+  if stdout.find(" CORRECT") == -1:
+    return stdout
+  if stderr.find("WARNING") != -1:
+    return stderr
+  return None
+
+def main(option):
+  path = utils.get_tool_build_path("oneprof")
+  if option == "cl":
+    log = cl_gemm.main("gpu")
+  elif option == "ze":
+    log = ze_gemm.main(None)
+  elif option == "omp":
+    log = omp_gemm.main("gpu")
+  else:
+    log = dpc_gemm.main("gpu")
+  if log:
+    return log
+  log = config(path)
+  if log:
+    return log
+  log = build(path)
+  if log:
+    return log
+  log = run(path, option)
+  if log:
+    return log
+
+if __name__ == "__main__":
+  option = "-m"
+  if len(sys.argv) > 1 and sys.argv[1] == "-i":
+    option = "-i"
+  if len(sys.argv) > 1 and sys.argv[1] == "-k":
+    option = "-k"
+  if len(sys.argv) > 1 and sys.argv[1] == "-a":
+    option = "-a"
+  if len(sys.argv) > 1 and sys.argv[1] == "cl":
+    option = "cl"
+  if len(sys.argv) > 1 and sys.argv[1] == "ze":
+    option = "ze"
+  if len(sys.argv) > 1 and sys.argv[1] == "omp":
+    option = "omp"
+  log = main(option)
+  if log:
+    print(log)

tools/cl_tracer/cl_tracer.h

@@ -36,6 +36,7 @@ class ClTracer {
     }
 
     ClTracer* tracer = new ClTracer(options);
+    PTI_ASSERT(tracer != nullptr);
 
     if (tracer->CheckOption(TRACE_DEVICE_TIMING) ||
         tracer->CheckOption(TRACE_DEVICE_TIMING_VERBOSE) ||

tools/oneprof/CMakeLists.txt

@@ -0,0 +1,50 @@
+include("../../build_utils/CMakeLists.txt")
+SetRequiredCMakeVersion()
+cmake_minimum_required(VERSION ${REQUIRED_CMAKE_VERSION})
+
+project(PTI_Tools_OneProf CXX)
+SetCompilerFlags()
+SetBuildType()
+
+# Tool Library
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPTI_KERNEL_INTERVALS=1")
+add_library(oneprof_tool SHARED
+  "${PROJECT_SOURCE_DIR}/../../loader/init.cc"
+  "${PROJECT_SOURCE_DIR}/../utils/correlator.cc"
+  tool.cc)
+target_include_directories(oneprof_tool
+  PRIVATE "${PROJECT_SOURCE_DIR}"
+  PRIVATE "${PROJECT_SOURCE_DIR}/../ze_tracer"
+  PRIVATE "${PROJECT_SOURCE_DIR}/../utils"
+  PRIVATE "${PROJECT_SOURCE_DIR}/../../utils")
+if(CMAKE_INCLUDE_PATH)
+  target_include_directories(oneprof_tool
+    PUBLIC "${CMAKE_INCLUDE_PATH}")
+endif()
+
+#FindOpenCLLibrary(oneprof_tool)
+#FindOpenCLHeaders(oneprof_tool)
+
+#GetOpenCLTracingHeaders(oneprof_tool)
+
+FindL0Library(oneprof_tool)
+FindL0Headers(oneprof_tool)
+
+CheckForMDLibrary(oneprof_tool)
+CheckForMetricsLibrary(oneprof_tool)
+
+# Loader
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTOOL_NAME=oneprof_tool")
+add_executable(oneprof "${PROJECT_SOURCE_DIR}/../../loader/loader.cc")
+target_include_directories(oneprof
+  PRIVATE "${PROJECT_SOURCE_DIR}/../../utils")
+if(UNIX)
+  target_link_libraries(oneprof
+    dl)
+endif()
+
+# Installation
+
+install(TARGETS oneprof oneprof_tool DESTINATION bin)