[PTI-LIB] Enable Support for zeInitDrivers. (#489)

Add support for initializing level zero with `zeInitDrivers`.

As of oneAPI 2025.1.0, the Unified Runtime initializes the Level Zero
drivers with the API call `zeInitDrivers()`. However, this
caused instability within our SYCL tests.

If the Level Zero Loader version >= `1.19.2`, we will now call
`zeInitDrivers` after `zeInit`. We keep the old (deprecated
 `zeInit`) to allow compatibility with older driver versions.

Signed-off-by: Schilling, Matthew <matthew.schilling@intel.com>

Author: mschilling0

sdk/CMakeLists.txt

@@ -108,7 +108,8 @@ add_library(pti_all INTERFACE)
 add_library(Pti::pti_all ALIAS pti_all)
 
 # formerly pti_view
-add_library(pti MODULE "${PROJECT_SOURCE_DIR}/src/pti_view.cc")
+add_library(pti MODULE "${PROJECT_SOURCE_DIR}/src/pti_view.cc"
+                       "${PROJECT_SOURCE_DIR}/src/levelzero/ze_driver_init.cc")
 # We might want to make our own, but for now use CMake's
 # https://cmake.org/cmake/help/latest/module/GenerateExportHeader.html
 include(GenerateExportHeader)

sdk/src/levelzero/ze_collector.h

@@ -40,6 +40,7 @@
 #include "pti/pti_view.h"
 #include "unikernel.h"
 #include "utils.h"
+#include "ze_driver_init.h"
 #include "ze_event_cache.h"
 #include "ze_local_collection_helpers.h"
 #include "ze_timer_helper.h"
@@ -177,33 +178,23 @@ class ZeCollector {
                                              void* callback_data = nullptr) {
     SPDLOG_DEBUG("In {}", __FUNCTION__);
     PTI_ASSERT(nullptr != pti_state);
-    ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_CRITICAL(
-          "zeInit() returned: {}. There might be Level-Zero Loader "
-          "and Tracing library mismatch. Cannot continue",
-          static_cast<uint32_t>(status));
+    ZeDriverInit driver_init{};
+    if (!driver_init.Success()) {
+      SPDLOG_ERROR("Unable to initialize Level Zero driver(s)");
       *pti_state = pti_result::PTI_ERROR_DRIVER;
-    }
-
-    ze_api_version_t version = utils::ze::GetVersion();
-    PTI_ASSERT(ZE_MAJOR_VERSION(version) >= 1 && ZE_MINOR_VERSION(version) >= 3);
-    SPDLOG_DEBUG("Driver version major: {}, minor: {}", ZE_MAJOR_VERSION(version),
-                 ZE_MINOR_VERSION(version));
-    if ((*pti_state) != pti_result::PTI_SUCCESS) {
-      // zeInit returned not SUCCESS but we want to know version of driver in any case
       return nullptr;
     }
 
-    auto collector =
-        std::unique_ptr<ZeCollector>(new ZeCollector(options, acallback, fcallback, callback_data));
+    auto collector = std::unique_ptr<ZeCollector>(
+        new ZeCollector(options, acallback, fcallback, callback_data, driver_init.Drivers()));
+
     PTI_ASSERT(collector != nullptr);
     collector->parent_state_ = pti_state;
 
     zel_tracer_desc_t tracer_desc = {ZEL_STRUCTURE_TYPE_TRACER_EXP_DESC, nullptr, collector.get()};
     zel_tracer_handle_t tracer = nullptr;
     overhead::Init();
-    status = zelTracerCreate(&tracer_desc, &tracer);
+    auto status = zelTracerCreate(&tracer_desc, &tracer);
     overhead_fini(zelTracerCreate_id);
 
     if (status != ZE_RESULT_SUCCESS) {
@@ -443,15 +434,16 @@ class ZeCollector {
 
  private:  // Implementation
   ZeCollector(CollectorOptions options, OnZeKernelFinishCallback acallback,
-              OnZeApiCallsFinishCallback fcallback, void* callback_data)
+              OnZeApiCallsFinishCallback fcallback, void* callback_data,
+              const std::vector<ze_driver_handle_t>& drv_list)
       : options_(options),
         acallback_(acallback),
         fcallback_(fcallback),
         callback_data_(callback_data),
         event_cache_(ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP),
         swap_event_pool_(512),
         startstop_mode_changer(this) {
-    CreateDeviceMap();
+    CreateDeviceMap(drv_list);
     UpdateDeviceSyncDelta();
     ze_result_t res = l0_wrapper_.InitDynamicTracingWrappers();
     if (ZE_RESULT_SUCCESS == res) {
@@ -513,6 +505,10 @@ class ZeCollector {
   void CreateDeviceMap() {
     SPDLOG_DEBUG("In {}", __FUNCTION__);
     const auto drivers = utils::ze::GetDriverList();
+    CreateDeviceMap(drivers);
+  }
+
+  void CreateDeviceMap(const std::vector<ze_driver_handle_t>& drivers) {
     for (auto* const driver : drivers) {
       const auto devices = utils::ze::GetDeviceList(driver);
       for (auto* const device : devices) {

sdk/src/levelzero/ze_driver_init.cc

@@ -0,0 +1,123 @@
+//==============================================================
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: MIT
+// =============================================================
+
+#include "ze_driver_init.h"
+
+#include <level_zero/loader/ze_loader.h>
+#include <level_zero/ze_api.h>
+#include <spdlog/spdlog.h>
+
+#include "lz_api_tracing_api_loader.h"
+#include "overhead_kinds.h"
+#include "pti_assert.h"
+#include "ze_utils.h"
+
+namespace {
+// The Level Zero Loader version with a fully functional zeInitDrivers.
+// Versions prior to this one have bugs (or don't have it at all).
+// zeInitDrivers is the preferred method for initializing drivers from this point on.
+constexpr zel_version_t kProperLoaderVersionForZeInitDrivers = {1, 19, 2};
+
+inline bool operator>=(const zel_version_t& left, const zel_version_t& right) {
+  bool same_major_version = left.major == right.major;
+  return (same_major_version && left.minor > right.minor) ||
+         (same_major_version && left.minor == right.minor && left.patch >= right.patch) ||
+         (left.major > right.major);
+}
+
+ze_result_t ZeInitDrivers(uint32_t* driver_count, ze_driver_handle_t* drivers,
+                          ze_init_driver_type_desc_t* desc) {
+  if (pti::PtiLzTracerLoader::Instance().zeInitDrivers_) {
+    return pti::PtiLzTracerLoader::Instance().zeInitDrivers_(driver_count, drivers, desc);
+  }
+  return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool ProperLoaderforZeInitDrivers() {
+  auto loader_version = utils::ze::GetLoaderVersion();
+  if (!loader_version) {
+    return false;
+  }
+  SPDLOG_DEBUG("Loader version: {}.{}.{}.", loader_version->major, loader_version->minor,
+               loader_version->patch);
+  return *loader_version >= kProperLoaderVersionForZeInitDrivers;
+}
+
+void CheckLegacyDriverVersion(const std::vector<ze_driver_handle_t>& drivers) {
+  auto version = utils::ze::GetVersion(drivers);
+  SPDLOG_INFO("Driver version major: {}, minor: {}", ZE_MAJOR_VERSION(version),
+              ZE_MINOR_VERSION(version));
+  PTI_ASSERT(ZE_MAJOR_VERSION(version) > 1 ||
+             ZE_MAJOR_VERSION(version) == 1 && ZE_MINOR_VERSION(version) >= 3);
+}
+
+bool InitLegacyDrivers() {
+  overhead::Init();
+  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  overhead_fini(zeInit_id);
+  bool result = (status == ZE_RESULT_SUCCESS);
+  if (!result) {
+    SPDLOG_WARN("zeInit returned: {}.", static_cast<uint32_t>(status));
+    return false;
+  }
+  return result;
+}
+}  // namespace
+
+ZeDriverInit::ZeDriverInit() : init_success_(InitLegacyDrivers()) {
+  CollectLegacyDrivers();
+  CheckLegacyDriverVersion(drivers_);
+  if (ProperLoaderforZeInitDrivers()) {
+    // If legacy driver initialization failed, the current way. Don't immediately fail.
+    if (InitDrivers()) {
+      init_success_ = true;
+    }
+  }
+}
+
+bool ZeDriverInit::Success() const { return init_success_; }
+
+const std::vector<ze_driver_handle_t>& ZeDriverInit::Drivers() const { return drivers_; }
+
+std::vector<ze_driver_handle_t>& ZeDriverInit::Drivers() { return drivers_; }
+
+bool ZeDriverInit::InitDrivers() {
+  std::uint32_t drv_cnt = 0;
+  ze_init_driver_type_desc_t desc{};
+  desc.stype = ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC;
+  desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU;
+  desc.pNext = nullptr;
+  overhead::Init();
+  auto status = ZeInitDrivers(&drv_cnt, nullptr, &desc);
+  overhead_fini(zeInitDrivers_id);
+
+  bool result = (status == ZE_RESULT_SUCCESS);
+
+  if (!result) {
+    SPDLOG_INFO("ZeInitDrivers returned: {}.", static_cast<uint32_t>(status));
+    return result;
+  }
+
+  std::vector<ze_driver_handle_t> driver_list(static_cast<size_t>(drv_cnt));
+
+  overhead::Init();
+  status = ZeInitDrivers(&drv_cnt, driver_list.data(), &desc);
+  overhead_fini(zeInitDrivers_id);
+  result = (status == ZE_RESULT_SUCCESS);
+
+  if (!result) {
+    SPDLOG_INFO("ZeInitDrivers returned: {}.", static_cast<uint32_t>(status));
+    return result;
+  }
+
+  for (auto* driver : driver_list) {
+    drivers_.push_back(driver);
+  }
+
+  return result;
+}
+
+void ZeDriverInit::CollectLegacyDrivers() { drivers_ = utils::ze::GetDriverList(); }

sdk/src/levelzero/ze_driver_init.h

@@ -0,0 +1,32 @@
+//==============================================================
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: MIT
+// =============================================================
+
+#ifndef LEVEL_ZERO_ZE_DRIVER_INIT_H_
+#define LEVEL_ZERO_ZE_DRIVER_INIT_H_
+
+#include <level_zero/ze_api.h>
+
+#include <vector>
+
+class ZeDriverInit {
+ public:
+  ZeDriverInit();
+
+  bool Success() const;
+
+  const std::vector<ze_driver_handle_t>& Drivers() const;
+
+  std::vector<ze_driver_handle_t>& Drivers();
+
+ private:
+  bool InitDrivers();
+  void CollectLegacyDrivers();
+
+  bool init_success_ = false;
+  std::vector<ze_driver_handle_t> drivers_;
+};
+
+#endif  // LEVEL_ZERO_ZE_DRIVER_INIT_H_

sdk/src/lz_api_tracing_api_loader.h

@@ -6,6 +6,10 @@
 #ifndef SRC_LZ_API_TRACING_API_LOADER_H_
 #define SRC_LZ_API_TRACING_API_LOADER_H_
 
+#include <level_zero/layers/zel_tracing_api.h>
+#include <level_zero/layers/zel_tracing_register_cb.h>
+#include <level_zero/ze_api.h>
+#include <level_zero/zet_api.h>
 #include <spdlog/cfg/env.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
@@ -35,6 +39,8 @@ class PtiLzTracerLoader {
 
   bool ViewAvailable() const { return api_dlsyms_lib_ != nullptr; }
 
+  decltype(&zeInitDrivers) zeInitDrivers_ = nullptr;  // NOLINT
+
   // Forward to implementation in core library
 #include <tracing_api_dlsym_public.gen>  // Auto-generated callbacks
 
@@ -50,6 +56,7 @@ class PtiLzTracerLoader {
 #define LEVEL_ZERO_LOADER_GET_SYMBOL(X) \
   X##_ = api_dlsyms_lib_->GetSymbol<decltype(&X)>(#X)  // NOLINT
 #include <tracing_api_dlsym_private.gen>               // Auto-generated callbacks
+    LEVEL_ZERO_LOADER_GET_SYMBOL(zeInitDrivers);
 #undef LEVEL_ZERO_LOADER_GET_SYMBOL
   }
   std::unique_ptr<LibraryLoader> api_dlsyms_lib_ = nullptr;

sdk/src/overhead_kinds.h

@@ -14,7 +14,7 @@
  * ocallback.
  */
 #include <pti/pti_driver_levelzero_api_ids.h>
-//#include <pti/pti_driver_opencl_api_ids.h>
+// #include <pti/pti_driver_opencl_api_ids.h>
 
 #include "unikernel.h"
 #include "utils.h"

sdk/src/utils/ze_utils.h

@@ -7,11 +7,14 @@
 #ifndef PTI_UTILS_ZE_UTILS_H_
 #define PTI_UTILS_ZE_UTILS_H_
 
+#include <level_zero/loader/ze_loader.h>
 #include <level_zero/ze_api.h>
 #include <level_zero/zet_api.h>
 #include <pti/pti_driver_levelzero_api_ids.h>
 
+#include <array>
 #include <iomanip>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -475,14 +478,44 @@ inline bool GetDeviceUUID(ze_device_handle_t device, uint8_t* uuid, bool measure
   return true;
 }
 
-inline ze_api_version_t GetVersion() {
-  auto driver_list = GetDriverList();
+inline ze_api_version_t GetVersion(const std::vector<ze_driver_handle_t>& driver_list) {
   if (driver_list.empty()) {
     return ZE_API_VERSION_FORCE_UINT32;
   }
   return GetDriverVersion(driver_list.front());
 }
 
+inline ze_api_version_t GetVersion() {
+  auto driver_list = GetDriverList();
+  return GetVersion(driver_list);
+}
+
+inline std::optional<zel_version_t> GetLoaderVersion() {
+  constexpr auto* kLoaderComponentName = "loader";
+  constexpr auto kLoaderComponentNameLength = std::char_traits<char>::length(kLoaderComponentName);
+  size_t number_of_components = 0;
+  auto status = zelLoaderGetVersions(&number_of_components, nullptr);
+  if (number_of_components == 0 || status != ZE_RESULT_SUCCESS) {
+    return std::nullopt;
+  }
+
+  std::vector<zel_component_version_t> versions(number_of_components);
+
+  status = zelLoaderGetVersions(&number_of_components, versions.data());
+  if (status != ZE_RESULT_SUCCESS) {
+    return std::nullopt;
+  }
+
+  for (const auto& component_version : versions) {
+    if (!std::strncmp(component_version.component_name, kLoaderComponentName,
+                      kLoaderComponentNameLength)) {
+      return component_version.component_lib_version;
+    }
+  }
+
+  return std::nullopt;
+}
+
 }  // namespace ze
 }  // namespace utils
 

sdk/test/CMakeLists.txt

@@ -406,7 +406,8 @@ target_include_directories(
 target_link_libraries(view_record_test PUBLIC spdlog::spdlog Pti::pti_view GTest::gtest_main
                                               spdlog::spdlog)
 
-add_executable(assert_exception_test assert_exception_test.cc)
+add_executable(assert_exception_test assert_exception_test.cc
+   "${PROJECT_SOURCE_DIR}/src/levelzero/ze_driver_init.cc")
 
 target_include_directories(
   assert_exception_test