program_impl.hpp

Go to the documentation of this file.

//==----- program_impl.hpp --- SYCL program implementation -----------------==//
//
// 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/context.hpp>
#include <CL/sycl/detail/common_info.hpp>
#include <CL/sycl/detail/kernel_desc.hpp>
#include <CL/sycl/device.hpp>
#include <CL/sycl/program.hpp>
#include <CL/sycl/property_list.hpp>
#include <CL/sycl/stl.hpp>
#include <detail/context_impl.hpp>
#include <detail/program_manager/program_manager.hpp>
#include <detail/spec_constant_impl.hpp>
 
#include <algorithm>
#include <cassert>
#include <fstream>
#include <memory>
#include <mutex>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
 
// Forward declarations
class kernel;
 
namespace detail {
 
using ContextImplPtr = std::shared_ptr<detail::context_impl>;
 
class program_impl {
public:
  program_impl() = delete;
 
  explicit program_impl(ContextImplPtr Context, const property_list &PropList);
 
  program_impl(ContextImplPtr Context, std::vector<device> DeviceList,
               const property_list &PropList);
 
  program_impl(std::vector<std::shared_ptr<program_impl>> ProgramList,
               std::string LinkOptions, const property_list &PropList);
 
  program_impl(ContextImplPtr Context, pi_native_handle InteropProgram);
 
  program_impl(ContextImplPtr Context, RT::PiKernel Kernel);
 
  ~program_impl();
 
  template <typename propertyT> bool has_property() const {
    return MPropList.has_property<propertyT>();
  }
 
  template <typename propertyT> propertyT get_property() const {
    return MPropList.get_property<propertyT>();
  }
 
  cl_program get() const;
 
  RT::PiProgram &getHandleRef() { return MProgram; }
  const RT::PiProgram &getHandleRef() const { return MProgram; }
 
  bool is_host() const { return MContext->is_host(); }
 
  void compile_with_kernel_name(std::string KernelName,
                                std::string CompileOptions,
                                OSModuleHandle Module);
 
  void compile_with_source(std::string KernelSource,
                           std::string CompileOptions = "");
 
  void build_with_kernel_name(std::string KernelName, std::string BuildOptions,
                              OSModuleHandle M);
 
  void build_with_source(std::string KernelSource,
                         std::string BuildOptions = "");
 
  void link(std::string LinkOptions = "");
 
  bool has_kernel(std::string KernelName, bool IsCreatedFromSource) const;
 
  kernel get_kernel(std::string KernelName,
                    std::shared_ptr<program_impl> PtrToSelf,
                    bool IsCreatedFromSource) const;
 
  template <info::program param>
  typename info::param_traits<info::program, param>::return_type
  get_info() const;
 
  std::vector<std::vector<char>> get_binaries() const;
 
  context get_context() const {
    if (is_host())
      return context();
    return createSyclObjFromImpl<context>(MContext);
  }
 
  const plugin &getPlugin() const {
    assert(!is_host() && "Plugin is not available for Host.");
    return MContext->getPlugin();
  }
 
  std::vector<device> get_devices() const { return MDevices; }
 
  std::string get_compile_options() const { return MCompileOptions; }
 
  std::string get_link_options() const { return MLinkOptions; }
 
  std::string get_build_options() const { return MBuildOptions; }
 
  program_state get_state() const { return MState; }
 
  void set_spec_constant_impl(const char *Name, const void *ValAddr,
                              size_t ValSize);
 
  void flush_spec_constants(const RTDeviceBinaryImage &Img,
                            RT::PiProgram NativePrg = nullptr) const;
 
  OSModuleHandle getOSModuleHandle() const { return MProgramModuleHandle; }
 
  void stableSerializeSpecConstRegistry(SerializedObj &Dst) const {
    detail::stableSerializeSpecConstRegistry(SpecConstRegistry, Dst);
  }
 
  bool hasSetSpecConstants() const { return !SpecConstRegistry.empty(); }
 
  bool is_cacheable() const { return MProgramAndKernelCachingAllowed; }
 
  pi_native_handle getNative() const;
 
  bool isInterop() const { return MIsInterop; }
 
private:
  // Deligating Constructor used in Implementation.
  program_impl(ContextImplPtr Context, pi_native_handle InteropProgram,
               RT::PiProgram Program);
  template <info::device param>
  void check_device_feature_support(const std::vector<device> &Devices) {
    for (const auto &Device : Devices) {
      if (!Device.get_info<param>()) {
        throw feature_not_supported(
            "Online compilation is not supported by this device",
            PI_COMPILER_NOT_AVAILABLE);
      }
    }
  }
 
  void
  create_pi_program_with_kernel_name(OSModuleHandle Module,
                                     const std::string &KernelName,
                                     bool JITCompilationIsRequired = false);
 
  void create_cl_program_with_source(const std::string &Source);
 
  void compile(const std::string &Options);
 
  void build(const std::string &Options);
 
  std::vector<RT::PiDevice> get_pi_devices() const;
 
  static bool is_cacheable_with_options(const std::string &Options) {
    return Options.empty();
  }
 
  bool has_cl_kernel(const std::string &KernelName) const;
 
  RT::PiKernel get_pi_kernel(const std::string &KernelName) const;
 
  std::vector<device> sort_devices_by_cl_device_id(std::vector<device> Devices);
 
  void throw_if_state_is(program_state State) const;
 
  void throw_if_state_is_not(program_state State) const;
 
  RT::PiProgram MProgram = nullptr;
  program_state MState = program_state::none;
  std::mutex MMutex;
  ContextImplPtr MContext;
  bool MLinkable = false;
  std::vector<device> MDevices;
  property_list MPropList;
  std::string MCompileOptions;
  std::string MLinkOptions;
  std::string MBuildOptions;
  OSModuleHandle MProgramModuleHandle = OSUtil::ExeModuleHandle;
 
  // Keeps specialization constant map for this program. Spec constant name
  // resolution to actual SPIR-V integer ID happens at build time, where the
  // device binary image is available. Access is guarded by this context's
  // program cache lock.
  SpecConstRegistryT SpecConstRegistry;
 
  bool MProgramAndKernelCachingAllowed = false;
 
  bool MIsInterop = false;
};
 
template <>
cl_uint program_impl::get_info<info::program::reference_count>() const;
 
template <> context program_impl::get_info<info::program::context>() const;
 
template <>
std::vector<device> program_impl::get_info<info::program::devices>() const;
 
} // namespace detail
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)