Use leak checker and API logging (for v2) from loader (#17536)

igchor · kbenzie · commit 513802215eab · 2025-05-08T10:52:36.000+01:00
diff --git a/source/adapters/level_zero/adapter.cpp b/source/adapters/level_zero/adapter.cpp
@@ -308,26 +308,25 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
 
   if (UrL0Debug & UR_L0_DEBUG_BASIC) {
     logger.setLegacySink(std::make_unique<ur_legacy_sink>());
+#ifdef UR_ADAPTER_LEVEL_ZERO_V2
+    setEnvVar("ZEL_ENABLE_LOADER_LOGGING", "1");
+    setEnvVar("ZEL_LOADER_LOGGING_LEVEL", "trace");
+    setEnvVar("ZEL_LOADER_LOG_CONSOLE", "1");
+    setEnvVar("ZE_ENABLE_VALIDATION_LAYER", "1");
+#endif
   };
 
   if (UrL0Debug & UR_L0_DEBUG_VALIDATION) {
     setEnvVar("ZE_ENABLE_VALIDATION_LAYER", "1");
     setEnvVar("ZE_ENABLE_PARAMETER_VALIDATION", "1");
   }
 
-  PlatformCache.Compute = [](Result<PlatformVec> &result) {
-    static std::once_flag ZeCallCountInitialized;
-    try {
-      std::call_once(ZeCallCountInitialized, []() {
-        if (UrL0LeaksDebug) {
-          ZeCallCount = new std::map<std::string, int>;
-        }
-      });
-    } catch (...) {
-      result = exceptionToResult(std::current_exception());
-      return;
-    }
+  if (UrL0LeaksDebug) {
+    setEnvVar("ZE_ENABLE_VALIDATION_LAYER", "1");
+    setEnvVar("ZEL_ENABLE_BASIC_LEAK_CHECKER", "1");
+  }
 
+  PlatformCache.Compute = [](Result<PlatformVec> &result) {
     uint32_t UserForcedSysManInit = 0;
     // Check if the user has disabled the default L0 Env initialization.
     const int UrSysManEnvInitEnabled = [&UserForcedSysManInit] {
@@ -417,6 +416,16 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
              loader_version.patch >= 2)) {
           useInitDrivers = true;
         }
+
+#ifdef UR_ADAPTER_LEVEL_ZERO_V2
+        if ((loader_version.major == 1 && loader_version.minor < 21) ||
+            (loader_version.major == 1 && loader_version.minor == 21 &&
+             loader_version.patch < 2)) {
+          logger::warning(
+              "WARNING: Level Zero Loader version is older than 1.21.2. "
+              "Please update to the latest version for API logging support.\n");
+        }
+#endif
       }
 
       if (useInitDrivers) {
@@ -533,97 +542,6 @@ void globalAdapterOnDemandCleanup() {
 }
 
 ur_result_t adapterStateTeardown() {
-  // Print the balance of various create/destroy native calls.
-  // The idea is to verify if the number of create(+) and destroy(-) calls are
-  // matched.
-  if (ZeCallCount && (UrL0LeaksDebug) != 0) {
-    bool LeakFound = false;
-    // clang-format off
-    //
-    // The format of this table is such that each row accounts for a
-    // specific type of objects, and all elements in the raw except the last
-    // one are allocating objects of that type, while the last element is known
-    // to deallocate objects of that type.
-    //
-    std::vector<std::vector<std::string>> CreateDestroySet = {
-      {"zeContextCreate",      "zeContextDestroy"},
-      {"zeCommandQueueCreate", "zeCommandQueueDestroy"},
-      {"zeModuleCreate",       "zeModuleDestroy"},
-      {"zeKernelCreate",       "zeKernelDestroy"},
-      {"zeEventPoolCreate",    "zeEventPoolDestroy"},
-      {"zeCommandListCreateImmediate", "zeCommandListCreate", "zeCommandListDestroy"},
-      {"zeEventCreate",        "zeEventDestroy"},
-      {"zeFenceCreate",        "zeFenceDestroy"},
-      {"zeImageCreate","zeImageViewCreateExt",        "zeImageDestroy"},
-      {"zeSamplerCreate",      "zeSamplerDestroy"},
-      {"zeMemAllocDevice", "zeMemAllocHost", "zeMemAllocShared", "zeMemFree"},
-    };
-
-    // A sample output aimed below is this:
-    // ------------------------------------------------------------------------
-    //                zeContextCreate = 1     \--->        zeContextDestroy = 1
-    //           zeCommandQueueCreate = 1     \--->   zeCommandQueueDestroy = 1
-    //                 zeModuleCreate = 1     \--->         zeModuleDestroy = 1
-    //                 zeKernelCreate = 1     \--->         zeKernelDestroy = 1
-    //              zeEventPoolCreate = 1     \--->      zeEventPoolDestroy = 1
-    //   zeCommandListCreateImmediate = 1     |
-    //            zeCommandListCreate = 1     \--->    zeCommandListDestroy = 1  ---> LEAK = 1
-    //                  zeEventCreate = 2     \--->          zeEventDestroy = 2
-    //                  zeFenceCreate = 1     \--->          zeFenceDestroy = 1
-    //                  zeImageCreate = 0     \--->          zeImageDestroy = 0
-    //                zeSamplerCreate = 0     \--->        zeSamplerDestroy = 0
-    //               zeMemAllocDevice = 0     |
-    //                 zeMemAllocHost = 1     |
-    //               zeMemAllocShared = 0     \--->               zeMemFree = 1
-    //
-    // clang-format on
-    // TODO: use logger to print this messages
-    std::cerr << "Check balance of create/destroy calls\n";
-    std::cerr << "----------------------------------------------------------\n";
-    std::stringstream ss;
-    for (const auto &Row : CreateDestroySet) {
-      int diff = 0;
-      for (auto I = Row.begin(); I != Row.end();) {
-        const char *ZeName = (*I).c_str();
-        const auto &ZeCount = (*ZeCallCount)[*I];
-
-        bool First = (I == Row.begin());
-        bool Last = (++I == Row.end());
-
-        if (Last) {
-          ss << " \\--->";
-          diff -= ZeCount;
-        } else {
-          diff += ZeCount;
-          if (!First) {
-            ss << " | ";
-            std::cerr << ss.str() << "\n";
-            ss.str("");
-            ss.clear();
-          }
-        }
-        ss << std::setw(30) << std::right << ZeName;
-        ss << " = ";
-        ss << std::setw(5) << std::left << ZeCount;
-      }
-
-      if (diff) {
-        LeakFound = true;
-        ss << " ---> LEAK = " << diff;
-      }
-
-      std::cerr << ss.str() << '\n';
-      ss.str("");
-      ss.clear();
-    }
-
-    ZeCallCount->clear();
-    delete ZeCallCount;
-    ZeCallCount = nullptr;
-    if (LeakFound)
-      return UR_RESULT_ERROR_INVALID_MEM_OBJECT;
-  }
-
   // Due to multiple DLLMain definitions with SYCL, register to cleanup the
   // Global Adapter after refcnt is 0
 #if defined(_WIN32)
diff --git a/source/adapters/level_zero/common.cpp b/source/adapters/level_zero/common.cpp
@@ -136,15 +136,18 @@ void zeParseError(ze_result_t ZeError, const char *&ErrorString) {
   } // switch
 }
 
+#ifdef UR_ADAPTER_LEVEL_ZERO_V2
+ze_result_t ZeCall::doCall(ze_result_t ZeResult, const char *, const char *,
+                           bool) {
+  return ZeResult;
+}
+#else
 ze_result_t ZeCall::doCall(ze_result_t ZeResult, const char *ZeName,
                            const char *ZeArgs, bool TraceError) {
   logger::debug("ZE ---> {}{}", ZeName, ZeArgs);
 
   if (ZeResult == ZE_RESULT_SUCCESS) {
-    if (UrL0LeaksDebug) {
-      ++(*ZeCallCount)[ZeName];
-    }
-    return ZE_RESULT_SUCCESS;
+    return ZeResult;
   }
 
   if (TraceError) {
@@ -154,6 +157,7 @@ ze_result_t ZeCall::doCall(ze_result_t ZeResult, const char *ZeName,
   }
   return ZeResult;
 }
+#endif
 
 // Specializations for various L0 structures
 template <> ze_structure_type_t getZeStructureType<ze_event_pool_desc_t>() {
diff --git a/source/adapters/level_zero/common.hpp b/source/adapters/level_zero/common.hpp
@@ -74,6 +74,7 @@ const int UrL0LeaksDebug = [] {
   const char *UrRet = std::getenv("UR_L0_LEAKS_DEBUG");
   if (!UrRet)
     return 0;
+
   return std::atoi(UrRet);
 }();
 
diff --git a/source/adapters/level_zero/v2/common.hpp b/source/adapters/level_zero/v2/common.hpp
@@ -15,24 +15,8 @@
 
 #include "../common.hpp"
 #include "logger/ur_logger.hpp"
-namespace {
-#define DECLARE_DESTROY_FUNCTION(name)                                         \
-  template <typename ZeHandleT> ze_result_t name##_wrapped(ZeHandleT handle) { \
-    return ZE_CALL_NOCHECK_NAME(name, (handle), #name);                        \
-  }
-
-#define HANDLE_WRAPPER_TYPE(handle, destroy)                                   \
-  ze_handle_wrapper<handle, destroy##_wrapped<handle>>
-} // namespace
 
 namespace v2 {
-
-DECLARE_DESTROY_FUNCTION(zeKernelDestroy)
-DECLARE_DESTROY_FUNCTION(zeEventDestroy)
-DECLARE_DESTROY_FUNCTION(zeEventPoolDestroy)
-DECLARE_DESTROY_FUNCTION(zeContextDestroy)
-DECLARE_DESTROY_FUNCTION(zeCommandListDestroy)
-DECLARE_DESTROY_FUNCTION(zeImageDestroy)
 namespace raii {
 
 template <typename ZeHandleT, ze_result_t (*destroy)(ZeHandleT)>
@@ -108,23 +92,23 @@ struct ze_handle_wrapper {
   bool ownZeHandle;
 };
 
-using ze_kernel_handle_t = HANDLE_WRAPPER_TYPE(::ze_kernel_handle_t,
-                                               zeKernelDestroy);
+using ze_kernel_handle_t =
+    ze_handle_wrapper<::ze_kernel_handle_t, zeKernelDestroy>;
 
-using ze_event_handle_t = HANDLE_WRAPPER_TYPE(::ze_event_handle_t,
-                                              zeEventDestroy);
+using ze_event_handle_t =
+    ze_handle_wrapper<::ze_event_handle_t, zeEventDestroy>;
 
-using ze_event_pool_handle_t = HANDLE_WRAPPER_TYPE(::ze_event_pool_handle_t,
-                                                   zeEventPoolDestroy);
+using ze_event_pool_handle_t =
+    ze_handle_wrapper<::ze_event_pool_handle_t, zeEventPoolDestroy>;
 
-using ze_context_handle_t = HANDLE_WRAPPER_TYPE(::ze_context_handle_t,
-                                                zeContextDestroy);
+using ze_context_handle_t =
+    ze_handle_wrapper<::ze_context_handle_t, zeContextDestroy>;
 
-using ze_command_list_handle_t = HANDLE_WRAPPER_TYPE(::ze_command_list_handle_t,
-                                                     zeCommandListDestroy);
+using ze_command_list_handle_t =
+    ze_handle_wrapper<::ze_command_list_handle_t, zeCommandListDestroy>;
 
-using ze_image_handle_t = HANDLE_WRAPPER_TYPE(::ze_image_handle_t,
-                                              zeImageDestroy);
+using ze_image_handle_t =
+    ze_handle_wrapper<::ze_image_handle_t, zeImageDestroy>;
 
 } // namespace raii
 } // namespace v2
