Update error messages to include function name, error name, and error description (#8)

* Add whip::get_error_name

* Add error name and string to exception description

* Add constructor to exception which accepts a function name to be printed alongside the error code and string

* Add function name when checking errors on wrapped functions

Author: msimberg

CMakeLists.txt

@@ -39,6 +39,7 @@ target_include_directories(
                 $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 target_compile_features(whip INTERFACE cxx_std_17)
 target_compile_definitions(whip INTERFACE "WHIP_${WHIP_BACKEND}")
+target_compile_definitions(whip INTERFACE "WHIP_BACKEND=${WHIP_BACKEND}")
 target_compile_options(
   whip INTERFACE
   $<$<AND:$<COMPILE_LANGUAGE:CUDA>,$<CUDA_COMPILER_ID:NVIDIA>>:--extended-lambda --expt-relaxed-constexpr>)

cmake/whip.hpp.in

@@ -24,8 +24,12 @@
 #include <hip/hip_runtime.h>
 #endif
 
+#define WHIP_STRINGIFY(x) WHIP_STRINGIFY_IMPL(x)
+#define WHIP_STRINGIFY_IMPL(x) #x
+
 #include <cstddef>
 #include <stdexcept>
+#include <string>
 
 namespace whip {
 inline constexpr std::size_t version_major = @PROJECT_VERSION_MAJOR@;
@@ -47,10 +51,32 @@ inline const char* get_error_string(error_t error) {
 #endif
 }
 
+inline const char *get_error_name(error_t error) {
+#if defined(WHIP_CUDA)
+  return cudaGetErrorName(error);
+#elif defined(WHIP_HIP)
+  return hipGetErrorName(error);
+#endif
+}
+
+namespace impl {
+inline std::string make_error_string(error_t error, char const *function) {
+  return std::string("[whip] ") + function + " returned " + get_error_name(error) + " (" + get_error_string(error) +
+         ")";
+}
+
+inline std::string make_error_string(error_t error) {
+  return std::string("[whip] ") + WHIP_STRINGIFY(WHIP_BACKEND) " function call returned " + get_error_name(error) + " (" +
+         get_error_string(error) + ")";
+}
+} // namespace impl
+
 // Custom exception which wraps a CUDA/HIP error
 class exception final : public std::runtime_error {
 public:
-  explicit exception(error_t error) : std::runtime_error(get_error_string(error)), error(error) {}
+  explicit exception(error_t error) : std::runtime_error(impl::make_error_string(error)), error(error) {}
+  explicit exception(error_t error, char const *function)
+      : std::runtime_error(impl::make_error_string(error, function)), error(error) {}
   error_t get_error() const noexcept { return error; }
 
 private:
@@ -65,16 +91,22 @@ inline void check_error(error_t e) {
 }
 
 namespace impl {
+inline void check_error(error_t e, char const *function) {
+  if (e != success) {
+    throw exception(e, function);
+  }
+}
+
 // Check an error and throw an exception on failure, except error_not_ready.
 // This is useful for query functions.
-inline bool check_error_query(error_t e) {
+inline bool check_error_query(error_t e, char const *function) {
   switch (e) {
-    case success:
-      return true;
-    case error_not_ready:
-      return false;
-    default:
-      throw exception(e);
+  case success:
+    return true;
+  case error_not_ready:
+    return false;
+  default:
+    throw exception(e, function);
   }
 }
 } // namespace impl

cmake/whip_helpers.cmake

@@ -69,10 +69,10 @@ function(whip_add_function var wrapper params wrapped)
   string(REGEX REPLACE "^, " "" wrapped_call_args "${wrapped_call_args}")
   set(wrapped_call "${prefixed_wrapped}(${wrapped_call_args})")
 
-  set(checker "whip::check_error")
+  set(checker "whip::impl::check_error")
   if(whip_add_function_QUERY)
     set(checker "whip::impl::check_error_query")
   endif()
-  set(fun "inline constexpr auto ${wrapper} = [](${wrapper_definition_params}) { return ${checker}(${wrapped_call}); };")
+  set(fun "inline constexpr auto ${wrapper} = [](${wrapper_definition_params}) { return ${checker}(${wrapped_call}, \"${prefixed_wrapped}\"); };")
   set(${var} "${${var}}\n${fun}" PARENT_SCOPE)
 endfunction()