global_handler.hpp

Go to the documentation of this file.

//==--------- 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>
#include <unordered_map>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
namespace detail {
class platform_impl;
class context_impl;
class Scheduler;
class ProgramManager;
class Sync;
class plugin;
class device_filter_list;
class XPTIRegistry;
class ThreadPool;
 
using PlatformImplPtr = std::shared_ptr<platform_impl>;
using ContextImplPtr = std::shared_ptr<context_impl>;
 
class GlobalHandler {
public:
  static GlobalHandler &instance();
 
  GlobalHandler(const GlobalHandler &) = delete;
  GlobalHandler(GlobalHandler &&) = delete;
 
  Scheduler &getScheduler();
  ProgramManager &getProgramManager();
  Sync &getSync();
  std::vector<PlatformImplPtr> &getPlatformCache();
 
  std::unordered_map<PlatformImplPtr, ContextImplPtr> &
  getPlatformToDefaultContextCache();
 
  std::mutex &getPlatformToDefaultContextCacheMutex();
  std::mutex &getPlatformMapMutex();
  std::mutex &getFilterMutex();
  std::vector<plugin> &getPlugins();
  device_filter_list &getDeviceFilterList(const std::string &InitValue);
  XPTIRegistry &getXPTIRegistry();
  std::mutex &getHandlerExtendedMembersMutex();
  ThreadPool &getHostTaskThreadPool();
 
  static void registerDefaultContextReleaseHandler();
 
private:
  friend void releaseDefaultContexts();
  friend void shutdown();
 
  // Constructor and destructor are declared out-of-line to allow incomplete
  // types as template arguments to unique_ptr.
  GlobalHandler();
  ~GlobalHandler();
 
  template <typename T> struct InstWithLock {
    std::unique_ptr<T> Inst;
    SpinLock Lock;
  };
 
  template <typename T, typename... Types>
  T &getOrCreate(InstWithLock<T> &IWL, Types... Args);
 
  InstWithLock<Scheduler> MScheduler;
  InstWithLock<ProgramManager> MProgramManager;
  InstWithLock<Sync> MSync;
  InstWithLock<std::vector<PlatformImplPtr>> MPlatformCache;
  InstWithLock<std::unordered_map<PlatformImplPtr, ContextImplPtr>>
      MPlatformToDefaultContextCache;
  InstWithLock<std::mutex> MPlatformToDefaultContextCacheMutex;
  InstWithLock<std::mutex> MPlatformMapMutex;
  InstWithLock<std::mutex> MFilterMutex;
  InstWithLock<std::vector<plugin>> MPlugins;
  InstWithLock<device_filter_list> MDeviceFilterList;
  InstWithLock<XPTIRegistry> MXPTIRegistry;
  // The mutex for synchronizing accesses to handlers extended members
  InstWithLock<std::mutex> MHandlerExtendedMembersMutex;
  // Thread pool for host task and event callbacks execution
  InstWithLock<ThreadPool> MHostTaskThreadPool;
};
} // namespace detail
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)