device.hpp

Go to the documentation of this file.

//==------------------- device.hpp - SYCL device ---------------------------==//
//
// 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/aspects.hpp>
#include <sycl/backend_types.hpp>
#include <sycl/detail/defines_elementary.hpp>
#include <sycl/detail/export.hpp>
#include <sycl/detail/info_desc_helpers.hpp>
#include <sycl/detail/owner_less_base.hpp>
#include <sycl/detail/pi.h>
#include <sycl/detail/string.hpp>
#include <sycl/detail/string_view.hpp>
#include <sycl/detail/util.hpp>
#include <sycl/device_selector.hpp>
#include <sycl/ext/oneapi/experimental/device_architecture.hpp>
#include <sycl/info/info_desc.hpp>
#include <sycl/kernel_bundle_enums.hpp>
#include <sycl/platform.hpp>
 
#include <cstddef>
#include <memory>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <variant>
#include <vector>
 
namespace sycl {
inline namespace _V1 {
// Forward declarations
class device_selector;
template <backend BackendName, class SyclObjectT>
auto get_native(const SyclObjectT &Obj)
    -> backend_return_t<BackendName, SyclObjectT>;
namespace detail {
class device_impl;
auto getDeviceComparisonLambda();
} // namespace detail
 
enum class aspect;
 
namespace ext::oneapi {
// Forward declaration
class filter_selector;
 
enum class peer_access {
  access_supported = 0x0,
  atomics_supported = 0x1,
};
 
} // namespace ext::oneapi
 
class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
public:
  device();
 
#ifdef __SYCL_INTERNAL_API
  explicit device(cl_device_id DeviceId);
#endif
 
  __SYCL2020_DEPRECATED("SYCL 1.2.1 device selectors are deprecated. Please "
                        "use SYCL 2020 device selectors instead.")
  explicit device(const device_selector &DeviceSelector);
 
  template <typename DeviceSelector,
            typename =
                detail::EnableIfSYCL2020DeviceSelectorInvocable<DeviceSelector>>
  explicit device(const DeviceSelector &deviceSelector)
      : device(detail::select_device(deviceSelector)) {}
 
  bool operator==(const device &rhs) const { return impl == rhs.impl; }
 
  bool operator!=(const device &rhs) const { return !(*this == rhs); }
 
  device(const device &rhs) = default;
 
  device(device &&rhs) = default;
 
  device &operator=(const device &rhs) = default;
 
  device &operator=(device &&rhs) = default;
 
  void ext_oneapi_enable_peer_access(const device &peer);
  void ext_oneapi_disable_peer_access(const device &peer);
  bool
  ext_oneapi_can_access_peer(const device &peer,
                             ext::oneapi::peer_access value =
                                 ext::oneapi::peer_access::access_supported);
 
#ifdef __SYCL_INTERNAL_API
  cl_device_id get() const;
#endif
 
  __SYCL2020_DEPRECATED(
      "is_host() is deprecated as the host device is no longer supported.")
  bool is_host() const;
 
  bool is_cpu() const;
 
  bool is_gpu() const;
 
  bool is_accelerator() const;
 
  platform get_platform() const;
 
  template <info::partition_property prop>
  std::vector<device> create_sub_devices(size_t ComputeUnits) const;
 
  template <info::partition_property prop>
  std::vector<device>
  create_sub_devices(const std::vector<size_t> &Counts) const;
 
  template <info::partition_property prop>
  std::vector<device>
  create_sub_devices(info::partition_affinity_domain AffinityDomain) const;
 
  template <info::partition_property prop>
  std::vector<device> create_sub_devices() const;
 
  template <typename Param>
  typename detail::is_device_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;
 
  __SYCL2020_DEPRECATED("use device::has() function with aspects APIs instead")
  bool has_extension(const std::string &extension_name) const;
 
  static std::vector<device>
  get_devices(info::device_type deviceType = info::device_type::all);
 
  backend get_backend() const noexcept;
 
// Clang may warn about the use of diagnose_if in __SYCL_WARN_IMAGE_ASPECT, so
// we disable that warning as we make appropriate checks to ensure its
// existence.
// TODO: Remove this diagnostics when __SYCL_WARN_IMAGE_ASPECT is removed.
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgcc-compat"
#endif // defined(__clang__)
 
  bool has(aspect Aspect) const __SYCL_WARN_IMAGE_ASPECT(Aspect);
 
  bool ext_oneapi_architecture_is(ext::oneapi::experimental::architecture arch);
 
  bool
  ext_oneapi_architecture_is(ext::oneapi::experimental::arch_category category);
 
 
  bool
  ext_oneapi_can_compile(ext::oneapi::experimental::source_language Language);
 
  bool ext_oneapi_supports_cl_c_feature(const std::string &Feature);
 
  bool ext_oneapi_supports_cl_c_version(
      const ext::oneapi::experimental::cl_version &Version) const;
 
  bool ext_oneapi_supports_cl_extension(
      const std::string &name,
      ext::oneapi::experimental::cl_version *version = nullptr) const;
 
  std::string ext_oneapi_cl_profile() const;
 
// TODO: Remove this diagnostics when __SYCL_WARN_IMAGE_ASPECT is removed.
#if defined(__clang__)
#pragma clang diagnostic pop
#endif // defined(__clang__)
 
private:
  std::shared_ptr<detail::device_impl> impl;
  device(std::shared_ptr<detail::device_impl> impl) : impl(impl) {}
 
  pi_native_handle getNative() const;
 
  template <class Obj>
  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
  template <class T>
  friend typename std::add_pointer_t<typename decltype(T::impl)::element_type>
  detail::getRawSyclObjImpl(const T &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_device_info_desc<Param>::return_type>
  get_info_impl() const;
};
 
} // namespace _V1
} // namespace sycl
 
namespace std {
template <> struct hash<sycl::device> {
  size_t operator()(const sycl::device &Device) const {
    return hash<std::shared_ptr<sycl::detail::device_impl>>()(
        sycl::detail::getSyclObjImpl(Device));
  }
};
} // namespace std