[UR] Share generic error handling between adapters (#17576)

* `UR_ASSERT`: Remove redefinition in L0 adapter.
* `die()`: Use `logger` and remover redefinitions in 4 adapters.
* `UR_CALL*`: Move from L0 to shared `ur.hpp`, used in sanitizer layer
and other adapters.

Author: npmiller

unified-runtime/source/adapters/cuda/command_buffer.cpp

@@ -68,10 +68,10 @@ ur_exp_command_buffer_handle_t_::ur_exp_command_buffer_handle_t_(
 /// all the memory objects allocated for command_buffer managment
 ur_exp_command_buffer_handle_t_::~ur_exp_command_buffer_handle_t_() {
   // Release the memory allocated to the Context stored in the command_buffer
-  UR_TRACE(urContextRelease(Context));
+  UR_CALL_NOCHECK(urContextRelease(Context));
 
   // Release the device
-  UR_TRACE(urDeviceRelease(Device));
+  UR_CALL_NOCHECK(urDeviceRelease(Device));
 }
 
 // This may throw so it must be called from within a try...catch

unified-runtime/source/adapters/cuda/command_buffer.hpp

@@ -18,23 +18,6 @@
 #include <memory>
 #include <unordered_set>
 
-// Trace an internal UR call
-#define UR_TRACE(Call)                                                         \
-  {                                                                            \
-    ur_result_t Result;                                                        \
-    UR_CALL(Call, Result);                                                     \
-  }
-
-// Trace an internal UR call and return the result to the user.
-#define UR_CALL(Call, Result)                                                  \
-  {                                                                            \
-    if (PrintTrace)                                                            \
-      logger::always("UR ---> {}", #Call);                                     \
-    Result = (Call);                                                           \
-    if (PrintTrace)                                                            \
-      logger::always("UR <--- {}({})", #Call, Result);                         \
-  }
-
 enum class CommandType {
   Kernel,
   USMMemcpy,

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

@@ -92,11 +92,6 @@ std::string getCudaVersionString() {
   return stream.str();
 }
 
-void detail::ur::die(const char *Message) {
-  logger::always("ur_die:{}", Message);
-  std::terminate();
-}
-
 void detail::ur::assertion(bool Condition, const char *Message) {
   if (!Condition)
     die(Message);

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

@@ -57,12 +57,6 @@ void setPluginSpecificMessage(CUresult cu_res);
 namespace detail {
 namespace ur {
 
-// Report error and no return (keeps compiler from printing warnings).
-// TODO: Probably change that to throw a catchable exception,
-//       but for now it is useful to see every failure.
-//
-[[noreturn]] void die(const char *Message);
-
 // Reports error messages
 void cuPrint(const char *Message);
 

unified-runtime/source/adapters/cuda/enqueue.cpp

@@ -1104,7 +1104,7 @@ static size_t imageElementByteSize(CUDA_ARRAY_DESCRIPTOR ArrayDesc) {
   case CU_AD_FORMAT_FLOAT:
     return 4;
   default:
-    detail::ur::die("Invalid image format.");
+    die("Invalid image format.");
     return 0;
   }
 }

unified-runtime/source/adapters/cuda/event.cpp

@@ -113,8 +113,7 @@ ur_result_t ur_event_handle_t_::record() {
   try {
     EventID = Queue->getNextEventID();
     if (EventID == 0) {
-      detail::ur::die(
-          "Unrecoverable program state reached in event identifier overflow");
+      die("Unrecoverable program state reached in event identifier overflow");
     }
     UR_CHECK_ERROR(cuEventRecord(EvEnd, Stream));
   } catch (ur_result_t error) {

unified-runtime/source/adapters/cuda/memory.cpp

@@ -118,7 +118,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
     // error for which it is unclear if the function that reported it succeeded
     // or not. Either way, the state of the program is compromised and likely
     // unrecoverable.
-    detail::ur::die("Unrecoverable program state reached in urMemRelease");
+    die("Unrecoverable program state reached in urMemRelease");
   }
 
   return UR_RESULT_SUCCESS;

unified-runtime/source/adapters/cuda/queue.cpp

@@ -279,7 +279,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   else if (CuFlags == CU_STREAM_NON_BLOCKING)
     Flags = UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
   else
-    detail::ur::die("Unknown cuda stream");
+    die("Unknown cuda stream");
 
   std::vector<CUstream> ComputeCuStreams(1, CuStream);
   std::vector<CUstream> TransferCuStreams(0);

unified-runtime/source/adapters/hip/command_buffer.cpp

@@ -33,10 +33,10 @@ ur_exp_command_buffer_handle_t_::ur_exp_command_buffer_handle_t_(
 /// all the memory objects allocated for command_buffer managment
 ur_exp_command_buffer_handle_t_::~ur_exp_command_buffer_handle_t_() {
   // Release the memory allocated to the Context stored in the command_buffer
-  UR_TRACE(urContextRelease(Context));
+  UR_CALL_NOCHECK(urContextRelease(Context));
 
   // Release the device
-  UR_TRACE(urDeviceRelease(Device));
+  UR_CALL_NOCHECK(urDeviceRelease(Device));
 
   // Release the memory allocated to the HIPGraph
   (void)hipGraphDestroy(HIPGraph);

unified-runtime/source/adapters/hip/command_buffer.hpp

@@ -17,23 +17,6 @@
 #include <memory>
 #include <unordered_set>
 
-// Trace an internal UR call
-#define UR_TRACE(Call)                                                         \
-  {                                                                            \
-    ur_result_t Result;                                                        \
-    UR_CALL(Call, Result);                                                     \
-  }
-
-// Trace an internal UR call and return the result to the user.
-#define UR_CALL(Call, Result)                                                  \
-  {                                                                            \
-    if (PrintTrace)                                                            \
-      std::cerr << "UR ---> " << #Call << "\n";                                \
-    Result = (Call);                                                           \
-    if (PrintTrace)                                                            \
-      std::cerr << "UR <--- " << #Call << "(" << Result << ")\n";              \
-  }
-
 // Handle to a kernel command.
 //
 // Struct that stores all the information related to a kernel command in a