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 <atomic>
#include <cassert>
#include <condition_variable>
#include <optional>
 
namespace sycl {
inline namespace _V1 {
namespace ext::oneapi::experimental::detail {
class graph_impl;
}
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)) {
    // Need to fail in event() constructor  if there are problems with the
    // ONEAPI_DEVICE_SELECTOR. Deferring may lead to conficts with noexcept
    // event methods. This ::get() call uses static vars to read and parse the
    // ODS env var exactly once.
    SYCLConfig<ONEAPI_DEVICE_SELECTOR>::get();
  }
 
  event_impl(sycl::detail::pi::PiEvent Event, const context &SyclContext);
  event_impl(const QueueImplPtr &Queue);
 
  //
  bool is_host();
 
  void wait(std::shared_ptr<sycl::detail::event_impl> Self,
            bool *Success = nullptr);
 
  void wait_and_throw(std::shared_ptr<sycl::detail::event_impl> Self);
 
  template <typename Param> typename Param::return_type get_profiling_info();
 
  template <typename Param> typename Param::return_type get_info();
 
  template <typename Param>
  typename Param::return_type get_backend_info() const;
 
  ~event_impl();
 
  void waitInternal(bool *Success = nullptr);
 
  void setComplete();
 
  sycl::detail::pi::PiEvent &getHandleRef();
  const sycl::detail::pi::PiEvent &getHandleRef() const;
 
  const ContextImplPtr &getContextImpl();
 
  const PluginPtr &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; }
 
  QueueImplPtr getWorkerQueue() { return MWorkerQueue.lock(); };
 
  void setWorkerQueue(const QueueImplPtr &WorkerQueue) {
    MWorkerQueue = WorkerQueue;
  };
 
  void setSubmittedQueue(const QueueImplPtr &SubmittedQueue) {
    MSubmittedQueue = SubmittedQueue;
  };
 
  void associateWithQueue(const QueueImplPtr &Queue);
 
  bool isNOP() { return !MCommand && !getHandleRef(); }
 
  void setSubmissionTime();
 
  void setHostEnqueueTime();
 
  uint64_t getSubmissionTime();
 
  QueueImplPtr getSubmittedQueue() const { return MSubmittedQueue.lock(); };
 
  bool isInitialized() const noexcept { return MIsInitialized; }
 
  bool isCompleted();
 
  void attachEventToComplete(const EventImplPtr &Event) {
    std::lock_guard<std::mutex> Lock(MMutex);
    MPostCompleteEvents.push_back(Event);
  }
 
  bool isContextInitialized() const noexcept { return MIsContextInitialized; }
 
  ContextImplPtr getContextImplPtr() {
    ensureContextInitialized();
    return MContext;
  }
 
  // Sets a sync point which is used when this event represents an enqueue to a
  // Command Buffer.
  void setSyncPoint(sycl::detail::pi::PiExtSyncPoint SyncPoint) {
    MSyncPoint = SyncPoint;
  }
 
  // Get the sync point associated with this event.
  sycl::detail::pi::PiExtSyncPoint getSyncPoint() const { return MSyncPoint; }
 
  void setCommandGraph(
      std::shared_ptr<ext::oneapi::experimental::detail::graph_impl> Graph) {
    MGraph = Graph;
  }
 
  std::shared_ptr<ext::oneapi::experimental::detail::graph_impl>
  getCommandGraph() const {
    return MGraph.lock();
  }
 
  void setEventFromSubmittedExecCommandBuffer(bool value) {
    MEventFromSubmittedExecCommandBuffer = value;
  }
 
  bool isEventFromSubmittedExecCommandBuffer() const {
    return MEventFromSubmittedExecCommandBuffer;
  }
 
  // Sets a command-buffer command when this event represents an enqueue to a
  // Command Buffer.
  void
  setCommandBufferCommand(sycl::detail::pi::PiExtCommandBufferCommand Command) {
    MCommandBufferCommand = Command;
  }
 
  sycl::detail::pi::PiExtCommandBufferCommand getCommandBufferCommand() const {
    return MCommandBufferCommand;
  }
 
  const std::vector<EventImplPtr> &getPostCompleteEvents() const {
    return MPostCompleteEvents;
  }
 
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;
  sycl::detail::pi::PiEvent MEvent = nullptr;
  // Stores submission time of command associated with event
  uint64_t MSubmitTime = 0;
  uint64_t MHostBaseTime = 0;
  ContextImplPtr MContext;
  bool MHostEvent = true;
  std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
  void *MCommand = nullptr;
  std::weak_ptr<queue_impl> MQueue;
  bool MIsProfilingEnabled = false;
  bool MFallbackProfiling = 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;
 
  std::mutex MMutex;
  std::condition_variable cv;
 
  std::weak_ptr<ext::oneapi::experimental::detail::graph_impl> MGraph;
  bool MEventFromSubmittedExecCommandBuffer = false;
 
  // If this event represents a submission to a
  // sycl::detail::pi::PiExtCommandBuffer the sync point for that submission is
  // stored here.
  sycl::detail::pi::PiExtSyncPoint MSyncPoint;
 
  // If this event represents a submission to a
  // sycl::detail::pi::PiExtCommandBuffer the command-buffer command
  // (if any) associated with that submission is stored here.
  sycl::detail::pi::PiExtCommandBufferCommand MCommandBufferCommand = nullptr;
 
  friend std::vector<sycl::detail::pi::PiEvent>
  getOrWaitEvents(std::vector<sycl::event> DepEvents,
                  std::shared_ptr<sycl::detail::context_impl> Context);
};
 
} // namespace detail
} // namespace _V1
} // namespace sycl