Merge remote-tracking branch 'origin/sycl-rel-6_3' into private/asachkov/cherry-pick-ur-patches

Author: AlexeySachkov

sycl/include/sycl/ext/intel/experimental/usm_properties.hpp

@@ -39,16 +39,10 @@ class buffer_location
   uint64_t MLocation;
 };
 
+// If new properties are added here, update `verifyUSMAllocatorProperties` to
+// include them!
+
 } // namespace intel::experimental::property::usm
 } // namespace ext
-
-template <>
-struct is_property<ext::oneapi::property::usm::device_read_only>
-    : std::true_type {};
-
-template <>
-struct is_property<ext::intel::experimental::property::usm::buffer_location>
-    : std::true_type {};
-
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/device_global_map.hpp

@@ -27,10 +27,17 @@ class DeviceGlobalMap {
   DeviceGlobalMap(bool OwnerControlledCleanup)
       : MOwnerControlledCleanup{OwnerControlledCleanup} {}
 
+  DeviceGlobalMap(const DeviceGlobalMap &) = delete;
+  DeviceGlobalMap &operator=(const DeviceGlobalMap &) = delete;
+
   ~DeviceGlobalMap() {
-    if (!MOwnerControlledCleanup)
-      for (auto &DeviceGlobalIt : MDeviceGlobals)
-        DeviceGlobalIt.second->cleanup();
+    try {
+      if (!MOwnerControlledCleanup)
+        for (auto &DeviceGlobalIt : MDeviceGlobals)
+          DeviceGlobalIt.second->cleanup();
+    } catch (std::exception &e) {
+      __SYCL_REPORT_EXCEPTION_TO_STREAM("exception in ~DeviceGlobalMap", e);
+    }
   }
 
   void initializeEntries(const RTDeviceBinaryImage *Img) {

sycl/source/detail/device_global_map_entry.hpp

@@ -67,14 +67,14 @@ struct DeviceGlobalMapEntry {
   // Constructor for only initializing ID and pointer. The other members will
   // be initialized later.
   DeviceGlobalMapEntry(std::string UniqueId, const void *DeviceGlobalPtr)
-      : MUniqueId(UniqueId), MDeviceGlobalPtr(DeviceGlobalPtr) {}
+      : MUniqueId(std::move(UniqueId)), MDeviceGlobalPtr(DeviceGlobalPtr) {}
 
   // Constructor for only initializing ID, type size, and device image scope
   // flag. The pointer to the device global will be initialized later.
   DeviceGlobalMapEntry(std::string UniqueId, const RTDeviceBinaryImage *Img,
                        std::uint32_t DeviceGlobalTSize,
                        bool IsDeviceImageScopeDecorated)
-      : MUniqueId(UniqueId), MImages{Img},
+      : MUniqueId(std::move(UniqueId)), MImages{Img},
         MImageIdentifiers{reinterpret_cast<uintptr_t>(Img)},
         MDeviceGlobalTSize(DeviceGlobalTSize),
         MIsDeviceImageScopeDecorated(IsDeviceImageScopeDecorated) {}

sycl/source/detail/device_impl.cpp

@@ -258,7 +258,7 @@ std::vector<device> device_impl::create_sub_devices(
                               affinityDomainToString(AffinityDomain) + ".");
   }
 
-  ur_device_partition_property_t Prop;
+  ur_device_partition_property_t Prop{};
   Prop.type = UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
   Prop.value.affinity_domain =
       static_cast<ur_device_affinity_domain_flags_t>(AffinityDomain);
@@ -285,9 +285,8 @@ std::vector<device> device_impl::create_sub_devices() const {
         "sycl::info::partition_property::ext_intel_partition_by_cslice.");
   }
 
-  ur_device_partition_property_t Prop;
+  ur_device_partition_property_t Prop{};
   Prop.type = UR_DEVICE_PARTITION_BY_CSLICE;
-
   ur_device_partition_properties_t Properties{};
   Properties.stype = UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES;
   Properties.pProperties = &Prop;

sycl/source/detail/property_set_io.hpp

@@ -30,7 +30,7 @@ static IntT stringViewToInt(const std::string_view &SV) {
   if (SV.empty())
     return Result;
 
-  bool Negate = std::is_signed_v<IntT> && SV[0] == '-';
+  const bool Negate = std::is_signed_v<IntT> && SV[0] == '-';
 
   for (size_t I = static_cast<size_t>(Negate); I < SV.size(); ++I) {
     const char CurrentC = SV[I];

sycl/source/detail/usm/usm_impl.cpp

@@ -644,9 +644,22 @@ void release_from_device_copy(const void *Ptr, const queue &Queue) {
 } // namespace ext::oneapi::experimental
 
 __SYCL_EXPORT void verifyUSMAllocatorProperties(const property_list &PropList) {
-  auto NoAllowedPropertiesCheck = [](int) { return false; };
-  detail::PropertyValidator::checkPropsAndThrow(
-      PropList, NoAllowedPropertiesCheck, NoAllowedPropertiesCheck);
+  auto DataLessCheck = [](int Kind) {
+    switch (Kind) {
+    case detail::DeviceReadOnly:
+      return true;
+    }
+    return false;
+  };
+  auto WithDataCheck = [](int Kind) {
+    switch (Kind) {
+    case detail::PropWithDataKind::AccPropBufferLocation:
+      return true;
+    }
+    return false;
+  };
+  detail::PropertyValidator::checkPropsAndThrow(PropList, DataLessCheck,
+                                                WithDataCheck);
 }
 
 } // namespace _V1

sycl/test-e2e/Adapters/level_zero/context_create_sub_sub_device.cpp

@@ -0,0 +1,42 @@
+// REQUIRES:  arch-intel_gpu_pvc, level_zero
+// UNSUPPORTED: gpu-intel-pvc-1T
+// UNSUPPORTED-TRACKER: GSD-9121
+
+// DEFINE: %{setup_env} = env ZE_FLAT_DEVICE_HIERARCHY=COMPOSITE ZE_AFFINITY_MASK=0 ZEX_NUMBER_OF_CCS=0:4
+// RUN: %{build} -o %t.out
+// RUN: %{setup_env} %{run} %t.out
+
+// Check that context can be created successfully when sub-sub-devices are
+// exposed.
+#include <iostream>
+#include <sycl/detail/core.hpp>
+#include <vector>
+
+using namespace sycl;
+
+int main() {
+  std::cout << "[info] start context_create_sub_sub_device test" << std::endl;
+  device d;
+  std::vector<device> subsubdevices;
+
+  auto subdevices = d.create_sub_devices<
+      info::partition_property::partition_by_affinity_domain>(
+      info::partition_affinity_domain::next_partitionable);
+  std::cout << "[info] sub device size = " << subdevices.size() << std::endl;
+
+  for (auto &subdev : subdevices) {
+    subsubdevices = subdev.create_sub_devices<
+        info::partition_property::ext_intel_partition_by_cslice>();
+
+    std::cout << "[info] sub-sub device size = " << subsubdevices.size()
+              << std::endl;
+  }
+
+  // Create contexts
+  context ctx1(d);
+  context ctx2(subdevices);
+  context ctx3(subsubdevices);
+
+  std::cout << "[info] contexts created successfully" << std::endl;
+  return 0;
+}

sycl/test-e2e/Adapters/level_zero/usm_device_read_only.cpp

@@ -8,6 +8,8 @@
 
 #include <sycl/ext/oneapi/experimental/annotated_usm/alloc_shared.hpp>
 
+#include <sycl/usm/usm_allocator.hpp>
+
 using namespace std;
 using namespace sycl;
 
@@ -24,7 +26,22 @@ int main(int argc, char *argv[]) {
   // CHECK: ---> urUSMSharedAlloc
   // CHECK-NOT: zeMemAllocShared
 
-  free(ptr1, Q);
+  sycl::usm_allocator<int, sycl::usm::alloc::shared> allocator_no_prop{Q};
+
+  auto ptr3 = allocator_no_prop.allocate(1);
+  // CHECK: ---> urUSMSharedAlloc
+  // CHECK: zeMemAllocShared
+
+  sycl::usm_allocator<int, sycl::usm::alloc::shared> allocator_prop{
+      Q, {sycl::ext::oneapi::property::usm::device_read_only{}}};
+
+  auto ptr4 = allocator_prop.allocate(1);
+  // CHECK: ---> urUSMSharedAlloc
+  // CHECK-NOT: zeMemAllocShared
+
+  allocator_prop.deallocate(ptr4, 1);
+  allocator_no_prop.deallocate(ptr3, 1);
   free(ptr2, Q);
+  free(ptr1, Q);
   return 0;
 }

sycl/test-e2e/USM/properties.cpp

@@ -0,0 +1,15 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+
+#include <sycl/ext/intel/experimental/usm_properties.hpp>
+#include <sycl/usm/usm_allocator.hpp>
+
+int main() {
+  sycl::queue q;
+
+  // Ensure properties are supported when constructing the allocator:
+  sycl::usm_allocator<int, sycl::usm::alloc::shared> allocator{
+      q,
+      {sycl::ext::oneapi::property::usm::device_read_only{},
+       sycl::ext::intel::experimental::property::usm::buffer_location{1}}};
+}

unified-runtime/source/adapters/level_zero/device.hpp

@@ -248,16 +248,20 @@ struct ur_device_handle_t_ : ur_object {
   ur::RefCount RefCount;
 };
 
-inline std::vector<ur_device_handle_t>
-CollectDevicesAndSubDevices(const std::vector<ur_device_handle_t> &Devices) {
+// Collects a flat vector of unique devices for USM memory pool creation.
+// Traverses the input devices and their sub-devices, ensuring each Level Zero
+// device handle appears only once in the result.
+inline std::vector<ur_device_handle_t> CollectDevicesForUsmPoolCreation(
+    const std::vector<ur_device_handle_t> &Devices) {
   std::vector<ur_device_handle_t> DevicesAndSubDevices;
-  std::unordered_set<ur_device_handle_t> Seen;
+  std::unordered_set<ze_device_handle_t> Seen;
+
   std::function<void(const std::vector<ur_device_handle_t> &)>
       CollectDevicesAndSubDevicesRec =
           [&](const std::vector<ur_device_handle_t> &Devices) {
             for (auto &Device : Devices) {
-              // Only add device if has not been seen before.
-              if (Seen.insert(Device).second) {
+              // Only add device if ZeDevice has not been seen before.
+              if (Seen.insert(Device->ZeDevice).second) {
                 DevicesAndSubDevices.push_back(Device);
                 CollectDevicesAndSubDevicesRec(Device->SubDevices);
               }