[SYCL] Wrap complex global objects to control lifetime (#2516)

The order of global constructor/destructor invocation is undefined. At the same
time, user may desire to make objects of SYCL classes global. Since there're
lots of global objects inside SYCL runtime (scheduler and program manager, to
name a few), they need to be wrapped with some trivial class/structure. The
object of that structure is allocated on heap and deallocated in
__attribute__((destructor))/DllMain, which guarantees, that SYCL global objects
will be destroyed after user objects.

Author: Alexander Batashev

sycl/include/CL/sycl/detail/spinlock.hpp

@@ -0,0 +1,40 @@
+//==-------------------- spinlock.hpp --- Spin lock ------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl/detail/defines.hpp>
+
+#include <atomic>
+#include <thread>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+/// SpinLock is a synchronization primitive, that uses atomic variable and
+/// causes thread trying acquire lock wait in loop while repeatedly check if
+/// the lock is available.
+///
+/// One important feature of this implementation is that std::atomic<bool> can
+/// be zero-initialized. This allows SpinLock to have trivial constructor and
+/// destructor, which makes it possible to use it in global context (unlike
+/// std::mutex, that doesn't provide such guarantees).
+class SpinLock {
+public:
+  void lock() {
+    while (MLock.test_and_set(std::memory_order_acquire))
+      std::this_thread::yield();
+  }
+  void unlock() { MLock.clear(std::memory_order_release); }
+
+private:
+  std::atomic_flag MLock{ATOMIC_FLAG_INIT};
+};
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/CMakeLists.txt

@@ -114,6 +114,7 @@ set(SYCL_SOURCES
     "detail/event_impl.cpp"
     "detail/filter_selector_impl.cpp"
     "detail/force_device.cpp"
+    "detail/global_handler.cpp"
     "detail/helpers.cpp"
     "detail/handler_proxy.cpp"
     "detail/image_accessor_util.cpp"

sycl/source/detail/config.hpp

@@ -13,6 +13,7 @@
 #include <CL/sycl/detail/device_filter.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <CL/sycl/info/info_desc.hpp>
+#include <detail/global_handler.hpp>
 
 #include <algorithm>
 #include <array>
@@ -181,8 +182,7 @@ template <> class SYCLConfig<SYCL_DEVICE_FILTER> {
 
     const char *ValStr = BaseT::getRawValue();
     if (ValStr) {
-      static device_filter_list DFL{ValStr};
-      FilterList = &DFL;
+      FilterList = &GlobalHandler::instance().getDeviceFilterList(ValStr);
     }
 
     // TODO: remove the following code when we remove the support for legacy

sycl/source/detail/global_handler.cpp

@@ -0,0 +1,139 @@
+//==--------- global_handler.cpp --- Global objects handler ----------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl/detail/device_filter.hpp>
+#include <CL/sycl/detail/spinlock.hpp>
+#include <detail/global_handler.hpp>
+#include <detail/platform_impl.hpp>
+#include <detail/plugin.hpp>
+#include <detail/program_manager/program_manager.hpp>
+#include <detail/scheduler/scheduler.hpp>
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <vector>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+GlobalHandler::GlobalHandler() = default;
+GlobalHandler::~GlobalHandler() = default;
+
+GlobalHandler &GlobalHandler::instance() {
+  static GlobalHandler *SyclGlobalObjectsHandler = new GlobalHandler();
+  return *SyclGlobalObjectsHandler;
+}
+
+Scheduler &GlobalHandler::getScheduler() {
+  if (MScheduler)
+    return *MScheduler;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MScheduler)
+    MScheduler = std::make_unique<Scheduler>();
+
+  return *MScheduler;
+}
+ProgramManager &GlobalHandler::getProgramManager() {
+  if (MProgramManager)
+    return *MProgramManager;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MProgramManager)
+    MProgramManager = std::make_unique<ProgramManager>();
+
+  return *MProgramManager;
+}
+Sync &GlobalHandler::getSync() {
+  if (MSync)
+    return *MSync;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MSync)
+    MSync = std::make_unique<Sync>();
+
+  return *MSync;
+}
+std::vector<PlatformImplPtr> &GlobalHandler::getPlatformCache() {
+  if (MPlatformCache)
+    return *MPlatformCache;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MPlatformCache)
+    MPlatformCache = std::make_unique<std::vector<PlatformImplPtr>>();
+
+  return *MPlatformCache;
+}
+std::mutex &GlobalHandler::getPlatformMapMutex() {
+  if (MPlatformMapMutex)
+    return *MPlatformMapMutex;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MPlatformMapMutex)
+    MPlatformMapMutex = std::make_unique<std::mutex>();
+
+  return *MPlatformMapMutex;
+}
+std::mutex &GlobalHandler::getFilterMutex() {
+  if (MFilterMutex)
+    return *MFilterMutex;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MFilterMutex)
+    MFilterMutex = std::make_unique<std::mutex>();
+
+  return *MFilterMutex;
+}
+std::vector<plugin> &GlobalHandler::getPlugins() {
+  if (MPlugins)
+    return *MPlugins;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MPlugins)
+    MPlugins = std::make_unique<std::vector<plugin>>();
+
+  return *MPlugins;
+}
+device_filter_list &
+GlobalHandler::getDeviceFilterList(const std::string &InitValue) {
+  if (MDeviceFilterList)
+    return *MDeviceFilterList;
+
+  const std::lock_guard<SpinLock> Lock{MFieldsLock};
+  if (!MDeviceFilterList)
+    MDeviceFilterList = std::make_unique<device_filter_list>(InitValue);
+
+  return *MDeviceFilterList;
+}
+
+void shutdown() { delete &GlobalHandler::instance(); }
+
+#ifdef WIN32
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) {
+  // Perform actions based on the reason for calling.
+  switch (fdwReason) {
+  case DLL_PROCESS_DETACH:
+    shutdown();
+    break;
+  case DLL_PROCESS_ATTACH:
+  case DLL_THREAD_ATTACH:
+  case DLL_THREAD_DETACH:
+    break;
+  }
+  return TRUE; // Successful DLL_PROCESS_ATTACH.
+}
+#else
+// Setting maximum priority on destructor ensures it runs after all other global
+// destructors.
+__attribute__((destructor(65535))) static void syclUnload() { shutdown(); }
+#endif
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/global_handler.hpp

@@ -0,0 +1,80 @@
+//==--------- global_handler.hpp --- Global objects handler ----------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl/detail/spinlock.hpp>
+#include <CL/sycl/detail/util.hpp>
+
+#include <memory>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+class platform_impl;
+class Scheduler;
+class ProgramManager;
+class Sync;
+class plugin;
+class device_filter_list;
+
+using PlatformImplPtr = std::shared_ptr<platform_impl>;
+
+/// Wrapper class for global data structures with non-trivial destructors.
+///
+/// As user code can call SYCL Runtime functions from destructor of global
+/// objects, it is not safe for the runtime library to have global objects with
+/// non-trivial destructors. Such destructors can be called any time after
+/// exiting main, which may result in user application crashes. Instead,
+/// complex global objects must be wrapped into GlobalHandler. Its instance
+/// is stored on heap, and deallocated when the runtime library is being
+/// unloaded.
+///
+/// There's no need to store trivial globals here, as no code for their
+/// construction or destruction is generated anyway.
+class GlobalHandler {
+public:
+  /// \return a reference to a GlobalHandler singleton instance. Memory for
+  /// storing objects is allocated on first call. The reference is valid as long
+  /// as runtime library is loaded (i.e. untill `DllMain` or
+  /// `__attribute__((destructor))` is called).
+  static GlobalHandler &instance();
+
+  GlobalHandler(const GlobalHandler &) = delete;
+  GlobalHandler(GlobalHandler &&) = delete;
+
+  Scheduler &getScheduler();
+  ProgramManager &getProgramManager();
+  Sync &getSync();
+  std::vector<PlatformImplPtr> &getPlatformCache();
+  std::mutex &getPlatformMapMutex();
+  std::mutex &getFilterMutex();
+  std::vector<plugin> &getPlugins();
+  device_filter_list &getDeviceFilterList(const std::string &InitValue);
+
+private:
+  friend void shutdown();
+  // Constructor and destructor are declared out-of-line to allow incomplete
+  // types as template arguments to unique_ptr.
+  GlobalHandler();
+  ~GlobalHandler();
+
+  SpinLock MFieldsLock;
+
+  std::unique_ptr<Scheduler> MScheduler;
+  std::unique_ptr<ProgramManager> MProgramManager;
+  std::unique_ptr<Sync> MSync;
+  std::unique_ptr<std::vector<PlatformImplPtr>> MPlatformCache;
+  std::unique_ptr<std::mutex> MPlatformMapMutex;
+  std::unique_ptr<std::mutex> MFilterMutex;
+  std::unique_ptr<std::vector<plugin>> MPlugins;
+  std::unique_ptr<device_filter_list> MDeviceFilterList;
+};
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/pi.cpp

@@ -17,6 +17,7 @@
 #include <CL/sycl/detail/device_filter.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/config.hpp>
+#include <detail/global_handler.hpp>
 #include <detail/plugin.hpp>
 
 #include <bitset>
@@ -283,18 +284,12 @@ bool trace(TraceLevel Level) {
 // Initializes all available Plugins.
 const vector_class<plugin> &initialize() {
   static std::once_flag PluginsInitDone;
-  static vector_class<plugin> *Plugins = nullptr;
 
   std::call_once(PluginsInitDone, []() {
-    // The memory for "Plugins" is intentionally leaked because the application
-    // may call into the SYCL runtime from a global destructor, and such a call
-    // could eventually call down to initialize().  Therefore, there is no safe
-    // time when "Plugins" could be deleted.
-    Plugins = new vector_class<plugin>;
-    initializePlugins(Plugins);
+    initializePlugins(&GlobalHandler::instance().getPlugins());
   });
 
-  return *Plugins;
+  return GlobalHandler::instance().getPlugins();
 }
 
 static void initializePlugins(vector_class<plugin> *Plugins) {

sycl/source/detail/platform_impl.cpp

@@ -10,13 +10,15 @@
 #include <detail/config.hpp>
 #include <detail/device_impl.hpp>
 #include <detail/force_device.hpp>
+#include <detail/global_handler.hpp>
 #include <detail/platform_impl.hpp>
 #include <detail/platform_info.hpp>
 
 #include <algorithm>
 #include <cstring>
 #include <regex>
 #include <string>
+#include <vector>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
@@ -32,12 +34,13 @@ PlatformImplPtr platform_impl::getHostPlatformImpl() {
 
 PlatformImplPtr platform_impl::getOrMakePlatformImpl(RT::PiPlatform PiPlatform,
                                                      const plugin &Plugin) {
-  static std::vector<PlatformImplPtr> PlatformCache;
-  static std::mutex PlatformMapMutex;
-
   PlatformImplPtr Result;
   {
-    const std::lock_guard<std::mutex> Guard(PlatformMapMutex);
+    const std::lock_guard<std::mutex> Guard(
+        GlobalHandler::instance().getPlatformMapMutex());
+
+    std::vector<PlatformImplPtr> &PlatformCache =
+        GlobalHandler::instance().getPlatformCache();
 
     // If we've already seen this platform, return the impl
     for (const auto &PlatImpl : PlatformCache) {
@@ -323,7 +326,7 @@ platform_impl::get_devices(info::device_type DeviceType) const {
   if (is_host() || DeviceType == info::device_type::host)
     return Res;
 
-  pi_uint32 NumDevices;
+  pi_uint32 NumDevices = 0;
   const detail::plugin &Plugin = getPlugin();
   Plugin.call<PiApiKind::piDevicesGet>(
       MPlatform, pi::cast<RT::PiDeviceType>(DeviceType), 0,

sycl/source/detail/platform_impl.hpp

@@ -20,8 +20,10 @@ namespace sycl {
 // Forward declaration
 class device_selector;
 class device;
+enum class aspect;
 
 namespace detail {
+class device_impl;
 
 // TODO: implement extension management for host device
 // TODO: implement parameters treatment for host device

sycl/source/detail/program_manager/program_manager.cpp

@@ -19,6 +19,7 @@
 #include <detail/config.hpp>
 #include <detail/context_impl.hpp>
 #include <detail/device_impl.hpp>
+#include <detail/global_handler.hpp>
 #include <detail/program_impl.hpp>
 #include <detail/program_manager/program_manager.hpp>
 #include <detail/spec_constant_impl.hpp>
@@ -47,9 +48,7 @@ enum BuildState { BS_InProgress, BS_Done, BS_Failed };
 static constexpr char UseSpvEnv[]("SYCL_USE_KERNEL_SPV");
 
 ProgramManager &ProgramManager::getInstance() {
-  // The singleton ProgramManager instance, uses the "magic static" idiom.
-  static ProgramManager Instance;
-  return Instance;
+  return GlobalHandler::instance().getProgramManager();
 }
 
 static RT::PiProgram createBinaryProgram(const ContextImplPtr Context,