Merge of 'upstream/sycl' into urlog and minor fixes

Author: mateuszpn

.github/workflows/ur-source-checks.yml

@@ -33,7 +33,7 @@ jobs:
       if: matrix.os == 'ubuntu-22.04'
       run: |
         sudo apt-get update
-        sudo apt-get install -y doxygen
+        sudo apt-get install -y doxygen libhwloc-dev
 
     - name: "[Win] Install doxygen"
       if: matrix.os == 'windows-2022'
@@ -53,7 +53,6 @@ jobs:
         -DCMAKE_BUILD_TYPE=Debug
         -DUR_BUILD_TESTS=OFF
         -DUR_FORMAT_CPP_STYLE=ON
-        -DUMF_DISABLE_HWLOC=ON
 
     # Verifying license should be enough on a single OS
     - name: Verify that each source file contains a license

llvm/lib/SYCLLowerIR/ESIMD/ESIMDVerifier.cpp

@@ -97,6 +97,8 @@ class BuffDeleter {
   BuffDeleter() = delete;
   BuffDeleter(const BuffDeleter &) = delete;
   BuffDeleter(BuffDeleter &&) = delete;
+  BuffDeleter &operator=(BuffDeleter &) = delete;
+  BuffDeleter &operator=(BuffDeleter &&) = delete;
 
 private:
   char *Buff;

sycl/cmake/modules/FetchUnifiedRuntime.cmake

@@ -87,8 +87,6 @@ if(IS_DIRECTORY "${UR_INTREE_SOURCE_DIR}")
   if(WIN32)
     set(UMF_BUILD_SHARED_LIBRARY OFF CACHE INTERNAL "Build UMF shared library")
     set(UMF_LINK_HWLOC_STATICALLY ON CACHE INTERNAL "static HWLOC")
-  else()
-    set(UMF_DISABLE_HWLOC ${SYCL_UMF_DISABLE_HWLOC} CACHE INTERNAL "Disable hwloc for UMF")
   endif()
   add_subdirectory(${UNIFIED_RUNTIME_SOURCE_DIR} ${UR_INTREE_BINARY_DIR})
 elseif(SYCL_UR_USE_FETCH_CONTENT)

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

@@ -48,7 +48,7 @@ namespace ur_tracing_layer
         uint64_t instance = getContext()->notify_begin(${th.make_func_etor(n, tags, obj)}, "${th.make_func_name(n, tags, obj)}", &params);
 
         auto &logger = getContext()->logger;
-        logger.info("   ---> ${th.make_func_name(n, tags, obj)}\n");
+        URLOG_(logger, INFO, "   ---> ${th.make_func_name(n, tags, obj)}\n");
 
         ${x}_result_t result = ${th.make_pfn_name(n, tags, obj)}( ${", ".join(th.make_param_lines(n, tags, obj, format=["name"]))} );
 
@@ -57,7 +57,7 @@ namespace ur_tracing_layer
         if (logger.getLevel() <= logger::Level::INFO) {
             std::ostringstream args_str;
             ur::extras::printFunctionParams(args_str, ${th.make_func_etor(n, tags, obj)}, &params);
-            logger.info("   <--- ${th.make_func_name(n, tags, obj)}({}) -> {};\n", args_str.str(), result);
+            URLOG_(logger, INFO, "   <--- ${th.make_func_name(n, tags, obj)}({}) -> {};\n", args_str.str(), result);
         }
 
         return result;

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']})) {
-                URLOG_CTX_INVALID_REFERENCES(${tp['name']});
+                URLOG_CTX_INVALID_REFERENCE(${tp['name']});
             }
             %endif
             %endfor
@@ -234,7 +234,7 @@ namespace ur_validation_layer
 
     ${x}_result_t context_t::tearDown() {
         if (enableLeakChecking) {
-            getContext()->refCountContext->logInvalidReferences();
+            URLOG_CTX_INVALID_REFERENCES();
         }
 
         return ${X}_RESULT_SUCCESS;

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

@@ -95,7 +95,7 @@ void checkErrorUR(nvmlReturn_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_CUDA_ABORT") != nullptr ||
       std::getenv("UR_CUDA_ABORT") != nullptr) {

unified-runtime/source/loader/layers/sanitizer/tsan/tsan_buffer.cpp

@@ -105,8 +105,8 @@ ur_result_t MemBuffer::getHandle(ur_device_handle_t Device, char *&Handle) {
                                                 Size, AllocType::DEVICE_USM,
                                                 ur_cast<void **>(&Allocation));
     if (URes != UR_RESULT_SUCCESS) {
-      URLOG_CTX(ERR, "Failed to allocate {} bytes memory for buffer {}",
-                Size, this);
+      URLOG_CTX(ERR, "Failed to allocate {} bytes memory for buffer {}", Size,
+                this);
       return URes;
     }
 

unified-runtime/source/loader/layers/sanitizer/tsan/tsan_interceptor.cpp

@@ -294,8 +294,7 @@ ur_result_t TsanInterceptor::prepareLaunch(std::shared_ptr<ContextInfo> &,
       ur_result_t URes = getContext()->urDdiTable.Kernel.pfnSetArgPointer(
           Kernel, ArgIndex, nullptr, ArgPointer);
       if (URes != UR_RESULT_SUCCESS) {
-        URLOG_CTX(ERR,
-                  "Failed to set buffer {} as the {} arg to kernel {}: {}",
+        URLOG_CTX(ERR, "Failed to set buffer {} as the {} arg to kernel {}: {}",
                   ur_cast<ur_mem_handle_t>(MemBuffer.get()), ArgIndex, Kernel,
                   URes);
       }

unified-runtime/test/unit/logger/logger.cpp

@@ -13,49 +13,49 @@
 
 //////////////////////////////////////////////////////////////////////////////
 TEST_F(DefaultLoggerWithFileSink, DefaultLevelNoOutput) {
-  logger->info("This should not be printed: {}", 42);
+  URLOG_(*logger, INFO, "This should not be printed: {}", 42);
   test_msg.clear();
 }
 
 TEST_F(DefaultLoggerWithFileSink, MultipleLines) {
-  logger->warning("Test message: {}", "success");
-  logger->debug("This should not be printed: {}", 42);
-  logger->error("Test message: {}", "success");
+  URLOG_(*logger, WARN, "Test message: {}", "success");
+  URLOG_(*logger, DEBUG, "This should not be printed: {}", 42);
+  URLOG_(*logger, ERR, "Test message: {}", "success");
 
   test_msg << test_msg_prefix << "[WARNING]: Test message: success\n"
            << test_msg_prefix << "[ERROR]: Test message: success\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, ThreeParams) {
-  logger->error("{} {}: {}", "Test", 42, 3.8);
+  URLOG_(*logger, ERR, "{} {}: {}", "Test", 42, 3.8);
   test_msg << test_msg_prefix << "[ERROR]: Test 42: 3.8\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, DoubleBraces) {
-  logger->error("{{}} {}: {}", "Test", 42);
+  URLOG_(*logger, ERR, "{{}} {}: {}", "Test", 42);
   test_msg << test_msg_prefix << "[ERROR]: {} Test: 42\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, DoubleBraces2) {
-  logger->error("200 {{ {}: {{{}}} 3.8", "Test", 42);
+  URLOG_(*logger, ERR, "200 {{ {}: {{{}}} 3.8", "Test", 42);
   test_msg << test_msg_prefix << "[ERROR]: 200 { Test: {42} 3.8\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, DoubleBraces3) {
-  logger->error("{{ {}:}} {}}}", "Test", 42);
+  URLOG_(*logger, ERR, "{{ {}:}} {}}}", "Test", 42);
   test_msg << test_msg_prefix << "[ERROR]: { Test:} 42}\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, NoBraces) {
-  logger->error(" Test: 42");
+  URLOG_(*logger, ERR, " Test: 42");
   test_msg << test_msg_prefix << "[ERROR]:  Test: 42\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, SetLevelDebug) {
   auto level = logger::Level::DEBUG;
   logger->setLevel(level);
   logger->setFlushLevel(level);
-  logger->debug("Test message: {}", "success");
+  URLOG_(*logger, DEBUG, "Test message: {}", "success");
 
   test_msg << test_msg_prefix << "[DEBUG]: Test message: success\n";
 }
@@ -64,25 +64,25 @@ TEST_F(DefaultLoggerWithFileSink, SetLevelInfo) {
   auto level = logger::Level::INFO;
   logger->setLevel(level);
   logger->setFlushLevel(level);
-  logger->info("Test message: {}", "success");
-  logger->debug("This should not be printed: {}", 42);
+  URLOG_(*logger, INFO, "Test message: {}", "success");
+  URLOG_(*logger, DEBUG, "This should not be printed: {}", 42);
 
   test_msg << test_msg_prefix << "[INFO]: Test message: success\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, SetLevelWarning) {
   auto level = logger::Level::WARN;
   logger->setLevel(level);
-  logger->warning("Test message: {}", "success");
-  logger->info("This should not be printed: {}", 42);
+  URLOG_(*logger, WARN, "Test message: {}", "success");
+  URLOG_(*logger, INFO, "This should not be printed: {}", 42);
 
   test_msg << test_msg_prefix << "[WARNING]: Test message: success\n";
 }
 
 TEST_F(DefaultLoggerWithFileSink, SetLevelError) {
   logger->setLevel(logger::Level::ERR);
-  logger->error("Test message: {}", "success");
-  logger->warning("This should not be printed: {}", 42);
+  URLOG_(*logger, ERR, "Test message: {}", "success");
+  URLOG_(*logger, WARN, "This should not be printed: {}", 42);
 
   test_msg << test_msg_prefix << "[ERROR]: Test message: success\n";
 }
@@ -93,7 +93,7 @@ TEST_F(UniquePtrLoggerWithFilesink, SetLogLevelAndFlushLevelDebugWithCtor) {
   logger = std::make_unique<logger::Logger>(
       level, std::make_unique<logger::FileSink>(logger_name, file_path, level));
 
-  logger->debug("Test message: {}", "success");
+  URLOG_(*logger, DEBUG, "Test message: {}", "success");
   test_msg << test_msg_prefix << "[DEBUG]: Test message: success\n";
 }
 
@@ -109,13 +109,13 @@ TEST_F(UniquePtrLoggerWithFilesink, NestedFilePath) {
       logger::Level::WARN, std::make_unique<logger::FileSink>(
                                logger_name, file_path, logger::Level::WARN));
 
-  logger->warning("Test message: {}", "success");
+  URLOG_(*logger, WARN, "Test message: {}", "success");
   test_msg << test_msg_prefix << "[WARNING]: Test message: success\n";
 }
 
 TEST_F(UniquePtrLoggerWithFilesinkFail, NullSink) {
   logger = std::make_unique<logger::Logger>(logger::Level::INFO, nullptr);
-  logger->info("This should not be printed: {}", 42);
+  URLOG_(*logger, INFO, "This should not be printed: {}", 42);
   test_msg.clear();
 }
 
@@ -136,7 +136,7 @@ TEST_P(FileSinkLoggerMultipleThreads, Multithreaded) {
   for (int i = 0; i < thread_count; i++) {
     threads.emplace_back([&]() {
       for (int j = 0; j < message_count; ++j) {
-        local_logger.warn("Test message: {}", "it's a success");
+        URLOG_(local_logger, WARN, "Test message: {}", "it's a success");
       }
     });
   }
@@ -150,7 +150,7 @@ TEST_P(FileSinkLoggerMultipleThreads, Multithreaded) {
   for (int i = 0; i < thread_count; i++) {
     threads.emplace_back([&]() {
       for (int j = 0; j < message_count; ++j) {
-        local_logger.error("Flushed test message: {}", "it's a success");
+        URLOG_(local_logger, ERR, "Flushed test message: {}", "it's a success");
       }
     });
   }
@@ -181,7 +181,7 @@ TEST_P(CommonLoggerWithMultipleThreads, StdoutMultithreaded) {
   for (int i = 0; i < thread_count; i++) {
     threads.emplace_back([&]() {
       for (int j = 0; j < message_count; ++j) {
-        local_logger.warn("Test message: {}", "it's a success");
+        URLOG_(local_logger, WARN, "Test message: {}", "it's a success");
       }
     });
   }
@@ -195,7 +195,7 @@ TEST_P(CommonLoggerWithMultipleThreads, StdoutMultithreaded) {
   for (int i = 0; i < thread_count; i++) {
     threads.emplace_back([&]() {
       for (int j = 0; j < message_count; ++j) {
-        local_logger.error("Flushed test message: {}", "it's a success");
+        URLOG_(local_logger, ERR, "Flushed test message: {}", "it's a success");
       }
     });
   }