[SYCL][UR] Do not log L0 API calls

instead, rely on logging provided by L0 loader.

Also, remove ZeCall and option to serialize all
L0 calls. It wasn't used correctly anyway, the function
call in ZE2UR_CALL* was done before taking the lock.

Author: igchor

unified-runtime/source/adapters/level_zero/adapter.cpp

@@ -308,6 +308,10 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
 
   if (UrL0Debug & UR_L0_DEBUG_BASIC) {
     logger.setLegacySink(std::make_unique<ur_legacy_sink>());
+    setEnvVar("ZEL_ENABLE_LOADER_LOGGING", "1");
+    setEnvVar("ZEL_LOADER_LOGGING_LEVEL", "trace");
+    setEnvVar("ZEL_LOADER_LOG_CONSOLE", "1");
+    setEnvVar("ZE_ENABLE_VALIDATION_LAYER", "1");
   };
 
   if (UrL0Debug & UR_L0_DEBUG_VALIDATION) {

unified-runtime/source/adapters/level_zero/common.cpp

@@ -137,18 +137,6 @@ void zeParseError(ze_result_t ZeError, const char *&ErrorString) {
   } // switch
 }
 
-ze_result_t ZeCall::doCall(ze_result_t ZeResult, const char *ZeName,
-                           const char *ZeArgs, bool TraceError) {
-  logger::debug("ZE ---> {}{}", ZeName, ZeArgs);
-
-  if (TraceError) {
-    const char *ErrorString = "Unknown";
-    zeParseError(ZeResult, ErrorString);
-    logger::error("Error ({}) in {}", ErrorString, ZeName);
-  }
-  return ZeResult;
-}
-
 // Specializations for various L0 structures
 template <> ze_structure_type_t getZeStructureType<ze_event_pool_desc_t>() {
   return ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;

unified-runtime/source/adapters/level_zero/common.hpp

@@ -241,7 +241,6 @@ const int UrL0InitAllDrivers = [] {
 enum {
   UrL0SerializeNone =
       0, // no locking or blocking (except when SYCL RT requested blocking)
-  UrL0SerializeLock = 1, // locking around each UR_CALL
   UrL0SerializeBlock =
       2, // blocking UR calls, where supported (usually in enqueue commands)
 };
@@ -288,20 +287,10 @@ class ZeCall {
   static std::mutex GlobalLock;
 
 public:
-  ZeCall() {
-    if ((UrL0Serialize & UrL0SerializeLock) != 0) {
-      GlobalLock.lock();
-    }
+  template <typename F> static auto underLock(F &&f) {
+    std::lock_guard<std::mutex> Lock(GlobalLock);
+    return f();
   }
-  ~ZeCall() {
-    if ((UrL0Serialize & UrL0SerializeLock) != 0) {
-      GlobalLock.unlock();
-    }
-  }
-
-  // The non-static version just calls static one.
-  ze_result_t doCall(ze_result_t ZeResult, const char *ZeName,
-                     const char *ZeArgs, bool TraceError = true);
 };
 
 // This function will ensure compatibility with both Linux and Windows for
@@ -352,25 +341,19 @@ void zeParseError(ze_result_t ZeError, const char *&ErrorString);
 // Trace a call to Level-Zero RT
 #define ZE2UR_CALL(ZeName, ZeArgs)                                             \
   {                                                                            \
-    ze_result_t ZeResult = ZeName ZeArgs;                                      \
-    if (auto Result = ZeCall().doCall(ZeResult, #ZeName, #ZeArgs, true))       \
+    if (auto Result = ZeName ZeArgs)                                           \
       return ze2urResult(Result);                                              \
   }
 
 // Trace a call to Level-Zero RT, throw on error
 #define ZE2UR_CALL_THROWS(ZeName, ZeArgs)                                      \
   {                                                                            \
-    ze_result_t ZeResult = ZeName ZeArgs;                                      \
-    if (auto Result = ZeCall().doCall(ZeResult, #ZeName, #ZeArgs, true))       \
+    if (auto Result = ZeName ZeArgs)                                           \
       throw ze2urResult(Result);                                               \
   }
 
 // Perform traced call to L0 without checking for errors
-#define ZE_CALL_NOCHECK(ZeName, ZeArgs)                                        \
-  ZeCall().doCall(ZeName ZeArgs, #ZeName, #ZeArgs, false)
-
-#define ZE_CALL_NOCHECK_NAME(ZeName, ZeArgs, callName)                         \
-  ZeCall().doCall(ZeName ZeArgs, callName, #ZeArgs, false)
+#define ZE_CALL_NOCHECK(ZeName, ZeArgs) ZeName ZeArgs
 
 // This wrapper around std::atomic is created to limit operations with reference
 // counter and to make allowed operations more transparent in terms of

unified-runtime/source/adapters/level_zero/kernel.cpp

@@ -1003,7 +1003,7 @@ ur_result_t urKernelSetExecInfo(
       else
         // Unexpected cache configuration value.
         return UR_RESULT_ERROR_INVALID_VALUE;
-      ZE2UR_CALL(zeKernelSetCacheConfig, (ZeKernel, ZeCacheConfig););
+      ZE2UR_CALL(zeKernelSetCacheConfig, (ZeKernel, ZeCacheConfig));
     } else {
       logger::error("urKernelSetExecInfo: unsupported ParamName");
       return UR_RESULT_ERROR_INVALID_VALUE;

unified-runtime/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)>
@@ -104,23 +88,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

unified-runtime/source/adapters/level_zero/v2/kernel.cpp

@@ -262,7 +262,7 @@ ur_result_t ur_kernel_handle_t_::setExecInfo(ur_kernel_exec_info_t propName,
         // Unexpected cache configuration value.
         return UR_RESULT_ERROR_INVALID_VALUE;
       ZE2UR_CALL(zeKernelSetCacheConfig,
-                 (kernel->hKernel.get(), zeCacheConfig););
+                 (kernel->hKernel.get(), zeCacheConfig));
     } else {
       logger::error("urKernelSetExecInfo: unsupported ParamName");
       return UR_RESULT_ERROR_INVALID_VALUE;