platform.hpp

Go to the documentation of this file.

//==---------------- platform.hpp - SYCL platform --------------------------==//
//
// 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/aspects.hpp>
#include <CL/sycl/context.hpp>
#include <CL/sycl/detail/common.hpp>
#include <CL/sycl/detail/export.hpp>
#include <CL/sycl/stl.hpp>
 
// 4.6.2 Platform class
#include <utility>
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
// TODO: make code thread-safe
 
// Forward declaration
class device_selector;
class device;
namespace detail {
class platform_impl;
}
 
class __SYCL_EXPORT platform {
public:
  platform();
 
#ifdef __SYCL_INTERNAL_API
  explicit platform(cl_platform_id PlatformId);
#endif
 
  explicit platform(const device_selector &DeviceSelector);
 
  platform(const platform &rhs) = default;
 
  platform(platform &&rhs) = default;
 
  platform &operator=(const platform &rhs) = default;
 
  platform &operator=(platform &&rhs) = default;
 
  bool operator==(const platform &rhs) const { return impl == rhs.impl; }
 
  bool operator!=(const platform &rhs) const { return !(*this == rhs); }
 
#ifdef __SYCL_INTERNAL_API
  cl_platform_id get() const;
#endif
 
  __SYCL2020_DEPRECATED(
      "use platform::has() function with aspects APIs instead")
  bool has_extension(const std::string &ExtensionName) const;
 
  bool is_host() const;
 
  std::vector<device>
  get_devices(info::device_type DeviceType = info::device_type::all) const;
 
  template <info::platform param>
  typename info::param_traits<info::platform, param>::return_type
  get_info() const;
 
  static std::vector<platform> get_platforms();
 
  backend get_backend() const noexcept;
 
  template <backend BackendName>
  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
  auto get_native() const -> typename interop<BackendName, platform>::type {
    return reinterpret_cast<typename interop<BackendName, platform>::type>(
        getNative());
  }
 
  bool has(aspect Aspect) const;
 
  context ext_oneapi_get_default_context() const;
 
private:
  pi_native_handle getNative() const;
 
  std::shared_ptr<detail::platform_impl> impl;
  platform(std::shared_ptr<detail::platform_impl> impl) : impl(impl) {}
 
  template <class T>
  friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
  template <class Obj>
  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
}; // class platform
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)
 
namespace std {
template <> struct hash<cl::sycl::platform> {
  size_t operator()(const cl::sycl::platform &p) const {
    return hash<std::shared_ptr<cl::sycl::detail::platform_impl>>()(
        cl::sycl::detail::getSyclObjImpl(p));
  }
};
} // namespace std