device_impl.hpp

Go to the documentation of this file.

//==----------------- device_impl.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 <detail/platform_impl.hpp>
#include <sycl/aspects.hpp>
#include <sycl/detail/cl.h>
#include <sycl/detail/pi.hpp>
#include <sycl/ext/oneapi/experimental/device_architecture.hpp>
#include <sycl/kernel_bundle.hpp>
 
#include <memory>
#include <mutex>
#include <utility>
 
namespace sycl {
inline namespace _V1 {
 
// Forward declaration
class platform;
 
namespace detail {
 
// Forward declaration
class platform_impl;
using PlatformImplPtr = std::shared_ptr<platform_impl>;
 
// TODO: Make code thread-safe
class device_impl {
public:
  device_impl();
 
  explicit device_impl(pi_native_handle, const PluginPtr &Plugin);
 
  explicit device_impl(sycl::detail::pi::PiDevice Device,
                       PlatformImplPtr Platform);
 
  explicit device_impl(sycl::detail::pi::PiDevice Device,
                       const PluginPtr &Plugin);
 
  ~device_impl();
 
  cl_device_id get() const;
 
  sycl::detail::pi::PiDevice &getHandleRef() {
    if (MIsHostDevice)
      throw invalid_object_error("This instance of device is a host instance",
                                 PI_ERROR_INVALID_DEVICE);
 
    return MDevice;
  }
 
  const sycl::detail::pi::PiDevice &getHandleRef() const {
    if (MIsHostDevice)
      throw invalid_object_error("This instance of device is a host instance",
                                 PI_ERROR_INVALID_DEVICE);
 
    return MDevice;
  }
 
  bool is_host() const { return MIsHostDevice; }
 
  bool is_cpu() const { return (!is_host() && (MType == PI_DEVICE_TYPE_CPU)); }
 
  bool is_gpu() const { return (!is_host() && (MType == PI_DEVICE_TYPE_GPU)); }
 
  bool is_accelerator() const {
    return (!is_host() && (MType == PI_DEVICE_TYPE_ACC));
  }
 
  sycl::detail::pi::PiDeviceType get_device_type() const { return MType; }
 
  platform get_platform() const;
 
  const PluginPtr &getPlugin() const { return MPlatform->getPlugin(); }
 
  bool has_extension(const std::string &ExtensionName) const;
 
  std::vector<device>
  create_sub_devices(const cl_device_partition_property *Properties,
                     size_t SubDevicesCount) const;
 
  std::vector<device> create_sub_devices(size_t ComputeUnits) const;
 
  std::vector<device>
  create_sub_devices(const std::vector<size_t> &Counts) const;
 
  std::vector<device>
  create_sub_devices(info::partition_affinity_domain AffinityDomain) const;
 
  std::vector<device> create_sub_devices() const;
 
  bool is_partition_supported(info::partition_property Prop) const;
 
  template <typename Param> typename Param::return_type get_info() const;
 
  template <typename Param>
  typename Param::return_type get_backend_info() const;
 
  bool
  is_affinity_supported(info::partition_affinity_domain AffinityDomain) const;
 
  pi_native_handle getNative() const;
 
  //
  bool has(aspect Aspect) const;
 
  static std::shared_ptr<device_impl> getHostDeviceImpl();
 
  bool isAssertFailSupported() const;
 
  bool isRootDevice() const { return MRootDevice == nullptr; }
 
  std::string getDeviceName() const;
 
  bool
  extOneapiArchitectureIs(ext::oneapi::experimental::architecture Arch) const {
    return Arch == getDeviceArch();
  }
 
  bool extOneapiArchitectureIs(
      ext::oneapi::experimental::arch_category Category) const {
    std::optional<ext::oneapi::experimental::architecture> CategoryMinArch =
        get_category_min_architecture(Category);
    std::optional<ext::oneapi::experimental::architecture> CategoryMaxArch =
        get_category_max_architecture(Category);
    if (CategoryMinArch.has_value() && CategoryMaxArch.has_value())
      return CategoryMinArch <= getDeviceArch() &&
             getDeviceArch() <= CategoryMaxArch;
    return false;
  }
 
  bool extOneapiCanCompile(ext::oneapi::experimental::source_language Language);
 
  uint64_t getCurrentDeviceTime();
 
 
  bool isGetDeviceAndHostTimerSupported();
 
  backend getBackend() const { return MPlatform->getBackend(); }
 
  PlatformImplPtr getPlatformImpl() const { return MPlatform; }
 
  std::string
  get_device_info_string(sycl::detail::pi::PiDeviceInfo InfoCode) const;
 
  ext::oneapi::experimental::architecture getDeviceArch() const;
 
private:
  explicit device_impl(pi_native_handle InteropDevice,
                       sycl::detail::pi::PiDevice Device,
                       PlatformImplPtr Platform, const PluginPtr &Plugin);
  sycl::detail::pi::PiDevice MDevice = 0;
  sycl::detail::pi::PiDeviceType MType;
  sycl::detail::pi::PiDevice MRootDevice = nullptr;
  bool MIsHostDevice;
  PlatformImplPtr MPlatform;
  bool MIsAssertFailSupported = false;
  mutable std::string MDeviceName;
  mutable std::once_flag MDeviceNameFlag;
  mutable ext::oneapi::experimental::architecture MDeviceArch{};
  mutable std::once_flag MDeviceArchFlag;
  std::pair<uint64_t, uint64_t> MDeviceHostBaseTime{0, 0};
}; // class device_impl
 
} // namespace detail
} // namespace _V1
} // namespace sycl