[SYCL] Keep platform_impl's device_impls alive until shutdown

sycl/source/detail/global_handler.cpp

@@ -211,6 +211,14 @@ std::vector<std::shared_ptr<platform_impl>> &GlobalHandler::getPlatformCache() {
   return PlatformCache;
 }
 
+void GlobalHandler::clearPlatforms() {
+  if (!MPlatformCache.Inst)
+    return;
+  for (auto &PltSmartPtr : *MPlatformCache.Inst)
+    PltSmartPtr->MDevices.clear();
+  MPlatformCache.Inst->clear();
+}
+
 std::mutex &GlobalHandler::getPlatformMapMutex() {
   static std::mutex &PlatformMapMutex = getOrCreate(MPlatformMapMutex);
   return PlatformMapMutex;
@@ -366,6 +374,7 @@ void shutdown_late() {
 #endif
 
   // First, release resources, that may access adapters.
+  Handler->clearPlatforms(); // includes dropping platforms' devices ownership.
   Handler->MPlatformCache.Inst.reset(nullptr);
   Handler->MScheduler.Inst.reset(nullptr);
   Handler->MProgramManager.Inst.reset(nullptr);

sycl/source/detail/global_handler.hpp

@@ -61,6 +61,8 @@ class GlobalHandler {
   Sync &getSync();
   std::vector<std::shared_ptr<platform_impl>> &getPlatformCache();
 
+  void clearPlatforms();
+
   std::unordered_map<platform_impl *, ContextImplPtr> &
   getPlatformToDefaultContextCache();
 

sycl/source/detail/platform_impl.cpp

@@ -306,7 +306,7 @@ platform_impl::getOrMakeDeviceImpl(ur_device_handle_t UrDevice) {
   // Otherwise make the impl
   Result = std::make_shared<device_impl>(UrDevice, *this,
                                          device_impl::private_tag{});
-  MDeviceCache.emplace_back(Result);
+  MDevices.emplace_back(Result);
 
   return Result;
 }
@@ -637,11 +637,9 @@ bool platform_impl::has(aspect Aspect) const {
 
 std::shared_ptr<device_impl>
 platform_impl::getDeviceImplHelper(ur_device_handle_t UrDevice) {
-  for (const std::weak_ptr<device_impl> &DeviceWP : MDeviceCache) {
-    if (std::shared_ptr<device_impl> Device = DeviceWP.lock()) {
-      if (Device->getHandleRef() == UrDevice)
-        return Device;
-    }
+  for (const std::shared_ptr<device_impl> &Device : MDevices) {
+    if (Device->getHandleRef() == UrDevice)
+      return Device;
   }
   return nullptr;
 }

sycl/source/detail/platform_impl.hpp

@@ -217,7 +217,8 @@ class platform_impl : public std::enable_shared_from_this<platform_impl> {
 
   AdapterPtr MAdapter;
 
-  std::vector<std::weak_ptr<device_impl>> MDeviceCache;
+  std::vector<std::shared_ptr<device_impl>> MDevices;
+  friend class GlobalHandler;
   std::mutex MDeviceMapMutex;
 };
 

sycl/unittests/context_device/DeviceRefCounter.cpp

@@ -31,14 +31,14 @@ static ur_result_t redefinedDeviceReleaseAfter(void *) {
 TEST(DevRefCounter, DevRefCounter) {
   {
     sycl::unittest::UrMock<> Mock;
-    sycl::platform Plt = sycl::platform();
 
     mock::getCallbacks().set_after_callback("urDeviceGet",
                                             &redefinedDevicesGetAfter);
     mock::getCallbacks().set_after_callback("urDeviceRetain",
                                             &redefinedDeviceRetainAfter);
     mock::getCallbacks().set_after_callback("urDeviceRelease",
                                             &redefinedDeviceReleaseAfter);
+    sycl::platform Plt = sycl::platform();
 
     Plt.get_devices();
   }

sycl/unittests/helpers/UrMock.hpp

@@ -612,7 +612,11 @@ template <sycl::backend Backend = backend::opencl> class UrMock {
     // clear platform cache in case subsequent tests want a different backend,
     // this forces platforms to be reconstructed (and thus queries about UR
     // backend info to be called again)
-    detail::GlobalHandler::instance().getPlatformCache().clear();
+    //
+    // This also erases each platform's devices (normally done in the library
+    // shutdown) so that platforms/devices' lifetimes could work in unittests
+    // scenario.
+    detail::GlobalHandler::instance().clearPlatforms();
     mock::getCallbacks().resetCallbacks();
   }