[common] fix umf2urResult

In case of UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC
the underlying native error was not being translated
to UR correctly (it was returned as is).

Fix this by adding native error handlers and implement one
for LEVEL_ZERO provider

Author: igchor

source/adapters/cuda/usm.cpp

@@ -22,6 +22,13 @@
 
 #include <cuda.h>
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *, int32_t) {
+  // TODO: implement when UMF supports CUDA
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 /// USM: Implements USM Host allocations using CUDA Pinned Memory
 /// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#page-locked-host-memory
 UR_APIEXPORT ur_result_t UR_APICALL

source/adapters/hip/usm.cpp

@@ -18,6 +18,13 @@
 #include "ur_util.hpp"
 #include "usm.hpp"
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *, int32_t) {
+  // TODO: implement when UMF supports HIP
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 /// USM: Implements USM Host allocations using HIP Pinned Memory
 UR_APIEXPORT ur_result_t UR_APICALL
 urUSMHostAlloc(ur_context_handle_t hContext, const ur_usm_desc_t *pUSMDesc,

source/adapters/level_zero/usm.cpp

@@ -23,6 +23,17 @@
 
 #include <umf_helpers.hpp>
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *providerName,
+                                   int32_t nativeError) {
+  if (strcmp(providerName, "Level Zero") == 0) {
+    return ze2urResult(static_cast<ze_result_t>(nativeError));
+  }
+
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 usm::DisjointPoolAllConfigs DisjointPoolConfigInstance =
     InitializeDisjointPoolConfig();
 

source/adapters/level_zero/v2/usm.cpp

@@ -19,6 +19,17 @@
 #include <umf/pools/pool_proxy.h>
 #include <umf/providers/provider_level_zero.h>
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *providerName,
+                                   int32_t nativeError) {
+  if (strcmp(providerName, "Level Zero") == 0) {
+    return ze2urResult(static_cast<ze_result_t>(nativeError));
+  }
+
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 static usm::DisjointPoolAllConfigs initializeDisjointPoolConfig() {
   const char *PoolUrTraceVal = std::getenv("UR_L0_USM_ALLOCATOR_TRACE");
 

source/adapters/native_cpu/usm.cpp

@@ -15,6 +15,12 @@
 #include "context.hpp"
 #include <cstdlib>
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *, int32_t) {
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 namespace native_cpu {
 
 static ur_result_t alloc_helper(ur_context_handle_t hContext,

source/adapters/opencl/usm.cpp

@@ -12,6 +12,13 @@
 
 #include "common.hpp"
 
+namespace umf {
+ur_result_t getProviderNativeError(const char *, int32_t) {
+  // TODO: implement when UMF supports OpenCL
+  return UR_RESULT_ERROR_UNKNOWN;
+}
+} // namespace umf
+
 inline cl_mem_alloc_flags_intel
 hostDescToClFlags(const ur_usm_host_desc_t &desc) {
   cl_mem_alloc_flags_intel allocFlags = 0;

source/common/umf_helpers.hpp

@@ -241,6 +241,9 @@ template <typename Type> umf_result_t &getPoolLastStatusRef() {
     return last_status;
 }
 
+ur_result_t getProviderNativeError(const char *providerName,
+                                   int32_t nativeError);
+
 /// @brief translates UMF return values to UR.
 /// This function assumes that the native error of
 /// the last failed memory provider is ur_result_t.
@@ -256,16 +259,15 @@ inline ur_result_t umf2urResult(umf_result_t umfResult) {
             return UR_RESULT_ERROR_UNKNOWN;
         }
 
-        ur_result_t Err = UR_RESULT_ERROR_UNKNOWN;
+        int32_t Err = UR_RESULT_ERROR_UNKNOWN;
         const char *Msg = nullptr;
-        umfMemoryProviderGetLastNativeError(hProvider, &Msg,
-                                            reinterpret_cast<int32_t *>(&Err));
+        umfMemoryProviderGetLastNativeError(hProvider, &Msg, &Err);
 
         if (Msg) {
             logger::error("UMF failed with: {}", Msg);
         }
 
-        return Err;
+        return getProviderNativeError(umfMemoryProviderGetName(hProvider), Err);
     }
     case UMF_RESULT_ERROR_INVALID_ARGUMENT:
         return UR_RESULT_ERROR_INVALID_ARGUMENT;