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 <detail/plugin.hpp>
#include <sycl/detail/cl.h>
#include <sycl/detail/common.hpp>
#include <sycl/detail/host_profiling_info.hpp>
#include <sycl/detail/pi.hpp>
#include <sycl/info/info_desc.hpp>
#include <sycl/stl.hpp>
 
#include <atomic>
#include <cassert>
#include <condition_variable>
#include <optional>
 
namespace sycl {
__SYCL_INLINE_VER_NAMESPACE(_V1) {
class context;
namespace detail {
class plugin;
class context_impl;
using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
class queue_impl;
using QueueImplPtr = std::shared_ptr<sycl::detail::queue_impl>;
class event_impl;
using EventImplPtr = std::shared_ptr<sycl::detail::event_impl>;
 
class event_impl {
public:
  enum HostEventState : int {
    HES_NotComplete = 0,
    HES_Complete,
    HES_Discarded
  };
 
  event_impl(std::optional<HostEventState> State = HES_Complete)
      : MIsInitialized(false), MHostEvent(State), MIsFlushed(true),
        MState(State.value_or(HES_Complete)) {}
 
  event_impl(RT::PiEvent Event, const context &SyclContext);
  event_impl(const QueueImplPtr &Queue);
 
  //
  bool is_host();
 
  void wait(std::shared_ptr<sycl::detail::event_impl> Self);
 
  void wait_and_throw(std::shared_ptr<sycl::detail::event_impl> Self);
 
  void cleanupCommand(std::shared_ptr<sycl::detail::event_impl> Self) const;
 
  template <typename Param> typename Param::return_type get_profiling_info();
 
  template <typename Param> typename Param::return_type get_info();
 
  ~event_impl();
 
  void waitInternal();
 
  void setComplete();
 
  RT::PiEvent &getHandleRef();
  const RT::PiEvent &getHandleRef() const;
 
  const ContextImplPtr &getContextImpl();
 
  const plugin &getPlugin();
 
  void setContextImpl(const ContextImplPtr &Context);
 
  void setStateIncomplete();
 
  void *getCommand() { return MCommand; }
 
  void setCommand(void *Command) { MCommand = Command; }
 
  HostProfilingInfo *getHostProfilingInfo() { return MHostProfilingInfo.get(); }
 
  pi_native_handle getNative();
 
  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; }
 
  QueueImplPtr getWorkerQueue() { return MWorkerQueue.lock(); };
 
  void setWorkerQueue(const QueueImplPtr &WorkerQueue) {
    MWorkerQueue = WorkerQueue;
  };
 
  void setSubmittedQueue(const QueueImplPtr &SubmittedQueue) {
    MSubmittedQueue = SubmittedQueue;
  };
 
  QueueImplPtr getSubmittedQueue() const { return MSubmittedQueue.lock(); };
 
  bool isInitialized() const noexcept { return MIsInitialized; }
 
  void attachEventToComplete(const EventImplPtr &Event) {
    std::lock_guard<std::mutex> Lock(MMutex);
    MPostCompleteEvents.push_back(Event);
  }
 
protected:
  // 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;
  // Events constructed without a context will lazily use the default context
  // when needed.
  void ensureContextInitialized();
  bool MIsInitialized = true;
  bool MIsContextInitialized = false;
  RT::PiEvent MEvent = nullptr;
  ContextImplPtr MContext;
  bool MHostEvent = true;
  std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
  void *MCommand = nullptr;
  std::weak_ptr<queue_impl> MQueue;
  const bool MIsProfilingEnabled = false;
 
  std::weak_ptr<queue_impl> MWorkerQueue;
  std::weak_ptr<queue_impl> MSubmittedQueue;
 
  std::vector<EventImplPtr> MPreparedDepsEvents;
  std::vector<EventImplPtr> MPreparedHostDepsEvents;
 
  std::vector<EventImplPtr> MPostCompleteEvents;
 
  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;
  std::condition_variable cv;
 
  friend std::vector<RT::PiEvent>
  getOrWaitEvents(std::vector<sycl::event> DepEvents,
                  std::shared_ptr<sycl::detail::context_impl> Context);
};
 
} // namespace detail
} // __SYCL_INLINE_VER_NAMESPACE(_V1)
} // namespace sycl