[SYCL] Make sycl::device use raw device_impl * for its impl

`device_impl`s are owned by the parent platforms and are only destroyed
when SYCL RT is unloaded. As such, there is no reason to pay the price
of a `std::shared_ptr` a raw non-owning pointers is enough.

Use a pointer and not a reference because `sycl::device` is assignable.

Author: aelovikov-intel

sycl/gdb/libsycl.so-gdb.py

@@ -381,7 +381,7 @@ def __init__(self, gdb_value):
         super().__init__(gdb_value)
 
     def impl_ptr(self):
-        return self.gdb_value()["impl"]["_M_ptr"]
+        return self.gdb_value()["impl"]
 
     def backend(self):
         char_ptr = SYCLType.char_type().pointer()

sycl/include/sycl/device.hpp

@@ -57,15 +57,14 @@ enum class peer_access {
   access_supported = 0x0,
   atomics_supported = 0x1,
 };
-
+template <typename SYCLObjT> class weak_object;
 } // namespace ext::oneapi
 
 /// The SYCL device class encapsulates a single SYCL device on which kernels
 /// may be executed.
 ///
 /// \ingroup sycl_api
-class __SYCL_STANDALONE_DEBUG __SYCL_EXPORT device
-    : public detail::OwnerLessBase<device> {
+class __SYCL_STANDALONE_DEBUG __SYCL_EXPORT device {
   friend sycl::detail::ImplUtils;
 
 public:
@@ -93,6 +92,12 @@ class __SYCL_STANDALONE_DEBUG __SYCL_EXPORT device
   /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
   /// takes a device and returns an int
   template <typename DeviceSelector,
+            // `device_impl` (used as a parameter in private ctor) is incomplete
+            // so would result in a error trying to instantiate
+            // `EnableIfSYCL2020DeviceSelectorInvocable` below. Filter it out
+            // before trying to do that.
+            typename = std::enable_if_t<
+                !std::is_same_v<DeviceSelector, detail::device_impl>>,
             typename =
                 detail::EnableIfSYCL2020DeviceSelectorInvocable<DeviceSelector>>
   explicit device(const DeviceSelector &deviceSelector)
@@ -361,14 +366,22 @@ class __SYCL_STANDALONE_DEBUG __SYCL_EXPORT device
   /// \return the default context
   context ext_oneapi_get_default_context();
 
+  // Definitions are in `<sycl/ext/oneapi/weak_object.hpp>` to avoid circular
+  // dependencies:
+  inline bool ext_oneapi_owner_before(const device &Other) const noexcept;
+  inline bool ext_oneapi_owner_before(
+      const ext::oneapi::weak_object<device> &Other) const noexcept;
+
 // TODO: Remove this diagnostics when __SYCL_WARN_IMAGE_ASPECT is removed.
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif // defined(__clang__)
 
 private:
-  std::shared_ptr<detail::device_impl> impl;
-  device(std::shared_ptr<detail::device_impl> Impl) : impl(std::move(Impl)) {}
+  // `device_impl`s are owned by the parent platform, user-visible
+  // `sycl::device` is non-owning and thus very cheap.
+  detail::device_impl *impl = nullptr;
+  device(detail::device_impl &impl) : impl(&impl) {}
 
   ur_native_handle_t getNative() const;
 

sycl/include/sycl/ext/oneapi/backend/level_zero.hpp

@@ -113,7 +113,8 @@ inline device make_device<backend::ext_oneapi_level_zero>(
       continue;
 
     for (auto &d : p.get_devices()) {
-      if (auto maybe_device = find_matching_descendent_device(d, BackendObject))
+      if (auto maybe_device =
+              detail::find_matching_descendent_device(d, BackendObject))
         return *maybe_device;
     }
   }

sycl/include/sycl/ext/oneapi/experimental/current_device.hpp

@@ -16,13 +16,8 @@ namespace ext::oneapi::experimental::this_thread {
 
 namespace detail {
 using namespace sycl::detail;
-// Underlying `std::shared_ptr<device_impl>`'s lifetime is tied to the
-// `global_handler`, so a subsequent `lock()` is expected to be successful when
-// used from user app. We still go through `std::weak_ptr` here because our own
-// unittests are linked statically against SYCL RT objects and have to implement
-// some hacks to emulate the lifetime management done by the `global_handler`.
-inline std::weak_ptr<device_impl> &get_current_device_impl() {
-  static thread_local std::weak_ptr<device_impl> current_device{
+inline device_impl *&get_current_device_impl() {
+  static thread_local device_impl *current_device{
       getSyclObjImpl(sycl::device{sycl::default_selector_v})};
   return current_device;
 }
@@ -36,7 +31,7 @@ inline std::weak_ptr<device_impl> &get_current_device_impl() {
 /// task or an asynchronous error handler.
 inline sycl::device get_current_device() {
   return detail::createSyclObjFromImpl<device>(
-      detail::get_current_device_impl().lock());
+      *detail::get_current_device_impl());
 }
 
 /// @brief Sets the current default device to `dev` for the calling host thread.

sycl/include/sycl/ext/oneapi/weak_object.hpp

@@ -233,6 +233,67 @@ class weak_object<stream> : public detail::weak_object_base<stream> {
   weak_object<detail::GlobalBufAccessorT> MWeakGlobalFlushBuf;
 };
 
+template <> class weak_object<device> {
+  friend sycl::device;
+
+  detail::device_impl *dev_impl = nullptr;
+
+public:
+  using object_type = device;
+
+  constexpr weak_object() noexcept = default;
+  weak_object(const device &dev) noexcept
+      : dev_impl(detail::getSyclObjImpl(dev)) {}
+  weak_object(const weak_object &Other) noexcept = default;
+  weak_object(weak_object &&Other) noexcept = default;
+
+  weak_object &operator=(const device &Other) noexcept {
+    this->dev_impl = detail::getSyclObjImpl(Other);
+    return *this;
+  }
+  weak_object &operator=(const weak_object &Other) noexcept = default;
+  weak_object &operator=(weak_object &&Other) noexcept = default;
+
+  bool expired() const noexcept { return dev_impl == nullptr; }
+
+  void reset() noexcept { dev_impl = nullptr; }
+
+#ifndef __SYCL_DEVICE_ONLY__
+  std::optional<device> try_lock() const noexcept {
+    if (!dev_impl)
+      return std::nullopt;
+    return sycl::detail::createSyclObjFromImpl<device>(*dev_impl);
+  }
+  device lock() const {
+    std::optional<device> OptionalObj = try_lock();
+    if (!OptionalObj)
+      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
+                            "Referenced object has expired.");
+    return *OptionalObj;
+  }
+  bool owner_before(const device &Other) const noexcept {
+    return dev_impl < detail::getSyclObjImpl(Other);
+  }
+  bool owner_before(const weak_object &Other) const noexcept {
+    return dev_impl < Other.dev_impl;
+  }
+#else
+  // On device calls to these functions are disallowed, so declare them but
+  // don't define them to avoid compilation failures.
+  std::optional<device> try_lock() const noexcept;
+  device lock() const;
+  bool owner_before(const device &Other) const noexcept;
+  bool owner_before(const weak_object &Other) const noexcept;
+#endif // __SYCL_DEVICE_ONLY__
+};
 } // namespace ext::oneapi
+inline bool
+device::ext_oneapi_owner_before(const device &Other) const noexcept {
+  return impl < Other.impl;
+}
+inline bool device::ext_oneapi_owner_before(
+    const ext::oneapi::weak_object<device> &Other) const noexcept {
+  return impl < Other.dev_impl;
+}
 } // namespace _V1
 } // namespace sycl

sycl/source/detail/context_impl.hpp

@@ -186,8 +186,7 @@ class context_impl : public std::enable_shared_from_this<context_impl> {
         return false;
       }
       CurrDevice = detail::getSyclObjImpl(
-                       CurrDevice->get_info<info::device::parent_device>())
-                       .get();
+          CurrDevice->get_info<info::device::parent_device>());
     }
 
     return true;

sycl/source/detail/platform_impl.cpp

@@ -30,6 +30,20 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 
+platform_impl::platform_impl(ur_platform_handle_t APlatform,
+                             adapter_impl &Adapter)
+    : MPlatform(APlatform), MAdapter(&Adapter) {
+
+  // Find out backend of the platform
+  ur_backend_t UrBackend = UR_BACKEND_UNKNOWN;
+  Adapter.call_nocheck<UrApiKind::urPlatformGetInfo>(
+      APlatform, UR_PLATFORM_INFO_BACKEND, sizeof(ur_backend_t), &UrBackend,
+      nullptr);
+  MBackend = convertUrBackend(UrBackend);
+}
+
+platform_impl::~platform_impl() = default;
+
 platform_impl &
 platform_impl::getOrMakePlatformImpl(ur_platform_handle_t UrPlatform,
                                      adapter_impl &Adapter) {
@@ -266,7 +280,7 @@ device_impl &platform_impl::getOrMakeDeviceImpl(ur_device_handle_t UrDevice) {
     return *Result;
 
   // Otherwise make the impl
-  MDevices.emplace_back(std::make_shared<device_impl>(
+  MDevices.emplace_back(std::make_unique<device_impl>(
       UrDevice, *this, device_impl::private_tag{}));
 
   return *MDevices.back();
@@ -568,7 +582,7 @@ bool platform_impl::has(aspect Aspect) const {
 }
 
 device_impl *platform_impl::getDeviceImplHelper(ur_device_handle_t UrDevice) {
-  for (const std::shared_ptr<device_impl> &Device : MDevices) {
+  for (const std::unique_ptr<device_impl> &Device : MDevices) {
     if (Device->getHandleRef() == UrDevice)
       return Device.get();
   }

sycl/source/detail/platform_impl.hpp

@@ -39,18 +39,9 @@ class platform_impl : public std::enable_shared_from_this<platform_impl> {
   //
   // Platforms can only be created under `GlobalHandler`'s ownership via
   // `platform_impl::getOrMakePlatformImpl` method.
-  explicit platform_impl(ur_platform_handle_t APlatform, adapter_impl &Adapter)
-      : MPlatform(APlatform), MAdapter(&Adapter) {
-
-    // Find out backend of the platform
-    ur_backend_t UrBackend = UR_BACKEND_UNKNOWN;
-    Adapter.call_nocheck<UrApiKind::urPlatformGetInfo>(
-        APlatform, UR_PLATFORM_INFO_BACKEND, sizeof(ur_backend_t), &UrBackend,
-        nullptr);
-    MBackend = convertUrBackend(UrBackend);
-  }
+  explicit platform_impl(ur_platform_handle_t APlatform, adapter_impl &Adapter);
 
-  ~platform_impl() = default;
+  ~platform_impl();
 
 public:
   /// Checks if this platform supports extension.
@@ -221,7 +212,7 @@ class platform_impl : public std::enable_shared_from_this<platform_impl> {
 
   adapter_impl *MAdapter;
 
-  std::vector<std::shared_ptr<device_impl>> MDevices;
+  std::vector<std::unique_ptr<device_impl>> MDevices;
   friend class GlobalHandler;
   std::mutex MDeviceMapMutex;
 };

sycl/source/detail/program_manager/program_manager.cpp

@@ -2470,7 +2470,7 @@ device_image_plain ProgramManager::getDeviceImageFromBinaryImage(
     const device &Dev) {
   const bundle_state ImgState = getBinImageState(BinImage);
 
-  assert(compatibleWithDevice(BinImage, *getSyclObjImpl(Dev).get()));
+  assert(compatibleWithDevice(BinImage, *getSyclObjImpl(Dev)));
 
   std::shared_ptr<std::vector<sycl::kernel_id>> KernelIDs;
   // Collect kernel names for the image.

sycl/source/detail/usm/usm_impl.cpp

@@ -245,7 +245,7 @@ void *alignedAlloc(size_t Alignment, size_t Size, const context &Ctxt,
 #endif
   void *RetVal =
       alignedAllocInternal(Alignment, Size, getSyclObjImpl(Ctxt).get(),
-                           getSyclObjImpl(Dev).get(), Kind, PropList);
+                           getSyclObjImpl(Dev), Kind, PropList);
 #ifdef XPTI_ENABLE_INSTRUMENTATION
   // Once the allocation is complete, update metadata with the memory pointer
   // before the mem_alloc_end event is sent