[NFC][SYCL] Change event_impl::MCommand's type void *->Command * (#19375)

Author: aelovikov-intel

sycl/source/detail/event_impl.cpp

@@ -616,7 +616,7 @@ bool event_impl::isCompleted() {
          info::event_command_status::complete;
 }
 
-void event_impl::setCommand(void *Cmd) { MCommand = Cmd; }
+void event_impl::setCommand(Command *Cmd) { MCommand = Cmd; }
 
 } // namespace detail
 } // namespace _V1

sycl/source/detail/event_impl.hpp

@@ -32,6 +32,7 @@ class context_impl;
 class queue_impl;
 class event_impl;
 using EventImplPtr = std::shared_ptr<sycl::detail::event_impl>;
+class Command;
 
 class event_impl {
   struct private_tag {
@@ -195,14 +196,14 @@ class event_impl {
   /// Scheduler mutex must be locked in read mode when this is called.
   ///
   /// @return a generic pointer to Command object instance.
-  void *getCommand() { return MCommand; }
+  Command *getCommand() { return MCommand; }
 
   /// Associates this event with the command.
   ///
   /// Scheduler mutex must be locked in write mode when this is called.
   ///
   /// @param Command is a generic pointer to Command object instance.
-  void setCommand(void *Command);
+  void setCommand(Command *Cmd);
 
   /// Returns host profiling information.
   ///
@@ -389,7 +390,7 @@ class event_impl {
   uint64_t MSubmitTime = 0;
   std::shared_ptr<context_impl> MContext;
   std::unique_ptr<HostProfilingInfo> MHostProfilingInfo;
-  void *MCommand = nullptr;
+  Command *MCommand = nullptr;
   std::weak_ptr<queue_impl> MQueue;
   bool MIsProfilingEnabled = false;
 

sycl/source/detail/queue_impl.cpp

@@ -294,7 +294,7 @@ sycl::detail::optional<event> queue_impl::getLastEvent() {
 void queue_impl::addEvent(const detail::EventImplPtr &EventImpl) {
   if (!EventImpl)
     return;
-  auto *Cmd = static_cast<Command *>(EventImpl->getCommand());
+  Command *Cmd = EventImpl->getCommand();
   if (Cmd != nullptr && EventImpl->getHandle() == nullptr) {
     std::weak_ptr<event_impl> EventWeakPtr{EventImpl};
     std::lock_guard<std::mutex> Lock{MMutex};

sycl/source/detail/scheduler/commands.cpp

@@ -282,7 +282,7 @@ Command::getUrEventsBlocking(const std::vector<EventImplPtr> &EventImpls,
     // they don't have an associated queue and command.
     if (!EventImpl->isInterop() && !EventImpl->isEnqueued()) {
       if (!EventImpl->getCommand() ||
-          !static_cast<Command *>(EventImpl->getCommand())->producesPiEvent())
+          !EventImpl->getCommand()->producesPiEvent())
         continue;
       std::vector<Command *> AuxCmds;
       Scheduler::getInstance().enqueueCommandForCG(EventImpl, AuxCmds,
@@ -766,7 +766,7 @@ Command *Command::processDepEvent(EventImplPtr DepEvent, const DepDesc &Dep,
   // distinction since the command might still be unenqueued at this point.
   bool PiEventExpected =
       (!DepEvent->isHost() && !DepEvent->isDefaultConstructed());
-  if (auto *DepCmd = static_cast<Command *>(DepEvent->getCommand()))
+  if (auto *DepCmd = DepEvent->getCommand())
     PiEventExpected &= DepCmd->producesPiEvent();
 
   if (!PiEventExpected) {
@@ -835,7 +835,7 @@ Command *Command::addDep(EventImplPtr Event,
 #ifdef XPTI_ENABLE_INSTRUMENTATION
   // We need this for just the instrumentation, so guarding it will prevent
   // unused variable warnings when instrumentation is turned off
-  Command *Cmd = (Command *)Event->getCommand();
+  Command *Cmd = Event->getCommand();
   ur_event_handle_t UrEventAddr = Event->getHandle();
   // Now make an edge for the dependent event
   emitEdgeEventForEventDependence(Cmd, UrEventAddr);

sycl/source/detail/scheduler/graph_builder.cpp

@@ -1246,8 +1246,7 @@ Command *Scheduler::GraphBuilder::connectDepEvent(
     // Dismiss the result here as it's not a connection now,
     // 'cause ConnectCmd is host one
     (void)ConnectCmd->addDep(Dep, ToCleanUp);
-    assert(reinterpret_cast<Command *>(DepEvent->getCommand()) ==
-           Dep.MDepCommand);
+    assert(DepEvent->getCommand() == Dep.MDepCommand);
     // add user to Dep.MDepCommand is already performed beyond this if branch
     {
       DepDesc DepOnConnect = Dep;
@@ -1260,7 +1259,7 @@ Command *Scheduler::GraphBuilder::connectDepEvent(
   } else {
     // It is required condition in another a path and addUser will be set in
     // addDep
-    if (Command *DepCmd = reinterpret_cast<Command *>(DepEvent->getCommand()))
+    if (Command *DepCmd = DepEvent->getCommand())
       DepCmd->addUser(ConnectCmd);
 
     std::ignore = ConnectCmd->addDep(DepEvent, ToCleanUp);
@@ -1343,8 +1342,7 @@ Command *Scheduler::GraphBuilder::addCommandGraphUpdate(
 
   // Register all the events as dependencies
   for (detail::EventImplPtr e : Events) {
-    if (e->getCommand() &&
-        e->getCommand() == static_cast<Command *>(NewCmd.get())) {
+    if (e->getCommand() && e->getCommand() == NewCmd.get()) {
       continue;
     }
     if (Command *ConnCmd = NewCmd->addDep(e, ToCleanUp))

sycl/source/detail/scheduler/graph_processor.cpp

@@ -17,15 +17,11 @@ namespace sycl {
 inline namespace _V1 {
 namespace detail {
 
-static Command *getCommand(const EventImplPtr &Event) {
-  return (Command *)Event->getCommand();
-}
-
 void Scheduler::GraphProcessor::waitForEvent(const EventImplPtr &Event,
                                              ReadLockT &GraphReadLock,
                                              std::vector<Command *> &ToCleanUp,
                                              bool LockTheLock, bool *Success) {
-  Command *Cmd = getCommand(Event);
+  Command *Cmd = Event->getCommand();
   // Command can be nullptr if user creates sycl::event explicitly or the
   // event has been waited on by another thread
   if (!Cmd)
@@ -87,7 +83,7 @@ bool Scheduler::GraphProcessor::enqueueCommand(
   // Recursively enqueue all the implicit + explicit backend level dependencies
   // first and exit immediately if any of the commands cannot be enqueued.
   for (const EventImplPtr &Event : Cmd->getPreparedDepsEvents()) {
-    if (Command *DepCmd = static_cast<Command *>(Event->getCommand()))
+    if (Command *DepCmd = Event->getCommand())
       if (!enqueueCommand(DepCmd, GraphReadLock, EnqueueResult, ToCleanUp,
                           RootCommand, Blocking))
         return false;
@@ -100,7 +96,7 @@ bool Scheduler::GraphProcessor::enqueueCommand(
   // MHostDepsEvents. TO FIX: implement enqueue of blocked commands on host task
   // completion stage and eliminate this event waiting in enqueue.
   for (const EventImplPtr &Event : Cmd->getPreparedHostDepsEvents()) {
-    if (Command *DepCmd = static_cast<Command *>(Event->getCommand()))
+    if (Command *DepCmd = Event->getCommand())
       if (!enqueueCommand(DepCmd, GraphReadLock, EnqueueResult, ToCleanUp,
                           RootCommand, Blocking))
         return false;

sycl/source/detail/scheduler/scheduler.cpp

@@ -159,8 +159,7 @@ void Scheduler::enqueueCommandForCG(EventImplPtr NewEvent,
   {
     ReadLockT Lock = acquireReadLock();
 
-    Command *NewCmd =
-        (NewEvent) ? static_cast<Command *>(NewEvent->getCommand()) : nullptr;
+    Command *NewCmd = (NewEvent) ? NewEvent->getCommand() : nullptr;
 
     EnqueueResultT Res;
     bool Enqueued;
@@ -366,7 +365,7 @@ EventImplPtr Scheduler::addHostAccessor(Requirement *Req) {
                         "Enqueue process failed.");
     }
 
-    if (Command *NewCmd = static_cast<Command *>(NewCmdEvent->getCommand())) {
+    if (Command *NewCmd = NewCmdEvent->getCommand()) {
       Enqueued =
           GraphProcessor::enqueueCommand(NewCmd, Lock, Res, ToCleanUp, NewCmd);
       if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)
@@ -418,7 +417,7 @@ void Scheduler::enqueueUnblockedCommands(
     const std::vector<EventImplPtr> &ToEnqueue, ReadLockT &GraphReadLock,
     std::vector<Command *> &ToCleanUp) {
   for (auto &Event : ToEnqueue) {
-    Command *Cmd = static_cast<Command *>(Event->getCommand());
+    Command *Cmd = Event->getCommand();
     if (!Cmd)
       continue;
     EnqueueResultT Res;
@@ -674,7 +673,7 @@ EventImplPtr Scheduler::addCommandGraphUpdate(
                         "Enqueue process failed.");
     }
 
-    if (Command *NewCmd = static_cast<Command *>(NewCmdEvent->getCommand())) {
+    if (Command *NewCmd = NewCmdEvent->getCommand()) {
       Enqueued =
           GraphProcessor::enqueueCommand(NewCmd, Lock, Res, ToCleanUp, NewCmd);
       if (!Enqueued && EnqueueResultT::SyclEnqueueFailed == Res.MResult)