kernel.hpp

Go to the documentation of this file.

//==--------------- kernel.hpp --- SYCL kernel -----------------------------==//
//
// 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 <sycl/backend_types.hpp>             // for backend, backend_return_t
#include <sycl/context.hpp>                   // for context
#include <sycl/detail/defines_elementary.hpp> // for __SYCL2020_DEPRECATED
#include <sycl/detail/export.hpp>             // for __SYCL_EXPORT
#include <sycl/detail/info_desc_helpers.hpp>  // for is_kernel_device_specif...
#include <sycl/detail/owner_less_base.hpp>    // for OwnerLessBase
#include <sycl/detail/pi.h>                   // for pi_native_handle
#include <sycl/detail/string.hpp>
#include <sycl/detail/string_view.hpp>
#include <sycl/detail/util.hpp>
#include <sycl/device.hpp>              // for device
#include <sycl/kernel_bundle_enums.hpp> // for bundle_state
#include <sycl/range.hpp>               // for range
 
#include <cstddef> // for size_t
#include <memory>  // for shared_ptr, hash, opera...
#include <variant> // for hash
 
namespace sycl {
inline namespace _V1 {
// Forward declaration
class context;
class queue;
template <backend Backend> class backend_traits;
template <bundle_state State> class kernel_bundle;
template <backend BackendName, class SyclObjectT>
auto get_native(const SyclObjectT &Obj)
    -> backend_return_t<BackendName, SyclObjectT>;
 
namespace detail {
class kernel_impl;
 
class auto_name {};
 
template <typename Name, typename Type> struct get_kernel_name_t {
  using name = Name;
  static_assert(
      !std::is_same_v<Name, auto_name>,
      "No kernel name provided without -fsycl-unnamed-lambda enabled!");
};
 
#ifdef __SYCL_UNNAMED_LAMBDA__
template <typename Type> struct get_kernel_name_t<detail::auto_name, Type> {
  using name = Type;
};
#endif // __SYCL_UNNAMED_LAMBDA__
 
} // namespace detail
 
class __SYCL_EXPORT kernel : public detail::OwnerLessBase<kernel> {
public:
#ifdef __SYCL_INTERNAL_API
  kernel(cl_kernel ClKernel, const context &SyclContext);
#endif
 
  kernel(const kernel &RHS) = default;
 
  kernel(kernel &&RHS) = default;
 
  kernel &operator=(const kernel &RHS) = default;
 
  kernel &operator=(kernel &&RHS) = default;
 
  bool operator==(const kernel &RHS) const { return impl == RHS.impl; }
 
  bool operator!=(const kernel &RHS) const { return !operator==(RHS); }
 
#ifdef __SYCL_INTERNAL_API
  cl_kernel get() const;
#endif
 
  __SYCL2020_DEPRECATED(
      "is_host() is deprecated as the host device is no longer supported.")
  bool is_host() const;
 
  context get_context() const;
 
  backend get_backend() const noexcept;
 
  kernel_bundle<bundle_state::executable> get_kernel_bundle() const;
 
  template <typename Param>
  typename detail::is_kernel_info_desc<Param>::return_type get_info() const {
    return detail::convert_from_abi_neutral(get_info_impl<Param>());
  }
 
  template <typename Param>
  typename detail::is_backend_info_desc<Param>::return_type
  get_backend_info() const;
 
  template <typename Param>
  typename detail::is_kernel_device_specific_info_desc<Param>::return_type
  get_info(const device &Device) const;
 
  template <typename Param>
  __SYCL2020_DEPRECATED("Use the overload without the second parameter")
  typename detail::is_kernel_device_specific_info_desc<Param>::return_type
      get_info(const device &Device, const range<3> &WGSize) const;
 
  // TODO: Revisit and align with sycl_ext_oneapi_forward_progress extension
  // once #7598 is merged.
  template <typename Param>
  typename Param::return_type ext_oneapi_get_info(const queue &q) const;
 
private:
  kernel(std::shared_ptr<detail::kernel_impl> Impl);
 
  pi_native_handle getNative() const;
 
  __SYCL_DEPRECATED("Use getNative() member function")
  pi_native_handle getNativeImpl() const;
 
  std::shared_ptr<detail::kernel_impl> impl;
 
  template <class Obj>
  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
  template <class T>
  friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
  template <backend BackendName, class SyclObjectT>
  friend auto get_native(const SyclObjectT &Obj)
      -> backend_return_t<BackendName, SyclObjectT>;
  template <typename Param>
  typename detail::ABINeutralT_t<
      typename detail::is_kernel_info_desc<Param>::return_type>
  get_info_impl() const;
};
} // namespace _V1
} // namespace sycl
 
namespace std {
template <> struct hash<sycl::kernel> {
  size_t operator()(const sycl::kernel &Kernel) const {
    return hash<std::shared_ptr<sycl::detail::kernel_impl>>()(
        sycl::detail::getSyclObjImpl(Kernel));
  }
};
} // namespace std