[UR] added filename and line number to logs

Co-authored-by: Łukasz Ślusarczyk <[email protected]>
Co-authored-by: Mateusz P. Nowak <[email protected]>

Author: mateuszpn

unified-runtime/scripts/templates/valddi.cpp.mako

@@ -93,7 +93,7 @@ namespace ur_validation_layer
             %>
             %if tp_input_handle_funcs and not is_related_create_get_retain_release_func:
             if (getContext()->enableLifetimeValidation && !getContext()->refCountContext->isReferenceValid(${tp['name']})) {
-                getContext()->refCountContext->logInvalidReference(${tp['name']});
+                URLOG_CTX_INVALID_REFERENCES(${tp['name']});
             }
             %endif
             %endfor

unified-runtime/source/CMakeLists.txt

@@ -6,6 +6,9 @@
 add_definitions(-DUR_VERSION="${PROJECT_VERSION_MAJOR}")
 add_definitions(-DUR_VALIDATION_LAYER_SUPPORTED_VERSION="${PROJECT_VERSION_MAJOR}")
 
+string(LENGTH "${CMAKE_SOURCE_DIR}/" SRC_PATH_SIZE)
+add_definitions("-DSRC_PATH_SIZE=${SRC_PATH_SIZE}")  # for nicer log messages
+
 add_subdirectory(common)
 add_subdirectory(loader)
 add_subdirectory(mock)

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

@@ -29,10 +29,10 @@
 #define UR_CALL(Call, Result)                                                  \
   {                                                                            \
     if (PrintTrace)                                                            \
-      logger::always("UR ---> {}", #Call);                                     \
+      URLOG_ALWAYS("UR ---> {}", #Call);                                       \
     Result = (Call);                                                           \
     if (PrintTrace)                                                            \
-      logger::always("UR <--- {}({})", #Call, Result);                         \
+      URLOG_ALWAYS("UR <--- {}({})", #Call, Result);                           \
   }
 
 enum class CommandType {

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

@@ -53,7 +53,7 @@ void checkErrorUR(CUresult Result, const char *Function, int Line,
      << "\n\tDescription:     " << ErrorString
      << "\n\tFunction:        " << Function << "\n\tSource Location: " << File
      << ":" << Line << "\n";
-  logger::error("{}", SS.str());
+  URLOG(ERR, "{}", SS.str());
 
   if (std::getenv("PI_CUDA_ABORT") != nullptr ||
       std::getenv("UR_CUDA_ABORT") != nullptr) {
@@ -73,7 +73,7 @@ void checkErrorUR(ur_result_t Result, const char *Function, int Line,
   SS << "\nUR ERROR:"
      << "\n\tValue:           " << Result << "\n\tFunction:        " << Function
      << "\n\tSource Location: " << File << ":" << Line << "\n";
-  logger::error("{}", SS.str());
+  URLOG(ERR, "{}", SS.str());
 
   if (std::getenv("PI_CUDA_ABORT") != nullptr) {
     std::abort();
@@ -93,7 +93,7 @@ std::string getCudaVersionString() {
 }
 
 void detail::ur::die(const char *Message) {
-  logger::always("ur_die:{}", Message);
+  URLOG_ALWAYS("ur_die:{}", Message);
   std::terminate();
 }
 

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

@@ -284,7 +284,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     } else if (std::getenv("SYCL_UR_CUDA_ENABLE_IMAGE_SUPPORT") != nullptr) {
       Enabled = true;
     } else {
-      logger::always(
+      URLOG_ALWAYS(
           "Images are not fully supported by the CUDA BE, their support is "
           "disabled by default. Their partial support can be activated by "
           "setting SYCL_UR_CUDA_ENABLE_IMAGE_SUPPORT environment variable at "

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

@@ -806,8 +806,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageCopyExp(
 
       // we don't support copying between different image types.
       if (pSrcImageDesc->type != pDstImageDesc->type) {
-        logger::error(
-            "Unsupported copy operation between different type of images");
+        URLOG(ERR,
+              "Unsupported copy operation between different type of images");
         return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
       }
 

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

@@ -86,7 +86,7 @@ void checkErrorUR(amd_comgr_status_t Result, const char *Function, int Line,
      << "\n\tDescription:     " << ErrorString
      << "\n\tFunction:        " << Function << "\n\tSource Location: " << File
      << ":" << Line << "\n";
-  logger::error("{}", SS.str());
+  URLOG(ERR, "{}", SS.str());
 
   if (std::getenv("PI_HIP_ABORT") != nullptr ||
       std::getenv("UR_HIP_ABORT") != nullptr) {
@@ -113,7 +113,7 @@ void checkErrorUR(hipError_t Result, const char *Function, int Line,
      << "\n\tDescription:     " << ErrorString
      << "\n\tFunction:        " << Function << "\n\tSource Location: " << File
      << ":" << Line << "\n";
-  logger::error("{}", SS.str());
+  URLOG(ERR, "{}", SS.str());
 
   if (std::getenv("PI_HIP_ABORT") != nullptr ||
       std::getenv("UR_HIP_ABORT") != nullptr) {
@@ -133,7 +133,7 @@ void checkErrorUR(ur_result_t Result, const char *Function, int Line,
   SS << "\nUR HIP ERROR:"
      << "\n\tValue:           " << Result << "\n\tFunction:        " << Function
      << "\n\tSource Location: " << File << ":" << Line << "\n";
-  logger::error("{}", SS.str());
+  URLOG(ERR, "{}", SS.str());
 
   if (std::getenv("PI_HIP_ABORT") != nullptr ||
       std::getenv("UR_HIP_ABORT") != nullptr) {
@@ -157,7 +157,7 @@ hipError_t getHipVersionString(std::string &Version) {
 }
 
 void detail::ur::die(const char *pMessage) {
-  logger::always("ur_die: {}", pMessage);
+  URLOG_ALWAYS("ur_die: {}", pMessage);
   std::terminate();
 }
 

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

@@ -825,8 +825,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageCopyExp(
 
       // we don't support copying between different image types.
       if (pSrcImageDesc->type != pDstImageDesc->type) {
-        logger::error(
-            "Unsupported copy operation between different type of images");
+        URLOG(ERR,
+              "Unsupported copy operation between different type of images");
         return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
       }
 

unified-runtime/source/adapters/level_zero/adapter.cpp

@@ -163,7 +163,7 @@ ur_result_t initPlatforms(PlatformVec &platforms,
     ZE2UR_CALL(zeDriverGet, (&ZeDriverGetCount, ZeDriverGetHandles.data()));
   }
   if (ZeDriverGetCount == 0 && GlobalAdapter->ZeInitDriversCount == 0) {
-    logger::error("\nNo Valid L0 Drivers found.\n");
+    URLOG(ERR, "\nNo Valid L0 Drivers found.\n");
     return UR_RESULT_SUCCESS;
   }
 
@@ -188,9 +188,10 @@ ur_result_t initPlatforms(PlatformVec &platforms,
           // newer drivers.
           if (ZeDriverGetProperties.driverVersion !=
               ZeInitDriverProperties.driverVersion) {
-            logger::debug("\nzeDriverHandle {} added to the zeInitDrivers list "
-                          "of possible handles.\n",
-                          ZeDriverGetHandles[Y]);
+            URLOG(DEBUG,
+                  "\nzeDriverHandle {} added to the zeInitDrivers list "
+                  "of possible handles.\n",
+                  ZeDriverGetHandles[Y]);
             ZeDrivers.push_back(ZeDriverGetHandles[Y]);
           }
         }
@@ -201,7 +202,7 @@ ur_result_t initPlatforms(PlatformVec &platforms,
     ZeDrivers.assign(ZeDriverGetHandles.begin(), ZeDriverGetHandles.end());
   }
   ZeDriverCount = ZeDrivers.size();
-  logger::debug("\n{} L0 Drivers found.\n", ZeDriverCount);
+  URLOG(DEBUG, "\n{} L0 Drivers found.\n", ZeDriverCount);
   for (uint32_t I = 0; I < ZeDriverCount; ++I) {
     // Keep track of the first platform init for this Driver
     bool DriverPlatformInit = false;
@@ -359,8 +360,8 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
       }
 
       if (getenv("SYCL_ENABLE_PCI") != nullptr) {
-        logger::warning(
-            "WARNING: SYCL_ENABLE_PCI is deprecated and no longer needed.\n");
+        URLOG(WARN,
+              "WARNING: SYCL_ENABLE_PCI is deprecated and no longer needed.\n");
       }
 
       // TODO: We can still safely recover if something goes wrong during the
@@ -381,13 +382,13 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
       if (UrL0InitAllDrivers) {
         L0InitFlags |= ZE_INIT_FLAG_VPU_ONLY;
       }
-      logger::debug("\nzeInit with flags value of {}\n",
-                    static_cast<int>(L0InitFlags));
+      URLOG(DEBUG, "\nzeInit with flags value of {}\n",
+            static_cast<int>(L0InitFlags));
       GlobalAdapter->ZeInitResult = ZE_CALL_NOCHECK(zeInit, (L0InitFlags));
       if (GlobalAdapter->ZeInitResult != ZE_RESULT_SUCCESS) {
         const char *ErrorString = "Unknown";
         zeParseError(GlobalAdapter->ZeInitResult, ErrorString);
-        logger::error("\nzeInit failed with {}\n", ErrorString);
+        URLOG(ERR, "\nzeInit failed with {}\n", ErrorString);
       }
 
       bool useInitDrivers = false;
@@ -403,9 +404,9 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
             if (strncmp(versions[i].component_name, "loader",
                         strlen("loader")) == 0) {
               loader_version = versions[i].component_lib_version;
-              logger::debug("\nLevel Zero Loader Version: {}.{}.{}\n",
-                            loader_version.major, loader_version.minor,
-                            loader_version.patch);
+              URLOG(DEBUG, "\nLevel Zero Loader Version: {}.{}.{}\n",
+                    loader_version.major, loader_version.minor,
+                    loader_version.patch);
               break;
             }
           }
@@ -428,8 +429,8 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
                 GlobalAdapter->processHandle, "zeInitDrivers");
 #endif
         if (GlobalAdapter->initDriversFunctionPtr) {
-          logger::debug("\nzeInitDrivers with flags value of {}\n",
-                        static_cast<int>(GlobalAdapter->InitDriversDesc.flags));
+          URLOG(DEBUG, "\nzeInitDrivers with flags value of {}\n",
+                static_cast<int>(GlobalAdapter->InitDriversDesc.flags));
           GlobalAdapter->ZeInitDriversResult =
               ZE_CALL_NOCHECK(GlobalAdapter->initDriversFunctionPtr,
                               (&GlobalAdapter->ZeInitDriversCount, nullptr,
@@ -439,7 +440,7 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
           } else {
             const char *ErrorString = "Unknown";
             zeParseError(GlobalAdapter->ZeInitDriversResult, ErrorString);
-            logger::error("\nzeInitDrivers failed with {}\n", ErrorString);
+            URLOG(ERR, "\nzeInitDrivers failed with {}\n", ErrorString);
           }
         }
       }
@@ -457,12 +458,12 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
 
     // Absorb the ZE_RESULT_ERROR_UNINITIALIZED and just return 0 Platforms.
     if (*GlobalAdapter->ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
-      logger::error("Level Zero Uninitialized\n");
+      URLOG(ERR, "Level Zero Uninitialized\n");
       result = std::move(platforms);
       return;
     }
     if (*GlobalAdapter->ZeResult != ZE_RESULT_SUCCESS) {
-      logger::error("Level Zero initialization failure\n");
+      URLOG(ERR, "Level Zero initialization failure\n");
       result = ze2urResult(*GlobalAdapter->ZeResult);
 
       return;
@@ -509,8 +510,8 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
         GlobalAdapter->getSysManDriversFunctionPtr &&
         GlobalAdapter->sysManInitFunctionPtr) {
       ze_init_flags_t L0ZesInitFlags = 0;
-      logger::debug("\nzesInit with flags value of {}\n",
-                    static_cast<int>(L0ZesInitFlags));
+      URLOG(DEBUG, "\nzesInit with flags value of {}\n",
+            static_cast<int>(L0ZesInitFlags));
       GlobalAdapter->ZesResult = ZE_CALL_NOCHECK(
           GlobalAdapter->sysManInitFunctionPtr, (L0ZesInitFlags));
     } else {

unified-runtime/source/adapters/level_zero/async_alloc.cpp

@@ -92,7 +92,7 @@ static ur_result_t enqueueUSMAllocHelper(
     CommandType = UR_COMMAND_ENQUEUE_USM_SHARED_ALLOC_EXP;
     break;
   default:
-    logger::error("enqueueUSMAllocHelper: unsupported USM type");
+    URLOG(ERR, "enqueueUSMAllocHelper: unsupported USM type");
     throw UR_RESULT_ERROR_UNKNOWN;
   }
   UR_CALL(createEventAndAssociateQueue(Queue, Event, CommandType, CommandList,