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/device_info.hpp>
#include <detail/platform_impl.hpp>
#include <sycl/aspects.hpp>
#include <sycl/detail/cl.h>
#include <sycl/detail/pi.hpp>
#include <sycl/kernel_bundle.hpp>
#include <sycl/stl.hpp>
 
#include <memory>
#include <mutex>
#include <utility>
 
namespace sycl {
__SYCL_INLINE_VER_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 plugin &Plugin);
 
  explicit device_impl(RT::PiDevice Device, PlatformImplPtr Platform);
 
  explicit device_impl(RT::PiDevice Device, const plugin &Plugin);
 
  ~device_impl();
 
  cl_device_id get() const;
 
  RT::PiDevice &getHandleRef() {
    if (MIsHostDevice)
      throw invalid_object_error("This instance of device is a host instance",
                                 PI_ERROR_INVALID_DEVICE);
 
    return MDevice;
  }
 
  const RT::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));
  }
 
  RT::PiDeviceType get_device_type() const { return MType; }
 
  platform get_platform() const;
 
  const plugin &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 {
    if (is_host()) {
      return get_device_info_host<Param>();
    }
    return get_device_info<Param>(this->getHandleRef(), this->getPlugin());
  }
 
  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;
 
  uint64_t getCurrentDeviceTime();
 
private:
  explicit device_impl(pi_native_handle InteropDevice, RT::PiDevice Device,
                       PlatformImplPtr Platform, const plugin &Plugin);
  RT::PiDevice MDevice = 0;
  RT::PiDeviceType MType;
  RT::PiDevice MRootDevice = nullptr;
  bool MIsHostDevice;
  PlatformImplPtr MPlatform;
  bool MIsAssertFailSupported = false;
  mutable std::string MDeviceName;
  mutable std::once_flag MDeviceNameFlag;
  std::pair<uint64_t, uint64_t> MDeviceHostBaseTime;
}; // class device_impl
 
} // namespace detail
} // __SYCL_INLINE_VER_NAMESPACE(_V1)
} // namespace sycl