update adapters emitting warnings to use logger instead of setErrorMessage and link up a logger callback from SYCL RT to simply print to stdout, this is setup during adapter

initialisation in sycl/source/detail.cpp

also remove setErrorMessage from OpenCL and Native CPU adapters where there was no usage

Author: martygrant

sycl/source/detail/ur.cpp

@@ -77,9 +77,9 @@ void *getAdapterOpaqueData([[maybe_unused]] void *OpaqueDataParam) {
 
 ur_code_location_t codeLocationCallback(void *);
 
-void receiveLoggerMessages([[maybe_unused]] ur_logger_level_t level,
-                           const char *msg, void *userData) {
-  // Do something with a message sent from a UR adapter
+void urLoggerCallback([[maybe_unused]] ur_logger_level_t level, const char *msg,
+                      [[maybe_unused]] void *userData) {
+  std::cout << msg << std::endl;
 }
 
 namespace ur {
@@ -143,6 +143,11 @@ static void initializeAdapters(std::vector<AdapterPtr> &Adapters,
   UrFuncInfo<UrApiKind::urAdapterGetInfo> adapterGetInfoInfo;
   auto adapterGetInfo =
       adapterGetInfoInfo.getFuncPtrFromModule(ur::getURLoaderLibrary());
+  UrFuncInfo<UrApiKind::urAdapterSetLoggerCallback>
+      adapterSetLoggerCallbackInfo;
+  auto adapterSetLoggerCallback =
+      adapterSetLoggerCallbackInfo.getFuncPtrFromModule(
+          ur::getURLoaderLibrary());
 
   bool OwnLoaderConfig = false;
   // If we weren't provided with a custom config handle create our own.
@@ -225,8 +230,8 @@ static void initializeAdapters(std::vector<AdapterPtr> &Adapters,
     auto syclBackend = UrToSyclBackend(adapterBackend);
     Adapters.emplace_back(std::make_shared<Adapter>(UrAdapter, syclBackend));
 
-    urAdapterSetLoggerCallback(UrAdapter, receiveLoggerMessages, nullptr,
-                               UR_LOGGER_LEVEL_INFO);
+    CHECK_UR_SUCCESS(adapterSetLoggerCallback(UrAdapter, urLoggerCallback,
+                                              nullptr, UR_LOGGER_LEVEL_INFO));
   }
 
 #ifdef XPTI_ENABLE_INSTRUMENTATION

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

@@ -97,10 +97,8 @@ ur_result_t setCuMemAdvise(CUdeviceptr DevPtr, size_t Size,
 
   for (auto &UnmappedFlag : UnmappedMemAdviceFlags) {
     if (URAdviceFlags & UnmappedFlag) {
-      setErrorMessage("Memory advice ignored because the CUDA backend does not "
-                      "support some of the specified flags",
-                      UR_RESULT_SUCCESS);
-      return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+      logger::warning("Memory advice ignored because the CUDA backend does not "
+                      "support some of the specified flags.");
     }
   }
 
@@ -1613,19 +1611,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
   // for managed memory. Therefore, ignore prefetch hint if concurrent managed
   // memory access is not available.
   if (!getAttribute(Device, CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS)) {
-    setErrorMessage("Prefetch hint ignored as device does not support "
-                    "concurrent managed access",
-                    UR_RESULT_SUCCESS);
-    return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+    logger::warning("Prefetch hint ignored as device does not support "
+                    "concurrent managed access.");
   }
 
   unsigned int IsManaged;
   UR_CHECK_ERROR(cuPointerGetAttribute(
       &IsManaged, CU_POINTER_ATTRIBUTE_IS_MANAGED, (CUdeviceptr)pMem));
   if (!IsManaged) {
-    setErrorMessage("Prefetch hint ignored as prefetch only works with USM",
-                    UR_RESULT_SUCCESS);
-    return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+    logger::warning("Prefetch hint ignored as prefetch only works with USM.");
   }
 
   ur_result_t Result = UR_RESULT_SUCCESS;
@@ -1675,9 +1669,8 @@ urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
       (advice & UR_USM_ADVICE_FLAG_DEFAULT)) {
     ur_device_handle_t Device = hQueue->getDevice();
     if (!getAttribute(Device, CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS)) {
-      setErrorMessage("Mem advise ignored as device does not support "
-                      "concurrent managed access",
-                      UR_RESULT_SUCCESS);
+      logger::warning("Mem advise ignored as device does not support "
+                      "concurrent managed access.");
       return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
     }
 

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

@@ -397,7 +397,7 @@ urKernelSetArgMemObj(ur_kernel_handle_t hKernel, uint32_t argIndex,
           arrayDesc.Format != CU_AD_FORMAT_SIGNED_INT32 &&
           arrayDesc.Format != CU_AD_FORMAT_HALF &&
           arrayDesc.Format != CU_AD_FORMAT_FLOAT) {
-        setErrorMessage("PI CUDA kernels only support images with channel "
+        setErrorMessage("UR CUDA kernels only support images with channel "
                         "types int32, uint32, float, and half.",
                         UR_RESULT_ERROR_ADAPTER_SPECIFIC);
         return UR_RESULT_ERROR_ADAPTER_SPECIFIC;

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

@@ -13,6 +13,7 @@
 #include "context.hpp"
 #include "event.hpp"
 #include "kernel.hpp"
+#include "logger/ur_logger.hpp"
 #include "memory.hpp"
 #include "queue.hpp"
 #include "ur_api.h"
@@ -1407,10 +1408,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     // mem_advise.
     if (!Device->getManagedMemSupport()) {
       releaseEvent();
-      setErrorMessage("mem_advise ignored as device does not support "
-                      "managed memory access",
-                      UR_RESULT_SUCCESS);
-      return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+      logger::warning("mem_advise ignored as device does not support "
+                      "managed memory access.");
     }
 
     hipPointerAttribute_t attribs;
@@ -1423,8 +1422,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     // async prefetch requires USM pointer (or hip SVM) to work.
     if (!attribs.isManaged) {
       releaseEvent();
-      setErrorMessage("Prefetch hint ignored as prefetch only works with USM",
-                      UR_RESULT_SUCCESS);
+      logger::warning("Prefetch hint ignored as prefetch only works with USM.");
       return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
     }
 
@@ -1480,10 +1478,8 @@ urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
     // mem_advise.
     if (!Device->getManagedMemSupport()) {
       releaseEvent();
-      setErrorMessage("mem_advise ignored as device does not support "
-                      "managed memory access",
-                      UR_RESULT_SUCCESS);
-      return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+      logger::warning("mem_advise ignored as device does not support "
+                      "managed memory access.");
     }
 
     // Passing MEM_ADVICE_SET/MEM_ADVICE_CLEAR_PREFERRED_LOCATION to
@@ -1498,10 +1494,8 @@ urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
                   UR_USM_ADVICE_FLAG_DEFAULT)) {
       if (!Device->getConcurrentManagedAccess()) {
         releaseEvent();
-        setErrorMessage("mem_advise ignored as device does not support "
-                        "concurrent managed access",
-                        UR_RESULT_SUCCESS);
-        return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+        logger::warning("mem_advise ignored as device does not support "
+                        "concurrent memory access.");
       }
 
       // TODO: If pMem points to valid system-allocated pageable memory, we
@@ -1519,9 +1513,8 @@ urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
     if (auto ptrAttribs = getPointerAttributes(pMem);
         !ptrAttribs || !ptrAttribs->isManaged) {
       releaseEvent();
-      setErrorMessage("mem_advise is ignored as the pointer argument is not "
-                      "a shared USM pointer",
-                      UR_RESULT_SUCCESS);
+      logger::warning("mem_advise is ignored as the pointer argument is not "
+                      "a shared USM pointer.");
       return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
     }
 
@@ -1549,10 +1542,8 @@ urEnqueueUSMAdvise(ur_queue_handle_t hQueue, const void *pMem, size_t size,
       // the runtime.
       if (Result == UR_RESULT_ERROR_INVALID_ENUMERATION) {
         releaseEvent();
-        setErrorMessage("mem_advise is ignored as the advice argument is not "
-                        "supported by this device",
-                        UR_RESULT_SUCCESS);
-        return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
+        logger::warning("mem_advise is ignored as the advice argument is not "
+                        "supported by this device.");
       }
       UR_CHECK_ERROR(Result);
     }

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

@@ -16,14 +16,6 @@ namespace cl_adapter {
 thread_local int32_t ErrorMessageCode = 0;
 thread_local char ErrorMessage[MaxMessageSize]{};
 
-[[maybe_unused]] void setErrorMessage(const char *Message, int32_t ErrorCode) {
-  assert(strlen(Message) < cl_adapter::MaxMessageSize);
-  // Copy at most MaxMessageSize - 1 bytes to ensure the resultant string is
-  // always null terminated.
-  strncpy(cl_adapter::ErrorMessage, Message, MaxMessageSize - 1);
-
-  ErrorMessageCode = ErrorCode;
-}
 } // namespace cl_adapter
 
 ur_result_t mapCLErrorToUR(cl_int Result) {

unified-runtime/source/common/logger/ur_sinks.hpp

@@ -240,7 +240,7 @@ class CallbackSink : public Sink {
   virtual void print(ur_logger_level_t level, const std::string &msg) override {
     if (callback) {
       callback(level, msg.c_str(), userData);
-    } 
+    }
   }
 };