context_impl.hpp

Go to the documentation of this file.

//==---------------- context_impl.hpp - SYCL context ------------*- C++-*---==//
//
// 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 <detail/device_impl.hpp>
#include <detail/kernel_program_cache.hpp>
#include <detail/platform_impl.hpp>
#include <detail/program_manager/program_manager.hpp>
#include <sycl/detail/common.hpp>
#include <sycl/detail/os_util.hpp>
#include <sycl/detail/pi.hpp>
#include <sycl/exception_list.hpp>
#include <sycl/info/info_desc.hpp>
#include <sycl/property_list.hpp>
 
#include <map>
#include <memory>
#include <optional>
#include <set>
 
namespace sycl {
inline namespace _V1 {
// Forward declaration
class device;
namespace detail {
using PlatformImplPtr = std::shared_ptr<detail::platform_impl>;
class context_impl {
public:
  context_impl(const device &Device, async_handler AsyncHandler,
               const property_list &PropList);
 
  context_impl(const std::vector<sycl::device> DeviceList,
               async_handler AsyncHandler, const property_list &PropList);
 
  context_impl(sycl::detail::pi::PiContext PiContext,
               async_handler AsyncHandler, const PluginPtr &Plugin,
               const std::vector<sycl::device> &DeviceList = {},
               bool OwnedByRuntime = true);
 
  ~context_impl();
 
  template <typename propertyT> bool has_property() const noexcept {
    return MPropList.has_property<propertyT>();
  }
 
  template <typename propertyT> propertyT get_property() const {
    return MPropList.get_property<propertyT>();
  }
 
  cl_context get() const;
 
  bool is_host() const;
 
  const async_handler &get_async_handler() const;
 
  const PluginPtr &getPlugin() const { return MPlatform->getPlugin(); }
 
  PlatformImplPtr getPlatformImpl() const { return MPlatform; }
 
  template <typename Param> typename Param::return_type get_info() const;
 
  template <typename Param>
  typename Param::return_type get_backend_info() const;
 
  sycl::detail::pi::PiContext &getHandleRef();
 
  const sycl::detail::pi::PiContext &getHandleRef() const;
 
  const std::vector<device> &getDevices() const { return MDevices; }
 
  using CachedLibProgramsT =
      std::map<std::pair<DeviceLibExt, sycl::detail::pi::PiDevice>,
               sycl::detail::pi::PiProgram>;
 
  Locked<CachedLibProgramsT> acquireCachedLibPrograms() {
    return {MCachedLibPrograms, MCachedLibProgramsMutex};
  }
 
  KernelProgramCache &getKernelProgramCache() const;
 
  bool hasDevice(std::shared_ptr<detail::device_impl> Device) const;
 
  bool isDeviceValid(DeviceImplPtr Device) {
    // OpenCL does not support using descendants of context members within that
    // context yet.
    // TODO remove once this limitation is lifted
    if (!is_host() && Device->getBackend() == backend::opencl)
      return hasDevice(Device);
 
    while (!hasDevice(Device)) {
      if (Device->isRootDevice())
        return false;
      Device = detail::getSyclObjImpl(
          Device->get_info<info::device::parent_device>());
    }
 
    return true;
  }
 
  // Returns the backend of this context
  backend getBackend() const {
    assert(MPlatform && "MPlatform must be not null");
    return MPlatform->getBackend();
  }
 
  DeviceImplPtr
  findMatchingDeviceImpl(sycl::detail::pi::PiDevice &DevicePI) const;
 
  pi_native_handle getNative() const;
 
  // Returns true if buffer_location property is supported by devices
  bool isBufferLocationSupported() const;
 
  void addAssociatedDeviceGlobal(const void *DeviceGlobalPtr);
 
  void addDeviceGlobalInitializer(sycl::detail::pi::PiProgram Program,
                                  const std::vector<device> &Devs,
                                  const RTDeviceBinaryImage *BinImage);
 
  std::vector<sycl::detail::pi::PiEvent>
  initializeDeviceGlobals(pi::PiProgram NativePrg,
                          const std::shared_ptr<queue_impl> &QueueImpl);
 
  void memcpyToHostOnlyDeviceGlobal(
      const std::shared_ptr<device_impl> &DeviceImpl,
      const void *DeviceGlobalPtr, const void *Src, size_t DeviceGlobalTSize,
      bool IsDeviceImageScoped, size_t NumBytes, size_t Offset);
 
  void
  memcpyFromHostOnlyDeviceGlobal(const std::shared_ptr<device_impl> &DeviceImpl,
                                 void *Dest, const void *DeviceGlobalPtr,
                                 bool IsDeviceImageScoped, size_t NumBytes,
                                 size_t Offset);
 
  std::optional<sycl::detail::pi::PiProgram>
  getProgramForDeviceGlobal(const device &Device,
                            DeviceGlobalMapEntry *DeviceGlobalEntry);
  std::optional<sycl::detail::pi::PiProgram>
  getProgramForHostPipe(const device &Device, HostPipeMapEntry *HostPipeEntry);
 
  std::optional<sycl::detail::pi::PiProgram>
  getProgramForDevImgs(const device &Device,
                       const std::set<std::uintptr_t> &ImgIdentifiers,
                       const std::string &ObjectTypeName);
 
  bool isOwnedByRuntime() { return MOwnedByRuntime; };
 
  enum PropertySupport { NotSupported = 0, Supported = 1, NotChecked = 2 };
 
private:
  bool MOwnedByRuntime;
  async_handler MAsyncHandler;
  std::vector<device> MDevices;
  sycl::detail::pi::PiContext MContext;
  PlatformImplPtr MPlatform;
  property_list MPropList;
  bool MHostContext;
  CachedLibProgramsT MCachedLibPrograms;
  std::mutex MCachedLibProgramsMutex;
  mutable KernelProgramCache MKernelProgramCache;
  mutable PropertySupport MSupportBufferLocationByDevices;
 
  std::set<const void *> MAssociatedDeviceGlobals;
  std::mutex MAssociatedDeviceGlobalsMutex;
 
  struct DeviceGlobalInitializer {
    DeviceGlobalInitializer() = default;
    DeviceGlobalInitializer(const RTDeviceBinaryImage *BinImage)
        : MBinImage(BinImage) {
      // If there are no device globals, they are trivially fully initialized.
      // Note: Lock is not needed during construction.
      MDeviceGlobalsFullyInitialized = BinImage->getDeviceGlobals().size() == 0;
    }
 
    void ClearEvents(const PluginPtr &Plugin);
 
    const RTDeviceBinaryImage *MBinImage = nullptr;
 
    std::mutex MDeviceGlobalInitMutex;
 
    bool MDeviceGlobalsFullyInitialized = false;
 
    std::vector<sycl::detail::pi::PiEvent> MDeviceGlobalInitEvents;
  };
 
  std::map<std::pair<sycl::detail::pi::PiProgram, sycl::detail::pi::PiDevice>,
           DeviceGlobalInitializer>
      MDeviceGlobalInitializers;
  std::mutex MDeviceGlobalInitializersMutex;
 
  // For device_global variables that are not used in any kernel code we still
  // allow copy operations on them. MDeviceGlobalUnregisteredData stores the
  // associated writes.
  // The key to this map is a combination of a the pointer to the device_global
  // and optionally a device if the device_global has device image scope.
  std::map<std::pair<const void *, std::optional<sycl::detail::pi::PiDevice>>,
           std::unique_ptr<std::byte[]>>
      MDeviceGlobalUnregisteredData;
  std::mutex MDeviceGlobalUnregisteredDataMutex;
};
 
template <typename T, typename Capabilities>
void GetCapabilitiesIntersectionSet(const std::vector<sycl::device> &Devices,
                                    std::vector<T> &CapabilityList) {
  for (const sycl::device &Device : Devices) {
    std::vector<T> NewCapabilityList;
    std::vector<T> DeviceCapabilities = Device.get_info<Capabilities>();
    std::set_intersection(
        CapabilityList.begin(), CapabilityList.end(),
        DeviceCapabilities.begin(), DeviceCapabilities.end(),
        std::inserter(NewCapabilityList, NewCapabilityList.begin()));
    CapabilityList = NewCapabilityList;
  }
  CapabilityList.shrink_to_fit();
}
 
} // namespace detail
} // namespace _V1
} // namespace sycl