L0 Tracer - dynamic load API register functions at runtime. (#473)

Changed tracer to use L0 tracer register API rather then using
prolog/epilog set API for all functions (previously used only for
experimental APIs).

Load the register APIs dynamically at runtime and only register
callbacks for APIs that exist in running ze loader.

Changed Cmake to download L0 headers, regardless if exist on build system.

Co-authored-by: Guy Zadicario <[email protected]>

Author: gzadica1

build_utils/CMakeLists.txt

@@ -614,18 +614,21 @@ macro(GetLevelZeroHeaders TARGET)
   set(L0_INC_PATH "${CMAKE_BINARY_DIR}")
   RequirePythonInterp()
 
-  add_custom_target(level_zero_headers ALL
-                    DEPENDS ${L0_INC_PATH}/level_zero/ze_api.h
-                            ${L0_INC_PATH}/level_zero/zes_api.h
-                            ${L0_INC_PATH}/level_zero/zet_api.h
-                            ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
-                            ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h)
-  add_custom_command(OUTPUT ${L0_INC_PATH}/level_zero/ze_api.h
-                            ${L0_INC_PATH}/level_zero/zes_api.h
-                            ${L0_INC_PATH}/level_zero/zet_api.h
-                            ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
-                            ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h
-                    COMMAND "${PYTHON_EXECUTABLE}" "${PTI_CMAKE_MACRO_DIR}/get_ze_headers.py" ${L0_INC_PATH} ${CMAKE_BINARY_DIR})
+  if (NOT TARGET level_zero_headers)
+    add_custom_target(level_zero_headers ALL
+                      DEPENDS ${L0_INC_PATH}/level_zero/ze_api.h
+                              ${L0_INC_PATH}/level_zero/zes_api.h
+                              ${L0_INC_PATH}/level_zero/zet_api.h
+                              ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
+                              ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h)
+    add_custom_command(OUTPUT ${L0_INC_PATH}/level_zero/ze_api.h
+                              ${L0_INC_PATH}/level_zero/zes_api.h
+                              ${L0_INC_PATH}/level_zero/zet_api.h
+                              ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
+                              ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h
+                      COMMAND "${PYTHON_EXECUTABLE}" "${PTI_CMAKE_MACRO_DIR}/get_ze_headers.py" ${L0_INC_PATH} ${CMAKE_BINARY_DIR})
+  endif()
+
   target_include_directories(${TARGET}
     PUBLIC "${L0_INC_PATH}")
   add_dependencies(${TARGET}

tools/unitrace/CMakeLists.txt

@@ -50,6 +50,7 @@ macro(FindHeadersPath TARGET L0_GEN_SCRIPT GEN_FILE_NAME custom_target)
     PUBLIC "${L0_GEN_INC_PATH}")
   add_dependencies(${TARGET}
     ${custom_target})
+  add_dependencies(${custom_target} level_zero_headers) # level_zero_headers target added in GetLevelZeroHeaders macro
 endmacro()
 
 # Get Git Commit Hash
@@ -131,10 +132,11 @@ FindOpenCLHeaders(unitrace_tool)
 GetOpenCLTracingHeaders(unitrace_tool)
 
 FindL0Library(unitrace_tool)
-FindL0Headers(unitrace_tool)
+GetLevelZeroHeaders(unitrace_tool)
 
 FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_tracing_common_header.py" "common_header.gen" gen_common_header)
 FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_tracing_callbacks.py" "tracing.gen" gen_tracing_header)
+FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_l0_loader.py" "l0_loader.gen" gen_l0_loader_header)
 
 add_dependencies(gen_common_header
     cl_tracing_headers)
@@ -215,7 +217,7 @@ if(UNIX)
 endif()
 
 FindL0Library(unitrace)
-FindL0Headers(unitrace)
+GetLevelZeroHeaders(unitrace)
 GetGitCommitHash(unitrace "${PROJECT_SOURCE_DIR}/scripts/get_commit_hash.py" "unitrace_commit_hash.h" get_git_commit_hash_unitrace)
 GetGitCommitHash(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/get_commit_hash.py" "unitrace_tool_commit_hash.h" get_git_commit_hash_unitrace_tool)
 if(WIN32)

tools/unitrace/scripts/gen_l0_loader.py

@@ -0,0 +1,69 @@
+#==============================================================
+# Copyright (C) Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+# =============================================================
+
+import os
+import sys
+import re
+
+def get_func_list(f, func_list):
+  f.seek(0)
+  for line in f.readlines():
+    if line.find("ZE_APICALL") != -1 and line.find("ze_pfn") != -1:
+      items = line.split("ze_pfn")
+      assert len(items) == 2
+      assert items[1].find("Cb_t") != -1
+      items = items[1].split("Cb_t")
+      assert len(items) == 2
+      func_list.append("ze" + items[0].strip())
+
+def gen_loader(f, func_list):
+  f.write("public:\n");
+  for func in func_list:
+    reg_fname = "zelTracer" + func[2:] + "RegisterCallback"
+    f.write("  decltype(&" + reg_fname + ") " + reg_fname + "_ = nullptr;\n");
+
+  f.write("private:\n");
+  f.write("  void init() {\n");
+  for func in func_list:
+    reg_fname = "zelTracer" + func[2:] + "RegisterCallback"
+    f.write("  LEVEL_ZERO_LOADER_GET_SYMBOL(" + reg_fname + ");\n");
+  f.write("}\n");
+
+def main():
+  if len(sys.argv) < 3:
+    print("Usage: python gen_l0_loader.py <output_include_path> <l0_include_path>")
+    return
+
+  dst_path = sys.argv[1]
+  if (not os.path.exists(dst_path)):
+    os.mkdir(dst_path)
+
+  dst_loader_file_path = os.path.join(dst_path, "l0_loader.gen")
+  if (os.path.isfile(dst_loader_file_path)):
+    os.remove(dst_loader_file_path)
+
+  dst_loader_file = open(dst_loader_file_path, "wt")
+
+  l0_path = sys.argv[2]
+  l0_file_path = os.path.join(l0_path, "ze_api.h")
+
+  func_list = []
+
+  l0_file = open(l0_file_path, "rt")
+  get_func_list(l0_file, func_list)
+
+  l0_exp_path = os.path.join(l0_path, "layers", "zel_tracing_register_cb.h")
+  l0_exp_file = open(l0_exp_path, "rt")
+  get_func_list(l0_exp_file, func_list)
+
+  gen_loader(dst_loader_file, func_list)
+
+  l0_exp_file.close()
+  l0_file.close()
+  dst_loader_file.close()
+
+if __name__ == "__main__":
+  main()

tools/unitrace/scripts/gen_tracing_callbacks.py

@@ -189,9 +189,8 @@ def get_param_struct_name(func_name):
   struct_name += "params_t"
   return struct_name
 
-def get_func_list(f):
+def get_func_list(f, func_list):
   f.seek(0)
-  func_list = []
   for line in f.readlines():
     if line.find("ZE_APICALL") != -1 and line.find("ze_pfn") != -1:
       items = line.split("ze_pfn")
@@ -200,22 +199,6 @@ def get_func_list(f):
       items = items[1].split("Cb_t")
       assert len(items) == 2
       func_list.append("ze" + items[0].strip())
-  return func_list
-
-def get_callback_group_map(f):
-  group_map = {}
-
-  base_map = get_callback_struct_map(f, "ze_callbacks_t")
-  assert len(base_map) > 0
-
-  for key, value in base_map.items():
-    func_map = get_callback_struct_map(f, key)
-    for fkey, fvalue in func_map.items():
-      func_name = get_func_name(fkey)
-      assert not (func_name in group_map)
-      group_map[func_name] = (value, fvalue)
-
-  return group_map
 
 def add_param_map(f, func_list, param_map):
   for func in func_list:
@@ -238,53 +221,24 @@ def get_enum_map(include_path):
 
 # Generate Callbacks ##########################################################
 
-def gen_set_prologues(f, func_list, group_map):
+def gen_register(f, func_list):
   for func in func_list:
-    if not func in group_map:
-      continue
+    reg_fname = "ZeLoader::get().zelTracer" + func[2:] + "RegisterCallback_"
+    f.write("    if (" + reg_fname + " != nullptr) {\n");
+    f.write("      status = " + reg_fname + "(tracer, ZEL_REGISTER_PROLOGUE, " + func + "OnEnter);\n")
+    f.write("      PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
+    f.write("      status = " + reg_fname + "(tracer, ZEL_REGISTER_EPILOGUE, " + func + "OnExit);\n")
+    f.write("      PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
+    f.write("    }\n")
 
-    group, callback = group_map[func]
-    group_name = group[0]
-    group_cond = group[1]
-    assert not group_cond
-    callback_name = callback[0]
-    callback_cond = callback[1]
-    if callback_cond:
-      f.write("#if " + callback_cond + "\n")
-    f.write("    prologue." + group_name + "." + callback_name + " = " + func + "OnEnter;\n")
-    f.write("    epilogue." + group_name + "." + callback_name + " = " + func + "OnExit;\n")
-    if callback_cond:
-      f.write("#endif //" + callback_cond + "\n")
-
-def gen_exp_register(f, exp_func_list):
-  for func in exp_func_list:
-    f.write("    status = zelTracer" + func[2:] + "RegisterCallback(tracer, ZEL_REGISTER_PROLOGUE, " + func + "OnEnter);\n")
-    f.write("    PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-    f.write("    status = zelTracer" + func[2:] + "RegisterCallback(tracer, ZEL_REGISTER_EPILOGUE, " + func + "OnExit);\n")
-    f.write("    PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-
-def gen_api(f, func_list, kfunc_list, group_map, exp_func_list, kexp_func_list):
+def gen_api(f, func_list, kfunc_list):
   f.write("void EnableTracing(zel_tracer_handle_t tracer) {\n")
-  f.write("  zet_core_callbacks_t prologue = {};\n")
-  f.write("  zet_core_callbacks_t epilogue = {};\n")
-  f.write("\n")
-  f.write("  if (options_.api_tracing) {\n")
-  gen_set_prologues(f, func_list, group_map)
-  f.write("  }\n")
-  f.write("  else if (options_.kernel_tracing) {\n")
-  gen_set_prologues(f, kfunc_list, group_map)
-  f.write("  }\n")
-  f.write("\n")
   f.write("  ze_result_t status = ZE_RESULT_SUCCESS;\n")
-  f.write("  status = zelTracerSetPrologues(tracer, &prologue);\n")
-  f.write("  PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-  f.write("  status = zelTracerSetEpilogues(tracer, &epilogue);\n")
-  f.write("  PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
   f.write("  if (options_.api_tracing) {\n")
-  gen_exp_register(f, exp_func_list)
+  gen_register(f, func_list)
   f.write("  }\n")
   f.write("  else if (options_.kernel_tracing) {\n")
-  gen_exp_register(f, kexp_func_list)
+  gen_register(f, kfunc_list)
   f.write("  }\n")
   f.write("\n")
   f.write("  status = zelTracerSetEnabled(tracer, true);\n")
@@ -822,38 +776,8 @@ def gen_exit_callback(f, func, submission_func_list, synchronize_func_list_on_en
     f.write("          start_time_host, end_time_host);\n")
   f.write("  }\n")
 
-def gen_callbacks(f, func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, group_map, param_map, enum_map):
+def gen_callbacks(f, func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map, enum_map):
   for func in func_list:
-    if not func in group_map:
-      continue
-
-    assert func in param_map
-    group, callback = group_map[func]
-    callback_name = callback[0]
-    callback_cond = callback[1]
-    if callback_cond:
-      f.write("#if " + callback_cond + "\n")
-    f.write("static void " + func + "OnEnter(\n")
-    f.write("    " + get_param_struct_name(func) + "* params,\n")
-    f.write("    ze_result_t result,\n")
-    f.write("    void* global_user_data,\n")
-    f.write("    void** instance_user_data) {\n")
-    gen_enter_callback(f, func, command_list_func_list, command_queue_func_list, synchronize_func_list_on_enter, param_map[func], enum_map)
-    f.write("}\n")
-    f.write("\n")
-    f.write("static void " + func + "OnExit(\n")
-    f.write("    " + get_param_struct_name(func) + "* params,\n")
-    f.write("    ze_result_t result,\n")
-    f.write("    void* global_user_data,\n")
-    f.write("    void** instance_user_data) {\n")
-    gen_exit_callback(f, func, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map[func], enum_map)
-    f.write("}\n")
-    if callback_cond:
-      f.write("#endif //" + callback_cond + "\n")
-    f.write("\n")
-
-def gen_exp_callbacks(f, exp_func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, group_map, param_map, enum_map):
-  for func in exp_func_list:
     assert func in param_map
     f.write("static void " + func + "OnEnter(\n")
     f.write("    " + get_param_struct_name(func) + "* params,\n")
@@ -890,13 +814,21 @@ def main():
   l0_path = sys.argv[2]
   l0_file_path = os.path.join(l0_path, "ze_api.h")
 
+  func_list = []
+  param_map = {}
+
   l0_file = open(l0_file_path, "rt")
-  func_list = get_func_list(l0_file)
+  get_func_list(l0_file, func_list)
+  add_param_map(l0_file, func_list, param_map)
 
   l0_exp_path = os.path.join(l0_path, "layers", "zel_tracing_register_cb.h")
   l0_exp_file = open(l0_exp_path, "rt")
-  exp_func_list = get_func_list(l0_exp_file)
- 
+  exp_func_list = []
+  get_func_list(l0_exp_file, exp_func_list)
+  add_param_map(l0_exp_file, exp_func_list, param_map)
+
+  func_list += exp_func_list
+
   kfunc_list = [
       "zeEventDestroy",
       "zeEventHostReset",
@@ -934,9 +866,9 @@ def main():
       "zeEventHostSynchronize",
       "zeEventQueryStatus",
       "zeFenceHostSynchronize",
-      "zeContextDestroy"]
-  kexp_func_list = [
+      "zeContextDestroy",
       "zeCommandListImmediateAppendCommandListsExp"]
+
   command_list_func_list = [
       "zeCommandListAppendEventReset",
       "zeCommandListAppendLaunchKernel",
@@ -973,17 +905,12 @@ def main():
       "zeFenceHostSynchronize",
       "zeCommandQueueSynchronize"]
 
-  group_map = get_callback_group_map(l0_file)
-  param_map = {}
-  add_param_map(l0_file, func_list, param_map)
-  add_param_map(l0_exp_file, exp_func_list, param_map)
   enum_map = get_enum_map(l0_path)
 
   gen_result_converter(dst_file, enum_map)
   gen_structure_type_converter(dst_file, enum_map)
-  gen_callbacks(dst_file, func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, group_map, param_map, enum_map)
-  gen_exp_callbacks(dst_file, exp_func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, group_map, param_map, enum_map)
-  gen_api(dst_file, func_list, kfunc_list, group_map, exp_func_list, kexp_func_list)
+  gen_callbacks(dst_file, func_list, command_list_func_list, command_queue_func_list, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map, enum_map)
+  gen_api(dst_file, func_list, kfunc_list)
 
   l0_exp_file.close()
   l0_file.close()

tools/unitrace/src/levelzero/ze_collector.h

@@ -38,6 +38,7 @@
 #include "unicontrol.h"
 #include "unimemory.h"
 
+#include "ze_loader.h"
 #include "common_header.gen"
 
 struct ZeMetricQueryPoolKey {

tools/unitrace/src/levelzero/ze_loader.h

@@ -0,0 +1,53 @@
+//==============================================================
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: MIT
+// =============================================================
+#ifndef PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_
+#define PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_
+
+#include <iostream>
+#include <memory>
+
+#include "utils/library_loader.h"
+
+class ZeLoader {
+ public:
+  static auto& get() {
+    static ZeLoader instance{};
+    return instance;
+  }
+
+  void Unload() { lib_.reset(nullptr); }
+
+  bool Loaded() const { return lib_ != nullptr; }
+
+ private:
+  ZeLoader() {
+    #if defined(_WIN32)
+    static constexpr const char* const kLevelZeroLoaderName = "ze_loader.dll";
+    #else
+    static constexpr const char* const kLevelZeroLoaderName = "libze_loader.so.1";
+    #endif
+
+    try {
+      lib_ = std::make_unique<LibraryLoader>(kLevelZeroLoaderName);
+    } catch (const std::exception& e) {
+      std::cerr << "[ERROR] Failed to load " << kLevelZeroLoaderName
+                << " Reason: " << e.what() << std::endl;
+      lib_ = nullptr;
+      return;
+    }
+
+    init();
+  }
+
+  std::unique_ptr<LibraryLoader> lib_ = nullptr;
+
+  #define LEVEL_ZERO_LOADER_GET_SYMBOL(X) \
+    this->X##_ = lib_->GetSymbol<decltype(&X)>(#X)  // NOLINT
+  #include <l0_loader.gen>               // Auto-generated callbacks
+  #undef LEVEL_ZERO_LOADER_GET_SYMBOL
+};
+
+#endif  // PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_