[SYCL] Host task implementation

sycl/CMakeLists.txt

@@ -11,7 +11,7 @@ option(SYCL_ADD_DEV_VERSION_POSTFIX "Adds -V postfix to version string" ON)
 set(SYCL_MAJOR_VERSION 1)
 set(SYCL_MINOR_VERSION 0)
 set(SYCL_PATCH_VERSION 0)
-set(SYCL_DEV_ABI_VERSION 2)
+set(SYCL_DEV_ABI_VERSION 1)
 if (SYCL_ADD_DEV_VERSION_POSTFIX)
   set(SYCL_VERSION_POSTFIX "-${SYCL_DEV_ABI_VERSION}")
 endif()

sycl/include/CL/sycl/detail/cg.hpp

@@ -219,6 +219,7 @@ class HostTask {
   std::function<void()> MHostTask;
 
 public:
+  HostTask() : MHostTask([]() {}) {}
   HostTask(std::function<void()> &&Func) : MHostTask(Func) {}
 
   void call() { MHostTask(); }
@@ -400,8 +401,8 @@ class CG {
     COPY_USM,
     FILL_USM,
     PREFETCH_USM,
-    INTEROP_TASK_CODEPLAY,
-    HOST_TASK_CODEPLAY
+    CODEPLAY_INTEROP_TASK,
+    CODEPLAY_HOST_TASK
   };
 
   CG(CGTYPE Type, vector_class<vector_class<char>> ArgsStorage,

sycl/include/CL/sycl/handler.hpp

@@ -832,7 +832,7 @@ class __SYCL_EXPORT handler {
 
     MHostTask.reset(new detail::HostTask(std::move(Func)));
 
-    MCGType = detail::CG::HOST_TASK_CODEPLAY;
+    MCGType = detail::CG::CODEPLAY_HOST_TASK;
   }
 
   /// Defines and invokes a SYCL kernel function for the specified range and
@@ -1161,7 +1161,7 @@ class __SYCL_EXPORT handler {
   template <typename FuncT> void interop_task(FuncT Func) {
 
     MInteropTask.reset(new detail::InteropTask(std::move(Func)));
-    MCGType = detail::CG::INTEROP_TASK_CODEPLAY;
+    MCGType = detail::CG::CODEPLAY_INTEROP_TASK;
   }
 
   /// Defines and invokes a SYCL kernel function for the specified range.

sycl/source/detail/scheduler/commands.cpp

@@ -186,55 +186,44 @@ class DispatchHostTask {
     }
   }
 
-  // Lookup for empty command amongst users of this cmd
-  static EmptyCommand *findUserEmptyCommand(Command *ThisCmd) {
-    assert(ThisCmd->MUsers.size() == 1 &&
-           "Only a single user is expected for host task command");
-
-    Command *User = *ThisCmd->MUsers.begin();
-
-    assert(User->getType() == Command::CommandType::EMPTY_TASK &&
-           "Expected empty command as single user of host task command");
-    assert(User->MIsBlockable && "Empty command is expected to be blockable");
-    assert(User->MBlockReason == Command::BlockReason::HostTask &&
-           "Empty command is expected to be blocked due to host task");
-
-    return static_cast<EmptyCommand *>(User);
-  }
-
 public:
   DispatchHostTask(ExecCGCommand *ThisCmd) : MThisCmd{ThisCmd} {}
 
   void operator()() const {
     waitForEvents();
 
-    assert(MThisCmd->getCG().get());
-    assert(MThisCmd->getCG()->getType() == CG::CGTYPE::HOST_TASK_CODEPLAY);
+    assert(MThisCmd->getCG().getType() == CG::CGTYPE::CODEPLAY_HOST_TASK);
 
-    CGHostTask *HostTask = static_cast<CGHostTask *>(MThisCmd->getCG().get());
+    CGHostTask &HostTask = static_cast<CGHostTask &>(MThisCmd->getCG());
 
     // we're ready to call the user-defined lambda now
-    HostTask->MHostTask->call();
-    HostTask->MHostTask.reset();
+    HostTask.MHostTask->call();
+    HostTask.MHostTask.reset();
 
     // unblock user empty command here
-    EmptyCommand *EmptyCmd = findUserEmptyCommand(MThisCmd);
+    EmptyCommand *EmptyCmd = MThisCmd->MEmptyCmd;
     assert(EmptyCmd && "No empty command found");
 
     // Completing command's event along with unblocking enqueue readiness of
     // empty command may lead to quick deallocation of MThisCmd by some cleanup
     // process. Thus we'll copy deps prior to completing of event and unblocking
     // of empty command.
+    // Also, it's possible to have record deallocated prior to enqueue process.
+    // Thus we employ read-lock of graph.
+    {
+      Scheduler &Sched = Scheduler::getInstance();
+      std::shared_lock<std::shared_timed_mutex> Lock(Sched.MGraphLock);
 
-    std::vector<DepDesc> Deps = MThisCmd->MDeps;
+      std::vector<DepDesc> Deps = MThisCmd->MDeps;
 
-    // update self-event status
-    MThisCmd->MEvent->setComplete();
+      // update self-event status
+      MThisCmd->MEvent->setComplete();
 
-    EmptyCmd->MEnqueueStatus = EnqueueResultT::SyclEnqueueReady;
+      EmptyCmd->MEnqueueStatus = EnqueueResultT::SyclEnqueueReady;
 
-    for (const DepDesc &Dep : Deps)
-      Scheduler::getInstance().enqueueLeavesOfReq(Dep.MDepRequirement);
+      for (const DepDesc &Dep : Deps)
+        Scheduler::enqueueLeavesOfReqUnlocked(Dep.MDepRequirement);
+    }
   }
 };
 
@@ -1396,7 +1385,7 @@ static std::string cgTypeToString(detail::CG::CGTYPE Type) {
   case detail::CG::PREFETCH_USM:
     return "prefetch usm";
     break;
-  case detail::CG::HOST_TASK_CODEPLAY:
+  case detail::CG::CODEPLAY_HOST_TASK:
     return "host task";
     break;
   default:
@@ -1877,7 +1866,7 @@ cl_int ExecCGCommand::enqueueImp() {
 
     return CL_SUCCESS;
   }
-  case CG::CGTYPE::INTEROP_TASK_CODEPLAY: {
+  case CG::CGTYPE::CODEPLAY_INTEROP_TASK: {
     const detail::plugin &Plugin = MQueue->getPlugin();
     CGInteropTask *ExecInterop = (CGInteropTask *)MCommandGroup.get();
     // Wait for dependencies to complete before dispatching work on the host
@@ -1907,7 +1896,7 @@ cl_int ExecCGCommand::enqueueImp() {
 
     return CL_SUCCESS;
   }
-  case CG::CGTYPE::HOST_TASK_CODEPLAY: {
+  case CG::CGTYPE::CODEPLAY_HOST_TASK: {
     CGHostTask *HostTask = static_cast<CGHostTask *>(MCommandGroup.get());
 
     for (ArgDesc &Arg : HostTask->MArgs) {
@@ -1920,7 +1909,7 @@ cl_int ExecCGCommand::enqueueImp() {
         break;
       }
       default:
-        throw std::runtime_error("Yet unsupported arg type");
+        throw runtime_error("Unsupported arg type", PI_INVALID_VALUE);
       }
     }
 

sycl/source/detail/scheduler/commands.hpp

@@ -255,6 +255,12 @@ class Command {
   /// Instance ID tracked for the command.
   uint64_t MInstanceID = 0;
 
+  // This flag allows to control whether host event should be set complete
+  // after successfull enqueue of command. Event is considered as host event if
+  // either it's is_host() return true or there is no backend representation
+  // of event (i.e. getHandleRef() return reference to nullptr value).
+  // By default the flag is set to true due to most of host operations are
+  // synchronous. The only asynchronous operation currently is host-task.
   bool MShouldCompleteEventIfPossible = true;
 };
 
@@ -463,7 +469,13 @@ class ExecCGCommand : public Command {
   void printDot(std::ostream &Stream) const final;
   void emitInstrumentationData();
 
-  const std::unique_ptr<detail::CG> &getCG() const { return MCommandGroup; }
+  detail::CG &getCG() const { return *MCommandGroup; }
+
+  // MEmptyCmd one is only employed if this command refers to host-task.
+  // MEmptyCmd due to unreliable mechanism of lookup for single EmptyCommand
+  // amongst users of host-task-representing command. This unreliability roots
+  // in cleanup process.
+  EmptyCommand *MEmptyCmd = nullptr;
 
 private:
   cl_int enqueueImp() final;

sycl/source/detail/scheduler/graph_builder.cpp

@@ -416,7 +416,8 @@ Command *Scheduler::GraphBuilder::addHostAccessor(Requirement *Req,
   Command *UpdateHostAccCmd = insertUpdateHostReqCmd(Record, Req, HostQueue);
 
   // Need empty command to be blocked until host accessor is destructed
-  EmptyCommand *EmptyCmd = addEmptyCmd(UpdateHostAccCmd, {Req}, HostQueue);
+  EmptyCommand *EmptyCmd = addEmptyCmd(UpdateHostAccCmd, {Req}, HostQueue,
+                                       Command::BlockReason::HostAccessor);
 
   Req->MBlockedCmd = EmptyCmd;
 
@@ -639,10 +640,9 @@ void Scheduler::GraphBuilder::markModifiedIfWrite(MemObjRecord *Record,
   }
 }
 
-EmptyCommand *
-Scheduler::GraphBuilder::addEmptyCmd(Command *Cmd,
-                                     const std::vector<Requirement *> &Reqs,
-                                     const QueueImplPtr &Queue) {
+EmptyCommand *Scheduler::GraphBuilder::addEmptyCmd(
+    Command *Cmd, const std::vector<Requirement *> &Reqs,
+    const QueueImplPtr &Queue, Command::BlockReason Reason) {
   EmptyCommand *EmptyCmd =
       new EmptyCommand(Scheduler::getInstance().getDefaultHostQueue());
 
@@ -651,7 +651,7 @@ Scheduler::GraphBuilder::addEmptyCmd(Command *Cmd,
 
   EmptyCmd->MIsBlockable = true;
   EmptyCmd->MEnqueueStatus = EnqueueResultT::SyclEnqueueBlocked;
-  EmptyCmd->MBlockReason = Command::BlockReason::HostTask;
+  EmptyCmd->MBlockReason = Reason;
 
   for (Requirement *Req : Reqs) {
     MemObjRecord *Record = getOrInsertMemObjRecord(Queue, Req);
@@ -734,8 +734,9 @@ Scheduler::GraphBuilder::addCG(std::unique_ptr<detail::CG> CommandGroup,
     NewCmd->addDep(e);
   }
 
-  if (CGType == CG::CGTYPE::HOST_TASK_CODEPLAY)
-    addEmptyCmd(NewCmd.get(), NewCmd->getCG()->MRequirements, Queue);
+  if (CGType == CG::CGTYPE::CODEPLAY_HOST_TASK)
+    NewCmd->MEmptyCmd = addEmptyCmd(NewCmd.get(), NewCmd->getCG().MRequirements,
+                                    Queue, Command::BlockReason::HostTask);
 
   if (MPrintOptionsArray[AfterAddCG])
     printGraphAsDot("after_addCG");
@@ -899,11 +900,11 @@ void Scheduler::GraphBuilder::removeRecordForMemObj(SYCLMemObjI *MemObject) {
 // Make Cmd depend on DepEvent from different context. Connection is performed
 // via distinct ConnectCmd with host task command group on host queue. Cmd will
 // depend on ConnectCmd's host event.
-// DepEvent may not have an associated with it command in at least two cases:
+// DepEvent may not have a command associated with it in at least two cases:
 //  - the command was deleted upon cleanup process;
 //  - DepEvent is user event.
-// In both these cases the only thing we can do is to make ConnectCmd depend on
-// DepEvent.
+// In both of these cases the only thing we can do is to make ConnectCmd depend
+// on DepEvent.
 // Otherwise, when there is a command associated with DepEvent, we make
 // ConnectCmd depend on on this command. If there is valid, i.e. non-nil,
 // requirement in Dep we make ConnectCmd depend on DepEvent's command with this
@@ -920,14 +921,12 @@ void Scheduler::GraphBuilder::connectDepEvent(Command *const Cmd,
   ExecCGCommand *ConnectCmd = nullptr;
 
   {
-    std::function<void(void)> Func = []() {};
-
-    std::unique_ptr<detail::HostTask> HT(new detail::HostTask(std::move(Func)));
+    std::unique_ptr<detail::HostTask> HT(new detail::HostTask);
     std::unique_ptr<detail::CG> ConnectCG(new detail::CGHostTask(
         std::move(HT), /* Args = */ {}, /* ArgsStorage = */ {},
         /* AccStorage = */ {}, /* SharedPtrStorage = */ {},
         /* Requirements = */ {}, /* DepEvents = */ {DepEvent},
-        CG::HOST_TASK_CODEPLAY, /* Payload */ {}));
+        CG::CODEPLAY_HOST_TASK, /* Payload */ {}));
     ConnectCmd = new ExecCGCommand(
         std::move(ConnectCG), Scheduler::getInstance().getDefaultHostQueue());
   }
@@ -938,25 +937,71 @@ void Scheduler::GraphBuilder::connectDepEvent(Command *const Cmd,
   if (Command *DepCmd = reinterpret_cast<Command *>(DepEvent->getCommand()))
     DepCmd->addUser(ConnectCmd);
 
-  ConnectCmd->addDep(DepEvent);
-
   EmptyCommand *EmptyCmd = nullptr;
 
   if (Dep.MDepRequirement) {
-    const auto &Reqs = std::vector<Requirement *>(
-        1, const_cast<Requirement *>(Dep.MDepRequirement));
+    Requirement *Req = const_cast<Requirement *>(Dep.MDepRequirement);
+
+    // make ConnectCmd depend on requirement
+    {
+      MemObjRecord *Record = getMemObjRecord(Req->MSYCLMemObj);
+      Dep.MDepCommand->addUser(ConnectCmd);
+
+      AllocaCommandBase *AllocaCmd =
+          findAllocaForReq(Record, Req, DepEventContext);
+      assert(AllocaCmd && "There must be alloca for requirement!");
+
+      std::set<Command *> Deps = findDepsForReq(Record, Req, DepEventContext);
+      assert(Deps.size() && "There must be some deps");
+
+      for (Command *ReqDepCmd : Deps) {
+        // we don't want to depend on any host task as the only "entry point" to
+        // host task is its empty cmd which is in Deps anyway
+        if (ReqDepCmd->getType() == Command::CommandType::RUN_CG) {
+          auto *Cmd = static_cast<ExecCGCommand *>(ReqDepCmd);
+          if (Cmd->getCG().getType() == CG::CGTYPE::CODEPLAY_HOST_TASK)
+            continue;
+        }
+
+        ConnectCmd->addDep(DepDesc{ReqDepCmd, Req, AllocaCmd});
+        ReqDepCmd->addUser(ConnectCmd);
+      }
+
+      updateLeaves(Deps, Record, Req->MAccessMode);
+      addNodeToLeaves(Record, ConnectCmd, Req->MAccessMode);
+    }
+
+    const auto &Reqs = std::vector<Requirement *>(1, Req);
     EmptyCmd = addEmptyCmd(ConnectCmd, Reqs,
-                           Scheduler::getInstance().getDefaultHostQueue());
+                           Scheduler::getInstance().getDefaultHostQueue(),
+                           Command::BlockReason::HostTask);
     // Dependencies for EmptyCmd are set in addEmptyCmd for provided Reqs.
+
+    // Depend Cmd on empty command
+    {
+      DepDesc CmdDep = Dep;
+      CmdDep.MDepCommand = EmptyCmd;
+
+      Cmd->addDep(CmdDep);
+    }
   } else {
     EmptyCmd = addEmptyCmd(ConnectCmd, {},
-                           Scheduler::getInstance().getDefaultHostQueue());
+                           Scheduler::getInstance().getDefaultHostQueue(),
+                           Command::BlockReason::HostTask);
 
     // There is no requirement thus, empty command will only depend on
     // ConnectCmd via its event.
     EmptyCmd->addDep(ConnectCmd->getEvent());
+    ConnectCmd->addDep(DepEvent);
+
+    // Depend Cmd on empty command
+    Cmd->addDep(EmptyCmd->getEvent());
   }
 
+  EmptyCmd->addUser(Cmd);
+
+  ConnectCmd->MEmptyCmd = EmptyCmd;
+
   // FIXME graph builder shouldn't really enqueue commands. We're in the middle
   // of enqueue process for some command Cmd. We're going to add a dependency
   // for it. Need some nice and cute solution to enqueue ConnectCmd via standard
@@ -966,8 +1011,6 @@ void Scheduler::GraphBuilder::connectDepEvent(Command *const Cmd,
   if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
     throw runtime_error("Failed to enqueue a sync event between two contexts",
                         PI_INVALID_OPERATION);
-
-  Cmd->addDep(ConnectCmd->getEvent());
 }
 
 } // namespace detail

sycl/source/detail/scheduler/scheduler.cpp

@@ -73,12 +73,16 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
       NewCmd = MGraphBuilder.addCGUpdateHost(std::move(CommandGroup),
                                              DefaultHostQueue);
       break;
-    case CG::HOST_TASK_CODEPLAY:
+    case CG::CODEPLAY_HOST_TASK:
       NewCmd = MGraphBuilder.addCG(std::move(CommandGroup), DefaultHostQueue);
       break;
     default:
       NewCmd = MGraphBuilder.addCG(std::move(CommandGroup), std::move(Queue));
     }
+  }
+
+  {
+    std::shared_lock<std::shared_timed_mutex> Lock(MGraphLock);
 
     // TODO: Check if lazy mode.
     EnqueueResultT Res;
@@ -190,11 +194,6 @@ void Scheduler::releaseHostAccessor(Requirement *Req) {
   enqueueLeavesOfReqUnlocked(Req);
 }
 
-void Scheduler::enqueueLeavesOfReq(const Requirement *const Req) {
-  std::shared_lock<std::shared_timed_mutex> Lock(MGraphLock);
-  enqueueLeavesOfReqUnlocked(Req);
-}
-
 // static
 void Scheduler::enqueueLeavesOfReqUnlocked(const Requirement *const Req) {
   MemObjRecord *Record = Req->MSYCLMemObj->MRecord.get();

sycl/source/detail/scheduler/scheduler.hpp

@@ -431,7 +431,6 @@ class Scheduler {
   static Scheduler instance;
 
   static void enqueueLeavesOfReqUnlocked(const Requirement *const Req);
-  void enqueueLeavesOfReq(const Requirement *const Req);
 
   /// Graph builder class.
   ///
@@ -552,7 +551,8 @@ class Scheduler {
 
     EmptyCommand *addEmptyCmd(Command *Cmd,
                               const std::vector<Requirement *> &Req,
-                              const QueueImplPtr &Queue);
+                              const QueueImplPtr &Queue,
+                              Command::BlockReason Reason);
 
   protected:
     /// Finds a command dependency corresponding to the record.