program_manager.hpp

Go to the documentation of this file.

//==------ program_manager.hpp --- SYCL program manager---------------------==//
//
// 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_binary_image.hpp>
#include <detail/device_global_map_entry.hpp>
#include <detail/spec_constant_impl.hpp>
#include <sycl/detail/common.hpp>
#include <sycl/detail/export.hpp>
#include <sycl/detail/os_util.hpp>
#include <sycl/detail/pi.hpp>
#include <sycl/detail/util.hpp>
#include <sycl/device.hpp>
#include <sycl/kernel_bundle.hpp>
#include <sycl/stl.hpp>
 
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
// +++ Entry points referenced by the offload wrapper object {
 
extern "C" __SYCL_EXPORT void __sycl_register_lib(pi_device_binaries desc);
 
extern "C" __SYCL_EXPORT void __sycl_unregister_lib(pi_device_binaries desc);
 
// +++ }
 
namespace sycl {
__SYCL_INLINE_VER_NAMESPACE(_V1) {
class context;
namespace detail {
 
// This value must be the same as in libdevice/device_itt.h.
// See sycl/doc/design/ITTAnnotations.md for more info.
static constexpr uint32_t inline ITTSpecConstId = 0xFF747469;
 
class context_impl;
using ContextImplPtr = std::shared_ptr<context_impl>;
class device_impl;
using DeviceImplPtr = std::shared_ptr<device_impl>;
class program_impl;
// DeviceLibExt is shared between sycl runtime and sycl-post-link tool.
// If any update is made here, need to sync with DeviceLibExt definition
// in llvm/tools/sycl-post-link/sycl-post-link.cpp
enum class DeviceLibExt : std::uint32_t {
  cl_intel_devicelib_assert,
  cl_intel_devicelib_math,
  cl_intel_devicelib_math_fp64,
  cl_intel_devicelib_complex,
  cl_intel_devicelib_complex_fp64,
  cl_intel_devicelib_cstring,
  cl_intel_devicelib_imf,
  cl_intel_devicelib_imf_fp64,
};
 
// Provides single loading and building OpenCL programs with unique contexts
// that is necessary for no interoperability cases with lambda.
class ProgramManager {
public:
  // TODO use a custom dynamic bitset instead to make initialization simpler.
  using KernelArgMask = std::vector<bool>;
 
  // Returns the single instance of the program manager for the entire
  // process. Can only be called after staticInit is done.
  static ProgramManager &getInstance();
  RTDeviceBinaryImage &getDeviceImage(OSModuleHandle M,
                                      const std::string &KernelName,
                                      const context &Context,
                                      const device &Device,
                                      bool JITCompilationIsRequired = false);
  RT::PiProgram createPIProgram(const RTDeviceBinaryImage &Img,
                                const context &Context, const device &Device);
  std::pair<RT::PiProgram, bool>
  getOrCreatePIProgram(const RTDeviceBinaryImage &Img, const context &Context,
                       const device &Device,
                       const std::string &CompileAndLinkOptions,
                       SerializedObj SpecConsts);
  RT::PiProgram getBuiltPIProgram(OSModuleHandle M,
                                  const ContextImplPtr &ContextImpl,
                                  const DeviceImplPtr &DeviceImpl,
                                  const std::string &KernelName,
                                  const program_impl *Prg = nullptr,
                                  bool JITCompilationIsRequired = false);
 
  RT::PiProgram getBuiltPIProgram(OSModuleHandle M, const context &Context,
                                  const device &Device,
                                  const std::string &KernelName,
                                  const property_list &PropList,
                                  bool JITCompilationIsRequired = false);
 
  std::tuple<RT::PiKernel, std::mutex *, RT::PiProgram>
  getOrCreateKernel(OSModuleHandle M, const ContextImplPtr &ContextImpl,
                    const DeviceImplPtr &DeviceImpl,
                    const std::string &KernelName, const program_impl *Prg);
 
  RT::PiProgram getPiProgramFromPiKernel(RT::PiKernel Kernel,
                                         const ContextImplPtr Context);
 
  void addImages(pi_device_binaries DeviceImages);
  void debugPrintBinaryImages() const;
  static std::string getProgramBuildLog(const RT::PiProgram &Program,
                                        const ContextImplPtr Context);
 
  void flushSpecConstants(const program_impl &Prg,
                          pi::PiProgram NativePrg = nullptr,
                          const RTDeviceBinaryImage *Img = nullptr);
  uint32_t getDeviceLibReqMask(const RTDeviceBinaryImage &Img);
 
  KernelArgMask getEliminatedKernelArgMask(OSModuleHandle M,
                                           pi::PiProgram NativePrg,
                                           const std::string &KernelName);
 
  // The function returns the unique SYCL kernel identifier associated with a
  // kernel name.
  kernel_id getSYCLKernelID(const std::string &KernelName);
 
  // The function returns a vector containing all unique SYCL kernel identifiers
  // in SYCL device images.
  std::vector<kernel_id> getAllSYCLKernelIDs();
 
  // The function returns the unique SYCL kernel identifier associated with a
  // built-in kernel name.
  kernel_id getBuiltInKernelID(const std::string &KernelName);
 
  // The function inserts or initializes a device_global entry into the
  // device_global map.
  void addOrInitDeviceGlobalEntry(const void *DeviceGlobalPtr,
                                  const char *UniqueId);
 
  // Returns true if any available image is compatible with the device Dev.
  bool hasCompatibleImage(const device &Dev);
 
  // The function returns a vector of SYCL device images that are compiled with
  // the required state and at least one device from the passed list of devices.
  std::vector<device_image_plain> getSYCLDeviceImagesWithCompatibleState(
      const context &Ctx, const std::vector<device> &Devs,
      bundle_state TargetState, const std::vector<kernel_id> &KernelIDs = {});
 
  // Brind images in the passed vector to the required state. Does it inplace
  void
  bringSYCLDeviceImagesToState(std::vector<device_image_plain> &DeviceImages,
                               bundle_state TargetState);
 
  // The function returns a vector of SYCL device images in required state,
  // which are compatible with at least one of the device from Devs.
  std::vector<device_image_plain>
  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
                      bundle_state State);
 
  // The function returns a vector of SYCL device images, for which Selector
  // callable returns true, in required state, which are compatible with at
  // least one of the device from Devs.
  std::vector<device_image_plain>
  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
                      const DevImgSelectorImpl &Selector,
                      bundle_state TargetState);
 
  // The function returns a vector of SYCL device images which represent at
  // least one kernel from kernel ids vector in required state, which are
  // compatible with at least one of the device from Devs.
  std::vector<device_image_plain>
  getSYCLDeviceImages(const context &Ctx, const std::vector<device> &Devs,
                      const std::vector<kernel_id> &KernelIDs,
                      bundle_state TargetState);
 
  // Produces new device image by convering input device image to the object
  // state
  device_image_plain compile(const device_image_plain &DeviceImage,
                             const std::vector<device> &Devs,
                             const property_list &PropList);
 
  // Produces set of device images by convering input device images to object
  // the executable state
  std::vector<device_image_plain>
  link(const std::vector<device_image_plain> &DeviceImages,
       const std::vector<device> &Devs, const property_list &PropList);
 
  // Produces new device image by converting input device image to the
  // executable state
  device_image_plain build(const device_image_plain &DeviceImage,
                           const std::vector<device> &Devs,
                           const property_list &PropList);
 
  std::pair<RT::PiKernel, std::mutex *>
  getOrCreateKernel(const context &Context, const std::string &KernelName,
                    const property_list &PropList, RT::PiProgram Program);
 
  ProgramManager();
  ~ProgramManager() = default;
 
  bool kernelUsesAssert(OSModuleHandle M, const std::string &KernelName) const;
 
private:
  ProgramManager(ProgramManager const &) = delete;
  ProgramManager &operator=(ProgramManager const &) = delete;
 
  RTDeviceBinaryImage &getDeviceImage(OSModuleHandle M, KernelSetId KSId,
                                      const context &Context,
                                      const device &Device,
                                      bool JITCompilationIsRequired = false);
  using ProgramPtr = std::unique_ptr<remove_pointer_t<RT::PiProgram>,
                                     decltype(&::piProgramRelease)>;
  ProgramPtr build(ProgramPtr Program, const ContextImplPtr Context,
                   const std::string &CompileOptions,
                   const std::string &LinkOptions, const RT::PiDevice &Device,
                   uint32_t DeviceLibReqMask);
  KernelSetId getNextKernelSetId() const;
  KernelSetId getKernelSetId(OSModuleHandle M,
                             const std::string &KernelName) const;
  void dumpImage(const RTDeviceBinaryImage &Img, KernelSetId KSId) const;
 
  void cacheKernelUsesAssertInfo(OSModuleHandle M, RTDeviceBinaryImage &Img);
 
 
  using RTDeviceBinaryImageUPtr = std::unique_ptr<RTDeviceBinaryImage>;
 
  std::unordered_map<KernelSetId,
                     std::unique_ptr<std::vector<RTDeviceBinaryImageUPtr>>>
      m_DeviceImages;
 
  using StrToKSIdMap = std::unordered_map<std::string, KernelSetId>;
  std::unordered_map<OSModuleHandle, StrToKSIdMap> m_KernelSets;
 
  std::unordered_map<OSModuleHandle, KernelSetId> m_OSModuleKernelSets;
 
  //
  std::unordered_map<std::string, kernel_id> m_KernelName2KernelIDs;
 
  // Maps KernelIDs to device binary images. There can be more than one image
  // in case of SPIRV + AOT.
  std::unordered_multimap<kernel_id, RTDeviceBinaryImage *>
      m_KernelIDs2BinImage;
 
  // Maps device binary image to a vector of kernel ids in this image.
  // Using shared_ptr to avoid expensive copy of the vector.
  // The vector is initialized in addImages function and is supposed to be
  // immutable afterwards.
  std::unordered_map<RTDeviceBinaryImage *,
                     std::shared_ptr<std::vector<kernel_id>>>
      m_BinImg2KernelIDs;
 
  std::mutex m_KernelIDsMutex;
 
  std::unordered_set<std::string> m_ServiceKernels;
 
  // from kernel bundles.
  std::unordered_set<std::string> m_ExportedSymbols;
 
  std::unordered_map<std::string, kernel_id> m_BuiltInKernelIDs;
 
  std::mutex m_BuiltInKernelIDsMutex;
 
  // Keeps track of pi_program to image correspondence. Needed for:
  // - knowing which specialization constants are used in the program and
  //   injecting their current values before compiling the SPIR-V; the binary
  //   image object has info about all spec constants used in the module
  // - finding kernel argument masks for kernels associated with each
  //   pi_program
  // NOTE: using RTDeviceBinaryImage raw pointers is OK, since they are not
  // referenced from outside SYCL runtime and RTDeviceBinaryImage object
  // lifetime matches program manager's one.
  // NOTE: keys in the map can be invalid (reference count went to zero and
  // the underlying program disposed of), so the map can't be used in any way
  // other than binary image lookup with known live PiProgram as the key.
  // NOTE: access is synchronized via the MNativeProgramsMutex
  std::unordered_map<pi::PiProgram, const RTDeviceBinaryImage *> NativePrograms;
 
  std::mutex MNativeProgramsMutex;
 
  using KernelNameToArgMaskMap = std::unordered_map<std::string, KernelArgMask>;
  std::unordered_map<const RTDeviceBinaryImage *, KernelNameToArgMaskMap>
      m_EliminatedKernelArgMasks;
 
  bool m_UseSpvFile = false;
 
  using KernelNameWithOSModule = std::pair<std::string, OSModuleHandle>;
  std::set<KernelNameWithOSModule> m_KernelUsesAssert;
 
  // Maps between device_global identifiers and associated information.
  std::unordered_map<std::string, std::unique_ptr<DeviceGlobalMapEntry>>
      m_DeviceGlobals;
  std::unordered_map<const void *, DeviceGlobalMapEntry *> m_Ptr2DeviceGlobal;
 
  std::mutex m_DeviceGlobalsMutex;
};
} // namespace detail
} // __SYCL_INLINE_VER_NAMESPACE(_V1)
} // namespace sycl