hip: api: generalize error handling (#9170)

* hip: api: generalize error handling

Generalize error handling for XRT hip external APIs.
This modification doesn't change the return error values or how it
captures errors. Instead, it provide template function to handle error
and return error, which reduces code duplication and makes it easier
for future error capturing change and error code update.

Signed-off-by: Wendy Liang <wendy.liang@amd.com>

* hip: api: device: fix unreachable code warning on windows

Due to hip_get_device_properties() and hip_device_get_attribute()
always throw error due to not implemented, MSVC compiler will throw
code unreachable warning:
 return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
    throw_invalid_value_if(!props, "arg passed is nullptr");
    *props = xrt::core::hip::hip_get_device_properties(device);
  });

  unreachable warning code: `*props =
  xrt::core::hip::hip_get_device_properties(device);`

  And thus change it to pass the props to the
  hip_get_device_properties() to avoid this warning.
  Or we will need to remove hip_get_device_properties() and just always
  returns unsupported error from top wrapper function.

  The same for hip_device_get_attribute().

Signed-off-by: Wendy Liang <wendy.liang@amd.com>

---------

Signed-off-by: Wendy Liang <wendy.liang@amd.com>

Author: wendyliang25

src/runtime_src/hip/api/hip_context.cpp

@@ -129,109 +129,55 @@ hip_device_primary_ctx_retain(device_handle dev)
 hipError_t
 hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!ctx, "ctx passed is nullptr");
 
     auto handle = xrt::core::hip::hip_ctx_create(flags, device);
     *ctx = reinterpret_cast<hipCtx_t>(handle);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipCtxDestroy(hipCtx_t ctx)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     xrt::core::hip::hip_ctx_destroy(ctx);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipCtxGetDevice(hipDevice_t* device)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!device, "device passed is nullptr");
 
     *device = static_cast<int>(xrt::core::hip::hip_ctx_get_device());
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipCtxSetCurrent(hipCtx_t ctx)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     xrt::core::hip::hip_ctx_set_current(ctx);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!pctx, "nullptr passed");
 
     auto handle = xrt::core::hip::hip_device_primary_ctx_retain(dev);
     *pctx = reinterpret_cast<hipCtx_t>(handle);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipDevicePrimaryCtxRelease(hipDevice_t dev)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     xrt::core::hip::hip_device_primary_ctx_release(dev);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }

src/runtime_src/hip/api/hip_device.cpp

@@ -105,9 +105,10 @@ hip_device_get_name(hipDevice_t device)
   return (xrt_core::device_query<xrt_core::query::rom_vbnv>((device_cache.get_or_error(device))->get_xrt_device().get_handle()));
 }
 
-static hipDeviceProp_t
-hip_get_device_properties(hipDevice_t device)
+static void
+hip_get_device_properties(hipDeviceProp_t* props, hipDevice_t device)
 {
+  throw_invalid_value_if(!props, "arg passed is nullptr");
   throw_invalid_device_if(check(device), "device requested is not available");
 
   throw std::runtime_error("Not implemented");
@@ -127,9 +128,10 @@ hip_device_get_uuid(hipDevice_t device)
   return uid;
 }
 
-static int
-hip_device_get_attribute(hipDeviceAttribute_t attr, int device)
+static void
+hip_device_get_attribute(int* pi, hipDeviceAttribute_t attr, int device)
 {
+  throw_invalid_value_if(!pi, "arg passed is nullptr");
   throw_invalid_device_if(check(device), "device requested is not available");
 
   throw std::runtime_error("Not implemented");
@@ -156,62 +158,32 @@ hip_kernel_name_ref(const hipFunction_t f)
 hipError_t
 hipInit(unsigned int flags)
 {
-  try {
-    xrt::core::hip::hip_init(flags);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorNotInitialized;
+  return handle_hip_func_error(__func__, hipErrorNotInitialized, [&] {
+    xrt::core::hip::hip_init(flags); });
 }
 
 hipError_t
 hipGetDeviceCount(size_t* count)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!count, "arg passed is nullptr");
-
     *count = xrt::core::hip::hip_get_device_count();
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipDeviceGet(hipDevice_t* device, int ordinal)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!device, "device is nullptr");
-
     *device = xrt::core::hip::hip_device_get(ordinal);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipDeviceGetName(char* name, int len, hipDevice_t device)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if((!name || len <= 0), "invalid arg");
 
     auto name_str = xrt::core::hip::hip_device_get_name(device);
@@ -220,16 +192,7 @@ hipDeviceGetName(char* name, int len, hipDevice_t device)
     auto cpy_size = (static_cast<size_t>(len) <= (name_str.length() + 1) ? (len - 1) : name_str.length());
     std::memcpy(name, name_str.c_str(), cpy_size);
     name[cpy_size] = '\0';
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 #if HIP_VERSION >= 60000000
@@ -256,91 +219,47 @@ hipError_t
 hipGetDeviceProperties(hipDeviceProp_t* props, hipDevice_t device)
 #endif
 {
-  try {
-    throw_invalid_value_if(!props, "arg passed is nullptr");
-
-    *props = xrt::core::hip::hip_get_device_properties(device);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
+    xrt::core::hip::hip_get_device_properties(props, device);
+  });
 }
 
 hipError_t
 hipDeviceGetUuid(hipUUID* uuid, hipDevice_t device)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     throw_invalid_value_if(!uuid, "arg passed is nullptr");
-
     *uuid = xrt::core::hip::hip_device_get_uuid(device);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 hipError_t
 hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int device)
 {
-  try {
-    throw_invalid_value_if(!pi, "arg passed is nullptr");
-
-    *pi = xrt::core::hip::hip_device_get_attribute(attr, device);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return hipErrorUnknown;
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
+	xrt::core::hip::hip_device_get_attribute(pi, attr, device);
+  });
 }
 
 hipError_t
 hipSetDevice(int device)
 {
-  try {
+  return handle_hip_func_error(__func__, hipErrorUnknown, [&] {
     xrt::core::hip::hip_set_device(device);
-    return hipSuccess;
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
-    return static_cast<hipError_t>(ex.value());
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(std::string(__func__) + " - " + ex.what());
-  }
-  return hipErrorUnknown;
+  });
 }
 
 const char *
 hipKernelNameRef(const hipFunction_t f)
 {
-  try {
+  const char* kname_ref = nullptr;
+  hipError_t err = handle_hip_func_error(__func__, hipErrorInvalidValue, [&] {
     throw_invalid_value_if(!f, "arg passed is nullptr");
+    kname_ref = xrt::core::hip::hip_kernel_name_ref(f);
+  });
 
-    return xrt::core::hip::hip_kernel_name_ref(f);
-  }
-  catch (const xrt_core::system_error& ex) {
-    xrt_core::send_exception_message(std::string(__func__) +  " - " + ex.what());
+  if (err != hipSuccess)
     return nullptr;
-  }
-  catch (const std::exception& ex) {
-    xrt_core::send_exception_message(ex.what());
-  }
-  return nullptr;
+
+  return kname_ref;
 }