[SYCL] Use platform_impl::getOrMakeDeviceImpl in make_device (#18163)

This effectively reverts part of the changes made in
#13483 in favor of a simpler solution.
The tests added there are unchanged and are verifying this PR.

This made one `device_impl` ctor overload unused with another already
dead prior to this. Removing them both here and making some other
simplifications following from that removal.

Author: aelovikov-intel

sycl/include/sycl/backend.hpp

@@ -305,16 +305,6 @@ std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeDevice == true,
                  device>
 make_device(const typename backend_traits<Backend>::template input_type<device>
                 &BackendObject) {
-  for (auto p : platform::get_platforms()) {
-    if (p.get_backend() != Backend)
-      continue;
-
-    for (auto d : p.get_devices()) {
-      if (get_native<Backend>(d) == BackendObject)
-        return d;
-    }
-  }
-
   return detail::make_device(
       detail::ur::cast<ur_native_handle_t>(BackendObject), Backend);
 }

sycl/source/backend.cpp

@@ -87,9 +87,11 @@ __SYCL_EXPORT device make_device(ur_native_handle_t NativeHandle,
   ur_device_handle_t UrDevice = nullptr;
   Adapter->call<UrApiKind::urDeviceCreateWithNativeHandle>(
       NativeHandle, Adapter->getUrAdapter(), nullptr, &UrDevice);
+
   // Construct the SYCL device from UR device.
+  auto Platform = platform_impl::getPlatformFromUrDevice(UrDevice, Adapter);
   return detail::createSyclObjFromImpl<device>(
-      std::make_shared<device_impl>(UrDevice, Adapter));
+      Platform->getOrMakeDeviceImpl(UrDevice, Platform));
 }
 
 __SYCL_EXPORT context make_context(ur_native_handle_t NativeHandle,

sycl/source/detail/device_impl.cpp

@@ -19,59 +19,29 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 
-device_impl::device_impl(ur_native_handle_t InteropDeviceHandle,
-                         const AdapterPtr &Adapter)
-    : device_impl(InteropDeviceHandle, nullptr, nullptr, Adapter) {}
-
 /// Constructs a SYCL device instance using the provided
 /// UR device instance.
 device_impl::device_impl(ur_device_handle_t Device, PlatformImplPtr Platform)
-    : device_impl(0, Device, Platform, Platform->getAdapter()) {}
-
-/// Constructs a SYCL device instance using the provided
-/// UR device instance.
-device_impl::device_impl(ur_device_handle_t Device, const AdapterPtr &Adapter)
-    : device_impl(0, Device, nullptr, Adapter) {}
-
-device_impl::device_impl(ur_native_handle_t InteropDeviceHandle,
-                         ur_device_handle_t Device, PlatformImplPtr Platform,
-                         const AdapterPtr &Adapter)
-    : MDevice(Device), MDeviceHostBaseTime(std::make_pair(0, 0)) {
-  bool InteroperabilityConstructor = false;
-  if (Device == nullptr) {
-    assert(InteropDeviceHandle);
-    // Get UR device from the raw device handle.
-    // NOTE: this is for OpenCL interop only (and should go away).
-    // With SYCL-2020 BE generalization "make" functions are used instead.
-    Adapter->call<UrApiKind::urDeviceCreateWithNativeHandle>(
-        InteropDeviceHandle, Adapter->getUrAdapter(), nullptr, &MDevice);
-    InteroperabilityConstructor = true;
-  }
+    : MDevice(Device), MPlatform(Platform),
+      MDeviceHostBaseTime(std::make_pair(0, 0)) {
+  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 == nullptr) || !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),
         &MRootDevice, nullptr);
   }
 
-  if (!InteroperabilityConstructor) {
-    // TODO catch an exception and put it to list of asynchronous exceptions
-    // Interoperability Constructor already calls DeviceRetain in
-    // urDeviceCreateWithNativeHandle.
-    Adapter->call<UrApiKind::urDeviceRetain>(MDevice);
-  }
-
-  // set MPlatform
-  if (!Platform) {
-    Platform = platform_impl::getPlatformFromUrDevice(MDevice, Adapter);
-  }
-  MPlatform = Platform;
+  // TODO catch an exception and put it to list of asynchronous exceptions
+  // Interoperability Constructor already calls DeviceRetain in
+  // urDeviceCreateWithNativeHandle.
+  Adapter->call<UrApiKind::urDeviceRetain>(MDevice);
 
   Adapter->call<UrApiKind::urDeviceGetInfo>(
       MDevice, UR_DEVICE_INFO_USE_NATIVE_ASSERT, sizeof(ur_bool_t),

sycl/source/detail/device_impl.hpp

@@ -35,20 +35,10 @@ using PlatformImplPtr = std::shared_ptr<platform_impl>;
 // TODO: Make code thread-safe
 class device_impl {
 public:
-  /// Constructs a SYCL device instance as a host device.
-  device_impl();
-
-  /// Constructs a SYCL device instance using the provided raw device handle.
-  explicit device_impl(ur_native_handle_t, const AdapterPtr &Adapter);
-
   /// Constructs a SYCL device instance using the provided
   /// UR device instance.
   explicit device_impl(ur_device_handle_t Device, PlatformImplPtr Platform);
 
-  /// Constructs a SYCL device instance using the provided
-  /// UR device instance.
-  explicit device_impl(ur_device_handle_t Device, const AdapterPtr &Adapter);
-
   ~device_impl();
 
   /// Get instance of OpenCL device
@@ -299,10 +289,6 @@ class device_impl {
   ext::oneapi::experimental::architecture getDeviceArch() const;
 
 private:
-  explicit device_impl(ur_native_handle_t InteropDevice,
-                       ur_device_handle_t Device, PlatformImplPtr Platform,
-                       const AdapterPtr &Adapter);
-
   ur_device_handle_t MDevice = 0;
   ur_device_type_t MType;
   ur_device_handle_t MRootDevice = nullptr;