context.hpp

Go to the documentation of this file.

//==---------------- context.hpp - SYCL context ----------------------------==//
//
// 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/detail/backend_traits.hpp>
#include <sycl/detail/cl.h>
#include <sycl/detail/common.hpp>
#include <sycl/detail/export.hpp>
#include <sycl/detail/info_desc_helpers.hpp>
#include <sycl/detail/owner_less_base.hpp>
#include <sycl/detail/stl_type_traits.hpp>
#include <sycl/exception_list.hpp>
#include <sycl/ext/oneapi/weak_object_base.hpp>
#include <sycl/info/info_desc.hpp>
#include <sycl/property_list.hpp>
#include <sycl/stl.hpp>
 
// 4.6.2 Context class
 
namespace sycl {
__SYCL_INLINE_VER_NAMESPACE(_V1) {
// Forward declarations
class device;
class platform;
namespace detail {
class context_impl;
}
template <backend Backend, class SyclT>
auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
class __SYCL_EXPORT context : public detail::OwnerLessBase<context> {
public:
  explicit context(const property_list &PropList = {});
 
  explicit context(const async_handler &AsyncHandler,
                   const property_list &PropList = {});
 
  explicit context(const device &Device, const property_list &PropList = {});
 
  explicit context(const device &Device, async_handler AsyncHandler,
                   const property_list &PropList = {});
 
  explicit context(const platform &Platform,
                   const property_list &PropList = {});
 
  explicit context(const platform &Platform, async_handler AsyncHandler,
                   const property_list &PropList = {});
 
  explicit context(const std::vector<device> &DeviceList,
                   const property_list &PropList = {});
 
  explicit context(const std::vector<device> &DeviceList,
                   async_handler AsyncHandler,
                   const property_list &PropList = {});
 
#ifdef __SYCL_INTERNAL_API
  context(cl_context ClContext, async_handler AsyncHandler = {});
#endif
 
  template <typename Param>
  typename detail::is_context_info_desc<Param>::return_type get_info() const;
 
  context(const context &rhs) = default;
 
  context(context &&rhs) = default;
 
  context &operator=(const context &rhs) = default;
 
  context &operator=(context &&rhs) = default;
 
  bool operator==(const context &rhs) const { return impl == rhs.impl; }
 
  bool operator!=(const context &rhs) const { return !(*this == rhs); }
 
  template <typename propertyT> bool has_property() const noexcept;
 
  template <typename propertyT> propertyT get_property() const;
 
#ifdef __SYCL_INTERNAL_API
  cl_context get() const;
#endif
 
  __SYCL2020_DEPRECATED(
      "is_host() is deprecated as the host device is no longer supported.")
  bool is_host() const;
 
  backend get_backend() const noexcept;
 
  platform get_platform() const;
 
  std::vector<device> get_devices() const;
 
private:
  context(std::shared_ptr<detail::context_impl> Impl);
 
  pi_native_handle getNative() const;
 
  std::shared_ptr<detail::context_impl> impl;
 
  template <backend Backend, class SyclT>
  friend auto get_native(const SyclT &Obj) -> backend_return_t<Backend, SyclT>;
 
  template <class Obj>
  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
  template <class T>
  friend
      typename detail::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);
};
 
} // __SYCL_INLINE_VER_NAMESPACE(_V1)
} // namespace sycl
 
namespace std {
template <> struct hash<sycl::context> {
  size_t operator()(const sycl::context &Context) const {
    return hash<std::shared_ptr<sycl::detail::context_impl>>()(
        sycl::detail::getSyclObjImpl(Context));
  }
};
} // namespace std