Merge branch 'sycl' into win-e2esplit

ayylol · ayylol · commit 1c6ff22f254e · 2025-03-31T07:37:00.000-07:00
diff --git a/.github/workflows/sycl-windows-run-tests.yml b/.github/workflows/sycl-windows-run-tests.yml
@@ -177,14 +177,22 @@ jobs:
 
     - name: Run End-to-End tests
       if: inputs.tests_selector == 'e2e'
-      shell: bash
+      shell: bash {0}
       run: |
         # Run E2E tests.
         if [[ ${{inputs.compiler}} == 'icx' ]]; then
            export LIT_FILTER_OUT="compile_on_win_with_mdd"
         fi
         export LIT_OPTS="-v --no-progress-bar --show-unsupported --show-pass --show-xfail --max-time 3600 --time-tests --param test-mode=${{ inputs.e2e_testing_mode }} ${{ inputs.extra_lit_opts }}"
-        cmake --build build-e2e --target check-sycl-e2e
+        cmake --build build-e2e --target check-sycl-e2e > e2e.log 2>&1
+
+        exit_code=$?
+        cat e2e.log
+        if [ $exit_code -ne 0 ]; then
+          # This is duplicated between lin/win, updates must change both.
+          awk '/^Failed Tests|Unexpectedly Passed Tests|Unresolved tests|Timed Out Tests|Testing Time/{flag=1}/FAILED: CMakeFiles/{flag=0}flag' e2e.log >> $GITHUB_STEP_SUMMARY
+        fi
+        exit $exit_code
 
     # Github CI doesn't support containers on Windows, so we cannot guarantee
     # that paths are the same between building and running systems. To avoid
diff --git a/devops/actions/run-tests/cts/action.yml b/devops/actions/run-tests/cts/action.yml
@@ -67,7 +67,7 @@ runs:
         # SYCL_CTS_EXCLUDE_TEST_CATEGORIES - Optional file specifying a list
         # of test categories to be excluded from the build.
         echo "::group::Excluded test categories"
-        cat $cts_exclude_filter
+        [ -f "$cts_exclude_filter" ] && cat "$cts_exclude_filter"
         echo "::endgroup::"
       fi
 
@@ -134,11 +134,13 @@ runs:
         cts_exclude_filter=$PWD/sycl/cts_exclude_filter/L0_GPU
       fi
 
-      while IFS= read -r line; do
-        if [[ $line != \#* ]]; then
-          rm "./build-cts/bin/test_$line"
-        fi
-      done < "$cts_exclude_filter"
+      if [ -f "$cts_exclude_filter" ]; then
+        while IFS= read -r line; do
+          if [[ $line != \#* ]]; then
+            rm "./build-cts/bin/test_$line"
+          fi
+        done < "$cts_exclude_filter"
+      fi
 
   - name: Run SYCL CTS tests
     # Proceed with execution even if the previous two steps did not succeed.
diff --git a/devops/actions/run-tests/e2e/action.yml b/devops/actions/run-tests/e2e/action.yml
@@ -65,6 +65,7 @@ runs:
       exit_code=$?
       cat e2e.log
       if [ $exit_code -ne 0 ]; then
+        # This is duplicated between lin/win, updates must change both.
         awk '/^Failed Tests|Unexpectedly Passed Tests|Unresolved tests|Timed Out Tests|Testing Time/{flag=1}/FAILED: CMakeFiles/{flag=0}flag' e2e.log >> $GITHUB_STEP_SUMMARY
       fi
       exit $exit_code
diff --git a/devops/actions/run-tests/windows/cts/action.yml b/devops/actions/run-tests/windows/cts/action.yml
@@ -67,7 +67,7 @@ runs:
         # SYCL_CTS_EXCLUDE_TEST_CATEGORIES - Optional file specifying a list
         # of test categories to be excluded from the build.
         echo "::group::Excluded test categories"
-        cat $cts_exclude_filter
+        [ -f "$cts_exclude_filter" ] && cat "$cts_exclude_filter"
         echo "::endgroup::"
       fi
 
@@ -136,11 +136,13 @@ runs:
         cts_exclude_filter=$PWD/sycl/cts_exclude_filter/L0_GPU
       fi
 
-      while IFS= read -r line; do
-        if [[ $line != \#* ]]; then
-          rm "./build-cts/bin/test_$line"
-        fi
-      done < "$cts_exclude_filter"
+      if [ -f "$cts_exclude_filter" ]; then
+        while IFS= read -r line; do
+          if [[ $line != \#* ]]; then
+            rm "./build-cts/bin/test_$line"
+          fi
+        done < "$cts_exclude_filter"
+      fi
 
   - name: Run SYCL CTS tests
     # Proceed with execution even if the previous two steps did not succeed.
diff --git a/llvm/cmake/modules/AddSecurityFlags.cmake b/llvm/cmake/modules/AddSecurityFlags.cmake
@@ -31,7 +31,7 @@ macro(add_link_option_ext flag name)
   endif()
 endmacro()
 
-function(append_common_extra_security_flags)
+macro(append_common_extra_security_flags)
   if( LLVM_ON_UNIX )
     # Fortify Source (strongly recommended):
     if (CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -70,7 +70,7 @@ function(append_common_extra_security_flags)
       CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS
       CMAKE_SHARED_LINKER_FLAGS)
   endif()
-endfunction()
+endmacro()
 
 if ( EXTRA_SECURITY_FLAGS )
     if (EXTRA_SECURITY_FLAGS STREQUAL "none")
diff --git a/sycl/include/sycl/detail/os_util.hpp b/sycl/include/sycl/detail/os_util.hpp
@@ -120,9 +120,13 @@ fn *dynLookupFunction(const char *WinName, const char *LinName,
                       const char *FunName) {
   return reinterpret_cast<fn *>(dynLookup(WinName, LinName, FunName));
 }
+// On Linux, the name of OpenCL that was used to link against may be either
+// `OpenCL.so`, `OpenCL.so.1` or possibly anything else.
+// `libur_adapter_opencl.so` is a more stable name, since it is hardcoded into
+// the loader.
 #define __SYCL_OCL_CALL(FN, ...)                                               \
   (sycl::_V1::detail::dynLookupFunction<decltype(FN)>(                         \
-      "OpenCL", "libOpenCL.so", #FN)(__VA_ARGS__))
+      "OpenCL", "libur_adapter_opencl.so", #FN)(__VA_ARGS__))
 
 } // namespace detail
 } // namespace _V1
diff --git a/sycl/include/sycl/ext/oneapi/experimental/graph.hpp b/sycl/include/sycl/ext/oneapi/experimental/graph.hpp
@@ -549,15 +549,16 @@ class dynamic_work_group_memory_base
 {
 public:
   dynamic_work_group_memory_base() = default;
-  dynamic_work_group_memory_base(
-      [[maybe_unused]] experimental::command_graph<graph_state::modifiable>
-          Graph,
-      [[maybe_unused]] size_t Size)
 #ifndef __SYCL_DEVICE_ONLY__
-      : dynamic_parameter_base(Graph), BufferSize(Size)
+  dynamic_work_group_memory_base(
+      experimental::command_graph<graph_state::modifiable> Graph, size_t Size)
+      : dynamic_parameter_base(Graph), BufferSize(Size) {}
+#else
+  dynamic_work_group_memory_base(
+      experimental::command_graph<graph_state::modifiable> /*Graph*/,
+      size_t Size)
+      : BufferSize(Size) {}
 #endif
-  {
-  }
 
 private:
 #ifdef __SYCL_DEVICE_ONLY__
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
@@ -213,6 +213,7 @@ class HandlerAccess;
 class HostTask;
 
 using EventImplPtr = std::shared_ptr<event_impl>;
+using DeviceImplPtr = std::shared_ptr<device_impl>;
 
 template <typename RetType, typename Func, typename Arg>
 static Arg member_ptr_helper(RetType (Func::*)(Arg) const);
@@ -249,6 +250,7 @@ template <typename Type> struct get_kernel_wrapper_name_t {
 };
 
 __SYCL_EXPORT device getDeviceFromHandler(handler &);
+const DeviceImplPtr &getDeviceImplFromHandler(handler &);
 
 // Checks if a device_global has any registered kernel usage.
 __SYCL_EXPORT bool isDeviceGlobalUsedInKernel(const void *DeviceGlobalPtr);
@@ -3481,6 +3483,8 @@ class __SYCL_EXPORT handler {
             typename PropertyListT>
   friend class accessor;
   friend device detail::getDeviceFromHandler(handler &);
+  friend const detail::DeviceImplPtr &
+  detail::getDeviceImplFromHandler(handler &);
 
   template <typename DataT, int Dimensions, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
diff --git a/sycl/source/detail/cg.hpp b/sycl/source/detail/cg.hpp
@@ -686,7 +686,7 @@ class CGAsyncAlloc : public CG {
       ur_event_handle_t event, CG::StorageInitHelper CGData,
       detail::code_location loc = {})
       : CG(CGType::AsyncAlloc, std::move(CGData), std::move(loc)), MSize(size),
-        MMemPool(MemPool), MEvent(event) {}
+        MMemPool(std::move(MemPool)), MEvent(event) {}
 
   std::shared_ptr<ext::oneapi::experimental::detail::memory_pool_impl>
   getMemPool() const {
diff --git a/sycl/source/detail/context_impl.cpp b/sycl/source/detail/context_impl.cpp
@@ -567,7 +567,7 @@ void context_impl::verifyProps(const property_list &Props) const {
 std::shared_ptr<sycl::ext::oneapi::experimental::detail::memory_pool_impl>
 context_impl::get_default_memory_pool(const context &Context,
                                       const device &Device,
-                                      const usm::alloc &Kind) {
+                                      [[maybe_unused]] const usm::alloc &Kind) {
 
   assert(Kind == usm::alloc::device);
 
diff --git a/sycl/source/detail/graph_impl.hpp b/sycl/source/detail/graph_impl.hpp
@@ -919,6 +919,12 @@ class graph_impl : public std::enable_shared_from_this<graph_impl> {
   /// @return Context associated with graph.
   sycl::context getContext() const { return MContext; }
 
+  /// Query for the device_impl tied to this graph.
+  /// @return device_impl shared ptr reference associated with graph.
+  const DeviceImplPtr &getDeviceImplPtr() const {
+    return getSyclObjImpl(MDevice);
+  }
+
   /// Query for the device tied to this graph.
   /// @return Device associated with graph.
   sycl::device getDevice() const { return MDevice; }
diff --git a/sycl/source/detail/handler_impl.hpp b/sycl/source/detail/handler_impl.hpp
@@ -207,8 +207,8 @@ class handler_impl {
   /// potential logging.
   /// Event computed from async alloc which is passed through for processing.
   std::shared_ptr<ext::oneapi::experimental::detail::memory_pool_impl> MMemPool;
-  size_t MAllocSize;
-  ur_event_handle_t MAsyncAllocEvent;
+  size_t MAllocSize = 0;
+  ur_event_handle_t MAsyncAllocEvent = nullptr;
 
   // Allocation ptr to be freed asynchronously.
   void *MFreePtr = nullptr;
diff --git a/sycl/source/detail/memory_pool_impl.cpp b/sycl/source/detail/memory_pool_impl.cpp
@@ -123,10 +123,14 @@ memory_pool_impl::~memory_pool_impl() {
   if (MIsDefaultPool)
     return;
 
-  ur_usm_pool_handle_t handle = this->get_handle();
-  sycl::context ctx = this->get_context();
-  sycl::device dev = this->get_device();
-  destroy_memory_pool(ctx, dev, handle);
+  try {
+    ur_usm_pool_handle_t handle = this->get_handle();
+    sycl::context ctx = this->get_context();
+    sycl::device dev = this->get_device();
+    destroy_memory_pool(ctx, dev, handle);
+  } catch (std::exception &e) {
+    __SYCL_REPORT_EXCEPTION_TO_STREAM("exception in ~memory_pool_impl", e);
+  }
 }
 
 size_t memory_pool_impl::get_threshold() const {
diff --git a/sycl/source/detail/scheduler/commands.cpp b/sycl/source/detail/scheduler/commands.cpp
@@ -3750,6 +3750,7 @@ ur_result_t ExecCGCommand::enqueueImpQueue() {
     return UR_RESULT_SUCCESS;
   }
   case CGType::AsyncFree: {
+    assert(MQueue && "Async free submissions should have an associated queue");
     CGAsyncFree *AsyncFree = (CGAsyncFree *)MCommandGroup.get();
     const detail::AdapterPtr &Adapter = MQueue->getAdapter();
     void *ptr = AsyncFree->getPtr();
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
@@ -43,6 +43,15 @@ inline namespace _V1 {
 
 namespace detail {
 
+const DeviceImplPtr &getDeviceImplFromHandler(handler &CGH) {
+  assert((CGH.MQueue || getSyclObjImpl(CGH)->MGraph) &&
+         "One of MQueue or MGraph should be nonnull!");
+  if (CGH.MQueue)
+    return CGH.MQueue->getDeviceImplPtr();
+
+  return getSyclObjImpl(CGH)->MGraph->getDeviceImplPtr();
+}
+
 bool isDeviceGlobalUsedInKernel(const void *DeviceGlobalPtr) {
   DeviceGlobalMapEntry *DGEntry =
       detail::ProgramManager::getInstance().getDeviceGlobalEntry(
@@ -2059,10 +2068,10 @@ void handler::setUserFacingNodeType(ext::oneapi::experimental::node_type Type) {
 }
 
 std::optional<std::array<size_t, 3>> handler::getMaxWorkGroups() {
-  auto Dev = detail::getSyclObjImpl(detail::getDeviceFromHandler(*this));
+  const auto &DeviceImpl = detail::getDeviceImplFromHandler(*this);
   std::array<size_t, 3> UrResult = {};
-  auto Ret = Dev->getAdapter()->call_nocheck<UrApiKind::urDeviceGetInfo>(
-      Dev->getHandleRef(),
+  auto Ret = DeviceImpl->getAdapter()->call_nocheck<UrApiKind::urDeviceGetInfo>(
+      DeviceImpl->getHandleRef(),
       UrInfoCode<
           ext::oneapi::experimental::info::device::max_work_groups<3>>::value,
       sizeof(UrResult), &UrResult, nullptr);
diff --git a/sycl/unittests/mock_opencl/CMakeLists.txt b/sycl/unittests/mock_opencl/CMakeLists.txt
@@ -1,9 +1,17 @@
 get_target_property(SYCL_BINARY_DIR sycl-toolchain BINARY_DIR)
 
+# Linux looks up ur_adapter_opencl rather than libOpenCL.
+# On Windows, this is copied into libOpenCL.dll.
+if(WIN32)
+  set(LIBNAME OpenCL)
+else()
+  set(LIBNAME ur_adapter_opencl)
+endif()
+
 add_library(mockOpenCL SHARED EXCLUDE_FROM_ALL mock_opencl.cpp)
 set_target_properties(mockOpenCL PROPERTIES
   LIBRARY_OUTPUT_DIRECTORY ${SYCL_BINARY_DIR}/unittests/lib
-  LIBRARY_OUTPUT_NAME OpenCL
+  LIBRARY_OUTPUT_NAME ${LIBNAME}
   RUNTIME_OUTPUT_DIRECTORY ${SYCL_BINARY_DIR}/unittests/lib
-  RUNTIME_OUTPUT_NAME OpenCL
+  RUNTIME_OUTPUT_NAME ${LIBNAME}
 )
diff --git a/unified-runtime/source/adapters/cuda/device.cpp b/unified-runtime/source/adapters/cuda/device.cpp
@@ -1089,8 +1089,13 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
   case UR_DEVICE_INFO_CURRENT_CLOCK_THROTTLE_REASONS: {
     unsigned long long ClocksEventReasons;
+#if (CUDA_VERSION >= 12060)
     UR_CHECK_ERROR(nvmlDeviceGetCurrentClocksEventReasons(hDevice->getNVML(),
                                                           &ClocksEventReasons));
+#else
+    UR_CHECK_ERROR(nvmlDeviceGetCurrentClocksThrottleReasons(
+        hDevice->getNVML(), &ClocksEventReasons));
+#endif
     ur_device_throttle_reasons_flags_t ThrottleReasons = 0;
     constexpr unsigned long long NVMLThrottleFlags[] = {
         nvmlClocksThrottleReasonSwPowerCap,
diff --git a/unified-runtime/source/loader/layers/sanitizer/msan/msan_report.cpp b/unified-runtime/source/loader/layers/sanitizer/msan/msan_report.cpp
@@ -36,7 +36,7 @@ void ReportUsesUninitializedValue(const MsanErrorReport &Report,
         (void *)Report.Origin);
   } else {
     getContext()->logger.always(
-        "====WARNING: DeviceSanitizer: use-of-uninitialized-value)");
+        "====WARNING: DeviceSanitizer: use-of-uninitialized-value");
   }
 
   getContext()->logger.always(
