[NFCI][SYCL] Less shared_ptr for platform_impl

`GlobalHandler::MPlatformCache` keeps (shared) ownership of
`platform_impl` objects, so none of them could be destroyed until SYCL
RT library shutdown/unload process. As such, using raw
pointers/reference to `platform_impl` throughout the SYCL RT is totally
fine and avoids extra costs of `std::shared_ptr`

I'm relatively sure `sycl::platform` could avoid using
`std::shared_ptr<detail::platform_impl> impl` as well, but that would be
a breaking change so not being implemented at this moment.

Author: aelovikov-intel

sycl/include/sycl/platform.hpp

@@ -37,12 +37,16 @@ inline namespace _V1 {
 // Forward declaration
 class device;
 class context;
+class platform;
 
 template <backend BackendName, class SyclObjectT>
 auto get_native(const SyclObjectT &Obj)
     -> backend_return_t<BackendName, SyclObjectT>;
 namespace detail {
 class platform_impl;
+template <class T>
+std::enable_if_t<std::is_same_v<T, platform>, platform>
+createSyclObjFromImpl(platform_impl &);
 
 /// Allows to enable/disable "Default Context" extension
 ///
@@ -231,6 +235,9 @@ class __SYCL_EXPORT platform : public detail::OwnerLessBase<platform> {
   template <class Obj>
   friend const decltype(Obj::impl) &
   detail::getSyclObjImpl(const Obj &SyclObject);
+  template <class T>
+  friend std::enable_if_t<std::is_same_v<T, platform>, platform>
+  detail::createSyclObjFromImpl(detail::platform_impl &);
 
   template <backend BackendName, class SyclObjectT>
   friend auto get_native(const SyclObjectT &Obj)

sycl/source/backend.cpp

@@ -89,9 +89,9 @@ __SYCL_EXPORT device make_device(ur_native_handle_t NativeHandle,
       NativeHandle, Adapter->getUrAdapter(), nullptr, &UrDevice);
 
   // Construct the SYCL device from UR device.
-  auto Platform = platform_impl::getPlatformFromUrDevice(UrDevice, Adapter);
   return detail::createSyclObjFromImpl<device>(
-      Platform->getOrMakeDeviceImpl(UrDevice, Platform));
+      platform_impl::getPlatformFromUrDevice(UrDevice, Adapter)
+          .getOrMakeDeviceImpl(UrDevice));
 }
 
 __SYCL_EXPORT context make_context(ur_native_handle_t NativeHandle,
@@ -288,10 +288,9 @@ make_kernel_bundle(ur_native_handle_t NativeHandle,
   std::transform(
       ProgramDevices.begin(), ProgramDevices.end(), std::back_inserter(Devices),
       [&Adapter](const auto &Dev) {
-        auto Platform =
-            detail::platform_impl::getPlatformFromUrDevice(Dev, Adapter);
-        auto DeviceImpl = Platform->getOrMakeDeviceImpl(Dev, Platform);
-        return createSyclObjFromImpl<device>(DeviceImpl);
+        return createSyclObjFromImpl<device>(
+            detail::platform_impl::getPlatformFromUrDevice(Dev, Adapter)
+                .getOrMakeDeviceImpl(Dev));
       });
 
   // Unlike SYCL, other backends, like OpenCL or Level Zero, may not support

sycl/source/backend/level_zero.cpp

@@ -20,14 +20,13 @@ using namespace sycl::detail;
 __SYCL_EXPORT device make_device(const platform &Platform,
                                  ur_native_handle_t NativeHandle) {
   const auto &Adapter = ur::getAdapter<backend::ext_oneapi_level_zero>();
-  const auto &PlatformImpl = getSyclObjImpl(Platform);
   // Create UR device first.
   ur_device_handle_t UrDevice;
   Adapter->call<UrApiKind::urDeviceCreateWithNativeHandle>(
       NativeHandle, Adapter->getUrAdapter(), nullptr, &UrDevice);
 
   return detail::createSyclObjFromImpl<device>(
-      PlatformImpl->getOrMakeDeviceImpl(UrDevice, PlatformImpl));
+      getSyclObjImpl(Platform)->getOrMakeDeviceImpl(UrDevice));
 }
 
 } // namespace ext::oneapi::level_zero::detail

sycl/source/detail/allowlist.cpp

@@ -375,8 +375,9 @@ void applyAllowList(std::vector<ur_device_handle_t> &UrDevices,
 
   // Get platform's backend and put it to DeviceDesc
   DeviceDescT DeviceDesc;
-  auto PlatformImpl = platform_impl::getOrMakePlatformImpl(UrPlatform, Adapter);
-  backend Backend = PlatformImpl->getBackend();
+  platform_impl &PlatformImpl =
+      platform_impl::getOrMakePlatformImpl(UrPlatform, Adapter);
+  backend Backend = PlatformImpl.getBackend();
 
   for (const auto &SyclBe : getSyclBeMap()) {
     if (SyclBe.second == Backend) {
@@ -395,7 +396,7 @@ void applyAllowList(std::vector<ur_device_handle_t> &UrDevices,
 
   int InsertIDx = 0;
   for (ur_device_handle_t Device : UrDevices) {
-    auto DeviceImpl = PlatformImpl->getOrMakeDeviceImpl(Device, PlatformImpl);
+    auto DeviceImpl = PlatformImpl.getOrMakeDeviceImpl(Device);
     // get DeviceType value and put it to DeviceDesc
     ur_device_type_t UrDevType = UR_DEVICE_TYPE_ALL;
     Adapter->call<UrApiKind::urDeviceGetInfo>(

sycl/source/detail/buffer_impl.cpp

@@ -79,12 +79,11 @@ buffer_impl::getNativeVector(backend BackendName) const {
     // doesn't have context and platform
     if (!Ctx)
       continue;
-    const PlatformImplPtr &Platform = Ctx->getPlatformImpl();
-    assert(Platform && "Platform must be present for device context");
-    if (Platform->getBackend() != BackendName)
+    const platform_impl &Platform = Ctx->getPlatformImpl();
+    if (Platform.getBackend() != BackendName)
       continue;
 
-    auto Adapter = Platform->getAdapter();
+    auto Adapter = Platform.getAdapter();
 
     ur_native_handle_t Handle = 0;
     // When doing buffer interop we don't know what device the memory should be
@@ -94,7 +93,7 @@ buffer_impl::getNativeVector(backend BackendName) const {
                                                    &Handle);
     Handles.push_back(Handle);
 
-    if (Platform->getBackend() == backend::opencl) {
+    if (Platform.getBackend() == backend::opencl) {
       __SYCL_OCL_CALL(clRetainMemObject, ur::cast<cl_mem>(Handle));
     }
   }

sycl/source/detail/context_impl.cpp

@@ -31,7 +31,7 @@ context_impl::context_impl(const device &Device, async_handler AsyncHandler,
                            const property_list &PropList)
     : MOwnedByRuntime(true), MAsyncHandler(AsyncHandler), MDevices(1, Device),
       MContext(nullptr),
-      MPlatform(detail::getSyclObjImpl(Device.get_platform())),
+      MPlatform(detail::getSyclObjImpl(Device.get_platform()).get()),
       MPropList(PropList), MSupportBufferLocationByDevices(NotChecked) {
   verifyProps(PropList);
   MKernelProgramCache.setContextPtr(this);
@@ -41,10 +41,10 @@ context_impl::context_impl(const std::vector<sycl::device> Devices,
                            async_handler AsyncHandler,
                            const property_list &PropList)
     : MOwnedByRuntime(true), MAsyncHandler(AsyncHandler), MDevices(Devices),
-      MContext(nullptr), MPlatform(), MPropList(PropList),
-      MSupportBufferLocationByDevices(NotChecked) {
+      MContext(nullptr),
+      MPlatform(detail::getSyclObjImpl(MDevices[0].get_platform()).get()),
+      MPropList(PropList), MSupportBufferLocationByDevices(NotChecked) {
   verifyProps(PropList);
-  MPlatform = detail::getSyclObjImpl(MDevices[0].get_platform());
   std::vector<ur_device_handle_t> DeviceIds;
   for (const auto &D : MDevices) {
     if (D.has(aspect::ext_oneapi_is_composite)) {
@@ -77,7 +77,7 @@ context_impl::context_impl(ur_context_handle_t UrContext,
       MDevices(DeviceList), MContext(UrContext), MPlatform(),
       MSupportBufferLocationByDevices(NotChecked) {
   if (!MDevices.empty()) {
-    MPlatform = detail::getSyclObjImpl(MDevices[0].get_platform());
+    MPlatform = detail::getSyclObjImpl(MDevices[0].get_platform()).get();
   } else {
     std::vector<ur_device_handle_t> DeviceIds;
     uint32_t DevicesNum = 0;
@@ -96,13 +96,13 @@ context_impl::context_impl(ur_context_handle_t UrContext,
           make_error_code(errc::invalid),
           "No devices in the provided device list and native context.");
 
-    std::shared_ptr<detail::platform_impl> Platform =
+    platform_impl &Platform =
         platform_impl::getPlatformFromUrDevice(DeviceIds[0], Adapter);
     for (ur_device_handle_t Dev : DeviceIds) {
-      MDevices.emplace_back(createSyclObjFromImpl<device>(
-          Platform->getOrMakeDeviceImpl(Dev, Platform)));
+      MDevices.emplace_back(
+          createSyclObjFromImpl<device>(Platform.getOrMakeDeviceImpl(Dev)));
     }
-    MPlatform = Platform;
+    MPlatform = &Platform;
   }
   // TODO catch an exception and put it to list of asynchronous exceptions
   // getAdapter() will be the same as the Adapter passed. This should be taken
@@ -158,7 +158,7 @@ uint32_t context_impl::get_info<info::context::reference_count>() const {
                                                           this->getAdapter());
 }
 template <> platform context_impl::get_info<info::context::platform>() const {
-  return createSyclObjFromImpl<platform>(MPlatform);
+  return createSyclObjFromImpl<platform>(*MPlatform);
 }
 template <>
 std::vector<sycl::device>

sycl/source/detail/context_impl.hpp

@@ -29,7 +29,6 @@ inline namespace _V1 {
 // Forward declaration
 class device;
 namespace detail {
-using PlatformImplPtr = std::shared_ptr<detail::platform_impl>;
 class context_impl {
 public:
   /// Constructs a context_impl using a single SYCL devices.
@@ -89,8 +88,10 @@ class context_impl {
   /// \return the Adapter associated with the platform of this context.
   const AdapterPtr &getAdapter() const { return MPlatform->getAdapter(); }
 
+  // TODO: Think more about `const`
   /// \return the PlatformImpl associated with this context.
-  const PlatformImplPtr &getPlatformImpl() const { return MPlatform; }
+  const platform_impl &getPlatformImpl() const { return *MPlatform; }
+  platform_impl &getPlatformImpl() { return *MPlatform; }
 
   /// Queries this context for information.
   ///
@@ -257,7 +258,8 @@ class context_impl {
   async_handler MAsyncHandler;
   std::vector<device> MDevices;
   ur_context_handle_t MContext;
-  PlatformImplPtr MPlatform;
+  // TODO: Make it a reference instead, but that needs a bit more refactoring:
+  platform_impl *MPlatform = nullptr;
   property_list MPropList;
   CachedLibProgramsT MCachedLibPrograms;
   std::mutex MCachedLibProgramsMutex;

sycl/source/detail/device_impl.cpp

@@ -21,17 +21,17 @@ namespace detail {
 
 /// Constructs a SYCL device instance using the provided
 /// UR device instance.
-device_impl::device_impl(ur_device_handle_t Device, PlatformImplPtr Platform)
+device_impl::device_impl(ur_device_handle_t Device, platform_impl &Platform)
     : MDevice(Device), MPlatform(Platform),
       MDeviceHostBaseTime(std::make_pair(0, 0)) {
-  const AdapterPtr &Adapter = Platform->getAdapter();
+  const AdapterPtr &Adapter = Platform.getAdapter();
 
   // TODO catch an exception and put it to list of asynchronous exceptions
   Adapter->call<UrApiKind::urDeviceGetInfo>(
       MDevice, UR_DEVICE_INFO_TYPE, sizeof(ur_device_type_t), &MType, nullptr);
 
   // No need to set MRootDevice when MAlwaysRootDevice is true
-  if (!Platform->MAlwaysRootDevice) {
+  if (!Platform.MAlwaysRootDevice) {
     // TODO catch an exception and put it to list of asynchronous exceptions
     Adapter->call<UrApiKind::urDeviceGetInfo>(
         MDevice, UR_DEVICE_INFO_PARENT_DEVICE, sizeof(ur_device_handle_t),
@@ -177,7 +177,7 @@ std::vector<device> device_impl::create_sub_devices(
   std::for_each(SubDevices.begin(), SubDevices.end(),
                 [&res, this](const ur_device_handle_t &a_ur_device) {
                   device sycl_device = detail::createSyclObjFromImpl<device>(
-                      MPlatform->getOrMakeDeviceImpl(a_ur_device, MPlatform));
+                      MPlatform.getOrMakeDeviceImpl(a_ur_device));
                   res.push_back(sycl_device);
                 });
   return res;

sycl/source/detail/device_impl.hpp

@@ -30,14 +30,13 @@ namespace detail {
 
 // Forward declaration
 class platform_impl;
-using PlatformImplPtr = std::shared_ptr<platform_impl>;
 
 // TODO: Make code thread-safe
 class device_impl {
 public:
   /// Constructs a SYCL device instance using the provided
   /// UR device instance.
-  explicit device_impl(ur_device_handle_t Device, PlatformImplPtr Platform);
+  explicit device_impl(ur_device_handle_t Device, platform_impl &Platform);
 
   ~device_impl();
 
@@ -94,7 +93,7 @@ class device_impl {
   platform get_platform() const;
 
   /// \return the associated adapter with this device.
-  const AdapterPtr &getAdapter() const { return MPlatform->getAdapter(); }
+  const AdapterPtr &getAdapter() const { return MPlatform.getAdapter(); }
 
   /// Check SYCL extension support by device
   ///
@@ -276,11 +275,11 @@ class device_impl {
   bool isGetDeviceAndHostTimerSupported();
 
   /// Get the backend of this device
-  backend getBackend() const { return MPlatform->getBackend(); }
+  backend getBackend() const { return MPlatform.getBackend(); }
 
+  // TODO: const-correctness
   /// @brief  Get the platform impl serving this device
-  /// @return PlatformImplPtr
-  const PlatformImplPtr &getPlatformImpl() const { return MPlatform; }
+  platform_impl &getPlatformImpl() const { return MPlatform; }
 
   /// Get device info string
   std::string get_device_info_string(ur_device_info_t InfoCode) const;
@@ -292,7 +291,7 @@ class device_impl {
   ur_device_handle_t MDevice = 0;
   ur_device_type_t MType;
   ur_device_handle_t MRootDevice = nullptr;
-  PlatformImplPtr MPlatform;
+  platform_impl &MPlatform;
   bool MUseNativeAssert = false;
   mutable std::string MDeviceName;
   mutable std::once_flag MDeviceNameFlag;

sycl/source/detail/device_info.hpp

@@ -35,7 +35,6 @@
 namespace sycl {
 inline namespace _V1 {
 namespace detail {
-
 inline std::vector<memory_order>
 readMemoryOrderBitfield(ur_memory_order_capability_flags_t bits) {
   std::vector<memory_order> result;
@@ -1171,9 +1170,8 @@ template <> struct get_device_info_impl<device, info::device::parent_device> {
       throw exception(make_error_code(errc::invalid),
                       "No parent for device because it is not a subdevice");
 
-    const auto &Platform = Dev.getPlatformImpl();
     return createSyclObjFromImpl<device>(
-        Platform->getOrMakeDeviceImpl(result, Platform));
+        Dev.getPlatformImpl().getOrMakeDeviceImpl(result));
   }
 };
 
@@ -1337,10 +1335,10 @@ struct get_device_info_impl<
             ext::oneapi::experimental::info::device::component_devices>::value,
         ResultSize, Devs.data(), nullptr);
     std::vector<sycl::device> Result;
-    const auto &Platform = Dev.getPlatformImpl();
+    platform_impl &Platform = Dev.getPlatformImpl();
     for (const auto &d : Devs)
-      Result.push_back(createSyclObjFromImpl<device>(
-          Platform->getOrMakeDeviceImpl(d, Platform)));
+      Result.push_back(
+          createSyclObjFromImpl<device>(Platform.getOrMakeDeviceImpl(d)));
 
     return Result;
   }
@@ -1363,9 +1361,8 @@ struct get_device_info_impl<
         sizeof(Result), &Result, nullptr);
 
     if (Result) {
-      const auto &Platform = Dev.getPlatformImpl();
       return createSyclObjFromImpl<device>(
-          Platform->getOrMakeDeviceImpl(Result, Platform));
+          Dev.getPlatformImpl().getOrMakeDeviceImpl(Result));
     }
     throw sycl::exception(make_error_code(errc::invalid),
                           "A component with aspect::ext_oneapi_is_component "

sycl/source/detail/global_handler.cpp

@@ -186,7 +186,7 @@ ProgramManager &GlobalHandler::getProgramManager() {
   return PM;
 }
 
-std::unordered_map<PlatformImplPtr, ContextImplPtr> &
+std::unordered_map<platform_impl *, ContextImplPtr> &
 GlobalHandler::getPlatformToDefaultContextCache() {
   // The optimization with static reference is not done because
   // there are public methods of the GlobalHandler
@@ -207,8 +207,8 @@ Sync &GlobalHandler::getSync() {
   return sync;
 }
 
-std::vector<PlatformImplPtr> &GlobalHandler::getPlatformCache() {
-  static std::vector<PlatformImplPtr> &PlatformCache =
+std::vector<std::shared_ptr<platform_impl>> &GlobalHandler::getPlatformCache() {
+  static std::vector<std::shared_ptr<platform_impl>> &PlatformCache =
       getOrCreate(MPlatformCache);
   return PlatformCache;
 }

sycl/source/detail/global_handler.hpp

@@ -27,7 +27,6 @@ class ods_target_list;
 class XPTIRegistry;
 class ThreadPool;
 
-using PlatformImplPtr = std::shared_ptr<platform_impl>;
 using ContextImplPtr = std::shared_ptr<context_impl>;
 using AdapterPtr = std::shared_ptr<Adapter>;
 
@@ -60,9 +59,9 @@ class GlobalHandler {
   bool isSchedulerAlive() const;
   ProgramManager &getProgramManager();
   Sync &getSync();
-  std::vector<PlatformImplPtr> &getPlatformCache();
+  std::vector<std::shared_ptr<platform_impl>> &getPlatformCache();
 
-  std::unordered_map<PlatformImplPtr, ContextImplPtr> &
+  std::unordered_map<platform_impl *, ContextImplPtr> &
   getPlatformToDefaultContextCache();
 
   std::mutex &getPlatformToDefaultContextCacheMutex();
@@ -118,8 +117,8 @@ class GlobalHandler {
   InstWithLock<Scheduler> MScheduler;
   InstWithLock<ProgramManager> MProgramManager;
   InstWithLock<Sync> MSync;
-  InstWithLock<std::vector<PlatformImplPtr>> MPlatformCache;
-  InstWithLock<std::unordered_map<PlatformImplPtr, ContextImplPtr>>
+  InstWithLock<std::vector<std::shared_ptr<platform_impl>>> MPlatformCache;
+  InstWithLock<std::unordered_map<platform_impl *, ContextImplPtr>>
       MPlatformToDefaultContextCache;
   InstWithLock<std::mutex> MPlatformToDefaultContextCacheMutex;
   InstWithLock<std::mutex> MPlatformMapMutex;

sycl/source/detail/kernel_impl.cpp

@@ -126,7 +126,7 @@ void kernel_impl::checkIfValidForNumArgsInfoQuery() const {
 }
 
 void kernel_impl::enableUSMIndirectAccess() const {
-  if (!MContext->getPlatformImpl()->supports_usm())
+  if (!MContext->getPlatformImpl().supports_usm())
     return;
 
   // Some UR Adapters (like OpenCL) require this call to enable USM