kernel_impl.hpp

Go to the documentation of this file.

//==------- kernel_impl.hpp --- SYCL kernel 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/detail/common.hpp>
#include <CL/sycl/detail/pi.h>
#include <CL/sycl/detail/pi.hpp>
#include <CL/sycl/device.hpp>
#include <CL/sycl/info/info_desc.hpp>
#include <CL/sycl/program.hpp>
#include <detail/context_impl.hpp>
#include <detail/device_impl.hpp>
#include <detail/kernel_info.hpp>
 
#include <cassert>
#include <memory>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
namespace detail {
// Forward declaration
class program_impl;
class kernel_bundle_impl;
 
using ContextImplPtr = std::shared_ptr<context_impl>;
using ProgramImplPtr = std::shared_ptr<program_impl>;
using KernelBundleImplPtr = std::shared_ptr<kernel_bundle_impl>;
class kernel_impl {
public:
  kernel_impl(RT::PiKernel Kernel, ContextImplPtr Context,
              KernelBundleImplPtr KernelBundleImpl);
 
  kernel_impl(RT::PiKernel Kernel, ContextImplPtr ContextImpl,
              ProgramImplPtr ProgramImpl, bool IsCreatedFromSource,
              KernelBundleImplPtr KernelBundleImpl);
 
  kernel_impl(RT::PiKernel Kernel, ContextImplPtr ContextImpl,
              DeviceImageImplPtr DeviceImageImpl,
              KernelBundleImplPtr KernelBundleImpl);
 
  kernel_impl(ContextImplPtr Context, ProgramImplPtr ProgramImpl);
 
  // This section means the object is non-movable and non-copyable
  // There is no need of move and copy constructors in kernel_impl.
  // If they need to be added, piKernelRetain method for MKernel
  // should be present.
  kernel_impl(const kernel_impl &) = delete;
  kernel_impl(kernel_impl &&) = delete;
  kernel_impl &operator=(const kernel_impl &) = delete;
  kernel_impl &operator=(kernel_impl &&) = delete;
 
  ~kernel_impl();
 
  cl_kernel get() const {
    if (is_host()) {
      throw invalid_object_error(
          "This instance of kernel doesn't support OpenCL interoperability.",
          PI_INVALID_KERNEL);
    }
    getPlugin().call<PiApiKind::piKernelRetain>(MKernel);
    return pi::cast<cl_kernel>(MKernel);
  }
 
  bool is_host() const { return MContext->is_host(); }
 
  const plugin &getPlugin() const { return MContext->getPlugin(); }
 
  template <info::kernel param>
  typename info::param_traits<info::kernel, param>::return_type
  get_info() const;
 
  template <info::kernel_device_specific param>
  typename info::param_traits<info::kernel_device_specific, param>::return_type
  get_info(const device &Device) const;
 
  template <info::kernel_device_specific param>
  typename info::param_traits<info::kernel_device_specific, param>::return_type
  get_info(const device &Device,
           typename info::param_traits<info::kernel_device_specific,
                                       param>::input_type Value) const;
 
  template <info::kernel_work_group param>
  typename info::param_traits<info::kernel_work_group, param>::return_type
  get_work_group_info(const device &Device) const;
 
  template <info::kernel_sub_group param>
  typename info::param_traits<info::kernel_sub_group, param>::return_type
  get_sub_group_info(const device &Device) const;
 
  template <info::kernel_sub_group param>
  typename info::param_traits<info::kernel_sub_group, param>::return_type
  get_sub_group_info(
      const device &Device,
      typename info::param_traits<info::kernel_sub_group, param>::input_type
          Value) const;
 
  RT::PiKernel &getHandleRef() { return MKernel; }
  const RT::PiKernel &getHandleRef() const { return MKernel; }
 
  bool isCreatedFromSource() const;
 
  const DeviceImageImplPtr &getDeviceImage() const { return MDeviceImageImpl; }
 
  pi_native_handle getNative() const {
    const plugin &Plugin = MContext->getPlugin();
 
    if (Plugin.getBackend() == backend::opencl)
      Plugin.call<PiApiKind::piKernelRetain>(MKernel);
 
    pi_native_handle NativeKernel = 0;
    Plugin.call<PiApiKind::piextKernelGetNativeHandle>(MKernel, &NativeKernel);
 
    return NativeKernel;
  }
 
  KernelBundleImplPtr get_kernel_bundle() const { return MKernelBundleImpl; }
 
  bool isInterop() const { return MIsInterop; }
 
private:
  RT::PiKernel MKernel;
  const ContextImplPtr MContext;
  const ProgramImplPtr MProgramImpl;
  bool MCreatedFromSource = true;
  const DeviceImageImplPtr MDeviceImageImpl;
  const KernelBundleImplPtr MKernelBundleImpl;
  bool MIsInterop = false;
};
 
template <info::kernel param>
inline typename info::param_traits<info::kernel, param>::return_type
kernel_impl::get_info() const {
  if (is_host()) {
    // TODO implement
    assert(0 && "Not implemented");
  }
  return get_kernel_info<
      typename info::param_traits<info::kernel, param>::return_type,
      param>::get(this->getHandleRef(), getPlugin());
}
 
template <>
inline context kernel_impl::get_info<info::kernel::context>() const {
  return createSyclObjFromImpl<context>(MContext);
}
 
#ifdef __SYCL_INTERNAL_API
template <>
inline program kernel_impl::get_info<info::kernel::program>() const {
  return createSyclObjFromImpl<program>(MProgramImpl);
}
#endif
 
template <info::kernel_device_specific param>
inline typename info::param_traits<info::kernel_device_specific,
                                   param>::return_type
kernel_impl::get_info(const device &Device) const {
  if (is_host()) {
    return get_kernel_device_specific_info_host<param>(Device);
  }
  return get_kernel_device_specific_info<
      typename info::param_traits<info::kernel_device_specific,
                                  param>::return_type,
      param>::get(this->getHandleRef(), getSyclObjImpl(Device)->getHandleRef(),
                  getPlugin());
}
 
template <info::kernel_device_specific param>
inline typename info::param_traits<info::kernel_device_specific,
                                   param>::return_type
kernel_impl::get_info(
    const device &Device,
    typename info::param_traits<info::kernel_device_specific, param>::input_type
        Value) const {
  if (is_host()) {
    throw runtime_error("Sub-group feature is not supported on HOST device.",
                        PI_INVALID_DEVICE);
  }
  return get_kernel_device_specific_info_with_input<param>::get(
      this->getHandleRef(), getSyclObjImpl(Device)->getHandleRef(), Value,
      getPlugin());
}
 
template <info::kernel_work_group param>
inline typename info::param_traits<info::kernel_work_group, param>::return_type
kernel_impl::get_work_group_info(const device &Device) const {
  return get_info<
      info::compatibility_param_traits<info::kernel_work_group, param>::value>(
      Device);
}
 
template <info::kernel_sub_group param>
inline typename info::param_traits<info::kernel_sub_group, param>::return_type
kernel_impl::get_sub_group_info(const device &Device) const {
  return get_info<
      info::compatibility_param_traits<info::kernel_sub_group, param>::value>(
      Device);
}
 
template <info::kernel_sub_group param>
inline typename info::param_traits<info::kernel_sub_group, param>::return_type
kernel_impl::get_sub_group_info(
    const device &Device,
    typename info::param_traits<info::kernel_sub_group, param>::input_type
        Value) const {
  return get_info<
      info::compatibility_param_traits<info::kernel_sub_group, param>::value>(
      Device, Value);
}
 
} // namespace detail
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)