event.hpp

Go to the documentation of this file.

//==---------------- event.hpp --- SYCL event ------------------------------==//
//
// 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/detail/backend_traits.hpp>
#include <CL/sycl/detail/cl.h>
#include <CL/sycl/detail/common.hpp>
#include <CL/sycl/detail/export.hpp>
#include <CL/sycl/info/info_desc.hpp>
#include <CL/sycl/stl.hpp>
 
#include <memory>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
// Forward declaration
class context;
namespace detail {
class event_impl;
}
 
class __SYCL_EXPORT event {
public:
  event();
 
#ifdef __SYCL_INTERNAL_API
  event(cl_event ClEvent, const context &SyclContext);
#endif
 
  event(const event &rhs) = default;
 
  event(event &&rhs) = default;
 
  event &operator=(const event &rhs) = default;
 
  event &operator=(event &&rhs) = default;
 
  bool operator==(const event &rhs) const;
 
  bool operator!=(const event &rhs) const;
 
#ifdef __SYCL_INTERNAL_API
  cl_event get() const;
#endif
 
  bool is_host() const;
 
  std::vector<event> get_wait_list();
 
  void wait();
 
  static void wait(const std::vector<event> &EventList);
 
  void wait_and_throw();
 
  static void wait_and_throw(const std::vector<event> &EventList);
 
  template <info::event param>
  typename info::param_traits<info::event, param>::return_type get_info() const;
 
  template <info::event_profiling param>
  typename info::param_traits<info::event_profiling, param>::return_type
  get_profiling_info() const;
 
  backend get_backend() const noexcept;
 
  template <backend Backend>
  __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
  backend_return_t<Backend, event> get_native() const {
    return reinterpret_cast<backend_return_t<Backend, event>>(getNative());
  }
 
private:
  event(std::shared_ptr<detail::event_impl> EventImpl);
 
  pi_native_handle getNative() const;
 
  std::vector<pi_native_handle> getNativeVector() const;
 
  std::shared_ptr<detail::event_impl> impl;
 
  template <class Obj>
  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &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>;
};
 
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)
 
namespace std {
template <> struct hash<cl::sycl::event> {
  size_t operator()(const cl::sycl::event &e) const {
    return hash<std::shared_ptr<cl::sycl::detail::event_impl>>()(
        cl::sycl::detail::getSyclObjImpl(e));
  }
};
} // namespace std