event_impl.hpp

Go to the documentation of this file.

//==---------------- event_impl.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/common.hpp>
#include <CL/sycl/detail/host_profiling_info.hpp>
#include <CL/sycl/detail/pi.hpp>
#include <CL/sycl/info/info_desc.hpp>
#include <CL/sycl/stl.hpp>
#include <detail/plugin.hpp>
 
#include <atomic>
#include <cassert>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
class context;
namespace detail {
class plugin;
class context_impl;
using ContextImplPtr = std::shared_ptr<cl::sycl::detail::context_impl>;
class queue_impl;
using QueueImplPtr = std::shared_ptr<cl::sycl::detail::queue_impl>;
class event_impl;
using EventImplPtr = std::shared_ptr<cl::sycl::detail::event_impl>;
 
class event_impl {
public:
  enum HostEventState : int {
    HES_NotComplete = 0,
    HES_Complete,
    HES_Discarded
  };
 
  event_impl(HostEventState State = HES_Complete);
  event_impl(RT::PiEvent Event, const context &SyclContext);
  event_impl(const QueueImplPtr &Queue);
 
  //
  bool is_host() const;
 
  cl_event get() const;
 
  void wait(std::shared_ptr<cl::sycl::detail::event_impl> Self) const;
 
  void wait_and_throw(std::shared_ptr<cl::sycl::detail::event_impl> Self);
 
  void cleanupCommand(std::shared_ptr<cl::sycl::detail::event_impl> Self) const;
 
  template <info::event_profiling param>
  typename info::param_traits<info::event_profiling, param>::return_type
  get_profiling_info() const;
 
  template <info::event param>
  typename info::param_traits<info::event, param>::return_type get_info() const;
 
  ~event_impl();
 
  void waitInternal() const;
 
  void setComplete();
 
  RT::PiEvent &getHandleRef();
  const RT::PiEvent &getHandleRef() const;
 
  const ContextImplPtr &getContextImpl();
 
  const plugin &getPlugin() const;
 
  void setContextImpl(const ContextImplPtr &Context);
 
  void *getCommand() { return MCommand; }
 
  void setCommand(void *Command) { MCommand = Command; }
 
  HostProfilingInfo *getHostProfilingInfo() { return MHostProfilingInfo.get(); }
 
  pi_native_handle getNative() const;
 
  std::vector<std::shared_ptr<event_impl>> &getPreparedDepsEvents() {
    return MPreparedDepsEvents;
  }
 
  std::vector<std::shared_ptr<event_impl>> &getPreparedHostDepsEvents() {
    return MPreparedHostDepsEvents;
  }
 
  std::vector<EventImplPtr> getWaitList();
 
  void flushIfNeeded(const QueueImplPtr &UserQueue);
 
  void cleanupDependencyEvents();
 
  void cleanDepEventsThroughOneLevel();
 
  bool isDiscarded() const { return MState == HES_Discarded; }
 
  void setNeedsCleanupAfterWait(bool NeedsCleanupAfterWait) {
    MNeedsCleanupAfterWait = NeedsCleanupAfterWait;
  }
  bool needsCleanupAfterWait() { return MNeedsCleanupAfterWait; }
 
private:
  // When instrumentation is enabled emits trace event for event wait begin and
  // returns the telemetry event generated for the wait
  void *instrumentationProlog(std::string &Name, int32_t StreamID,
                              uint64_t &instance_id) const;
  // Uses events generated by the Prolog and emits event wait done event
  void instrumentationEpilog(void *TelementryEvent, const std::string &Name,
                             int32_t StreamID, uint64_t IId) const;
  void checkProfilingPreconditions() const;
  mutable bool MIsInitialized = true;
  mutable RT::PiEvent MEvent = nullptr;
  mutable ContextImplPtr MContext;
  mutable bool MOpenCLInterop = false;
  mutable bool MHostEvent = true;
  std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
  void *MCommand = nullptr;
  std::weak_ptr<queue_impl> MQueue;
  const bool MIsProfilingEnabled = false;
 
  std::vector<EventImplPtr> MPreparedDepsEvents;
  std::vector<EventImplPtr> MPreparedHostDepsEvents;
 
  std::atomic<bool> MIsFlushed = false;
 
  // State of host event. Employed only for host events and event with no
  // backend's representation (e.g. alloca). Used values are listed in
  // HostEventState enum.
  std::atomic<int> MState;
 
  // A temporary workaround for the current limitations of post enqueue graph
  // cleanup. Indicates that the command associated with this event isn't
  // handled by post enqueue cleanup yet and has to be deleted by cleanup after
  // wait.
  bool MNeedsCleanupAfterWait = false;
 
  std::mutex MMutex;
};
 
} // namespace detail
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)