[SYCL] Added missing wait(), wait_and_throw(), get_wait_list() methods to event class

Signed-off-by: Klochkov, Vyacheslav N <[email protected]>
Signed-off-by: Vladimir Lazarev <[email protected]>

Author: v-klochkov

sycl/include/CL/sycl/detail/event_impl.hpp

@@ -33,6 +33,8 @@ class event_impl {
   // Self is needed in order to pass shared_ptr to Scheduler.
   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);
+
   template <info::event_profiling param>
   typename info::param_traits<info::event_profiling, param>::return_type
   get_profiling_info() const;

sycl/include/CL/sycl/detail/scheduler/scheduler.h

@@ -22,6 +22,7 @@
 #include <iostream>
 #include <map>
 #include <set>
+#include <unordered_set>
 #include <vector>
 
 namespace cl {
@@ -157,6 +158,10 @@ class Scheduler {
   // Waits for the event passed.
   void waitForEvent(EventImplPtr Event);
 
+  // Calls asynchronous handler for the passed event Event
+  // and for those other events that Event depends on.
+  void throwForEventRecursive(EventImplPtr Event);
+
   // Adds new node to graph, creating an Alloca and MemMove commands if
   // needed.
   cl::sycl::event addNode(Node NewNode);
@@ -195,6 +200,12 @@ class Scheduler {
   enum DumpOptions { Text = 0, WholeGraph = 1, RunGraph = 2 };
   bool getDumpFlagValue(DumpOptions DumpOption);
 
+  // Recursively walks through the dependencies and initializes
+  // the given EventsSet with the events that the Event
+  // waits for. The unordered_set is used to collect unuque events,
+  // and the unordered_set is convenient as it does not need operator<().
+  void getDepEventsRecursive(std::unordered_set<cl::sycl::event> &EventsSet,
+                             EventImplPtr Event);
 protected:
   // TODO: Add releasing of OpenCL buffers.
 
@@ -208,7 +219,6 @@ class Scheduler {
   // Recursively generates dot records for the command passed and all that the
   // command depends on.
   void printGraphForCommand(CommandPtr Cmd, std::ostream &Stream) const;
-
 private:
   Scheduler();
   ~Scheduler();
@@ -223,6 +233,15 @@ class Scheduler {
 
   Scheduler(Scheduler const &) = delete;
   Scheduler &operator=(Scheduler const &) = delete;
+
+  // Returns the pointer to the command associated with the given event,
+  // or nullptr if none is found.
+  CommandPtr getCmdForEvent(EventImplPtr Event);
+
+  // Basically it is the helper method for throwForEventRecursive() now.
+  // It calls async handler for the command Cmd and those other
+  // commands that Cmd depends on.
+  void throwForCmdRecursive(std::shared_ptr<Command> Cmd);
 };
 
 } // namespace simple_scheduler

sycl/include/CL/sycl/event.hpp

@@ -41,15 +41,15 @@ class event {
 
   bool is_host() const;
 
-  void wait() const;
+  vector_class<event> get_wait_list();
 
-  // vector_class<event> get_wait_list();
+  void wait();
 
-  // static void wait(const vector_class<event> &eventList);
+  static void wait(const vector_class<event> &EventList);
 
-  // void wait_and_throw();
+  void wait_and_throw();
 
-  // static void wait_and_throw(const vector_class<event> &eventList);
+  static void wait_and_throw(const vector_class<event> &EventList);
 
   template <info::event param>
   typename info::param_traits<info::event, param>::return_type get_info() const;

sycl/source/detail/event_impl.cpp

@@ -72,6 +72,14 @@ void event_impl::wait(
     simple_scheduler::Scheduler::getInstance().waitForEvent(Self);
 }
 
+
+void event_impl::wait_and_throw(
+    std::shared_ptr<cl::sycl::detail::event_impl> Self) {
+  wait(Self);
+  cl::sycl::simple_scheduler::Scheduler::getInstance().throwForEventRecursive(
+    Self);
+}
+
 template <>
 cl_ulong
 event_impl::get_profiling_info<info::event_profiling::command_submit>() const {

sycl/source/detail/scheduler/scheduler.cpp

@@ -17,6 +17,7 @@
 #include <cassert>
 #include <fstream>
 #include <set>
+#include <unordered_set>
 #include <vector>
 
 namespace cl {
@@ -40,16 +41,31 @@ void Node::addInteropArg(shared_ptr_class<void> Ptr, size_t Size,
   m_InteropArgs.emplace_back(Ptr, Size, ArgIndex, BufReq);
 }
 
-// Waits for the event passed.
-void Scheduler::waitForEvent(EventImplPtr Event) {
+CommandPtr Scheduler::getCmdForEvent(EventImplPtr Event) {
+  // TODO: Currently, this method searches for the command in
+  // m_BuffersEvolution, which seems expensive, especially
+  // taking into account that this operation may be called
+  // from another loop. Need to optimize this method, for example,
+  // by adding a direct link from 'event' to the 'command' it
+  // is associated with.
   for (auto &BufEvolution : m_BuffersEvolution) {
     for (auto &Cmd : BufEvolution.second) {
       if (detail::getSyclObjImpl(Cmd->getEvent()) == Event) {
-        enqueueAndWaitForCommand(Cmd);
-        return;
+        return Cmd;
       }
     }
   }
+  return nullptr;
+}
+
+// Waits for the event passed.
+void Scheduler::waitForEvent(EventImplPtr Event) {
+  auto Cmd = getCmdForEvent(Event);
+  if (Cmd) {
+    enqueueAndWaitForCommand(Cmd);
+    return;
+  }
+
   for (auto &Evnt : m_EventsWithoutRequirements) {
     if (Evnt == Event) {
       Evnt->waitInternal();
@@ -58,6 +74,51 @@ void Scheduler::waitForEvent(EventImplPtr Event) {
   }
 }
 
+// Calls async handler for the given command Cmd and those other
+// commands that Cmd depends on.
+void Scheduler::throwForCmdRecursive(std::shared_ptr<Command> Cmd) {
+  if (Cmd == nullptr) {
+    return;
+  }
+
+  auto QImpl = Cmd->getQueue();
+  QImpl->throw_asynchronous();
+
+  std::vector<std::pair<std::shared_ptr<Command>, BufferReqPtr>> Deps =
+    Cmd->getDependencies();
+  for (auto D : Deps) {
+    throwForCmdRecursive(D.first);
+  }
+}
+
+// Calls async handler for the given event Event and those other
+// events that Event depends on.
+void Scheduler::throwForEventRecursive(EventImplPtr Event) {
+  auto Cmd = getCmdForEvent(Event);
+  if (Cmd) {
+    throwForCmdRecursive(Cmd);
+  }
+}
+
+void Scheduler::getDepEventsRecursive(
+    std::unordered_set<cl::sycl::event> &EventsSet,
+    EventImplPtr Event) {
+  auto Cmd = getCmdForEvent(Event);
+  if (Cmd == nullptr) {
+    return;
+  }
+
+  std::vector<std::pair<std::shared_ptr<Command>, BufferReqPtr>> Deps =
+    Cmd->getDependencies();
+  for (auto D : Deps) {
+    auto DepEvent = D.first->getEvent();
+    EventsSet.insert(DepEvent);
+
+    auto DepEventImpl = cl::sycl::detail::getSyclObjImpl(DepEvent);
+    getDepEventsRecursive(EventsSet, DepEventImpl);
+  }
+}
+
 void Scheduler::print(std::ostream &Stream) const {
   Stream << "======================================" << std::endl;
   Stream << "Graph dump" << std::endl;

sycl/source/event.cpp

@@ -11,9 +11,12 @@
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/event_impl.hpp>
 #include <CL/sycl/event.hpp>
+#include <CL/sycl/detail/scheduler/scheduler.h>
+
 #include <CL/sycl/stl.hpp>
 
 #include <memory>
+#include <unordered_set>
 
 namespace cl {
 namespace sycl {
@@ -31,7 +34,30 @@ cl_event event::get() { return impl->get(); }
 
 bool event::is_host() const { return impl->is_host(); }
 
-void event::wait() const { impl->wait(impl); }
+void event::wait() { impl->wait(impl); }
+
+void event::wait(const vector_class<event> &EventList) {
+  for (auto E : EventList) {
+    E.wait();
+  }
+}
+
+void event::wait_and_throw() { impl->wait_and_throw(impl); }
+
+void event::wait_and_throw(const vector_class<event> &EventList) {
+  for (auto E : EventList) {
+    E.wait_and_throw();
+  }
+}
+
+vector_class<event> event::get_wait_list() {
+  std::unordered_set<event> DepEventsSet;
+  cl::sycl::simple_scheduler::Scheduler::getInstance().getDepEventsRecursive(
+    DepEventsSet, impl);
+
+  vector_class<event> DepEventsVec(DepEventsSet.begin(), DepEventsSet.end());
+  return DepEventsVec;
+}
 
 event::event(std::shared_ptr<detail::event_impl> event_impl)
     : impl(event_impl) {}