[SYCL] Fix handling of discarded events in preview lib

The queue implementation assumed that handler.finalize()
will return either a valid (non-discarded) event or nullptr
(that's why parseEvent is nop in preview mode).

However, that was not always true. It was possible for
scheduler to only mark an event as discarded after
handler.finalize() completed (during actual command
execution). This resulted in discarded event being
stored in LastEventPtr in the queue and calls to wait()
on that discarded event (which is not allowed) in MT
scenarios.

Fix this, by modyfing addCG() to mark the event as
discarded immediately and to return nullptr is the
event is discarded.

Author: igchor

sycl/source/detail/scheduler/commands.cpp

@@ -1961,7 +1961,7 @@ ExecCGCommand::ExecCGCommand(
     const std::vector<ur_exp_command_buffer_sync_point_t> &Dependencies)
     : Command(CommandType::RUN_CG, std::move(Queue), CommandBuffer,
               Dependencies),
-      MEventNeeded(EventNeeded), MCommandGroup(std::move(CommandGroup)) {
+      MDiscardEvent(!EventNeeded), MCommandGroup(std::move(CommandGroup)) {
   if (MCommandGroup->getType() == detail::CGType::CodeplayHostTask) {
     MEvent->setSubmittedQueue(
         static_cast<detail::CGHostTask *>(MCommandGroup.get())->MQueue);
@@ -3132,22 +3132,17 @@ ur_result_t ExecCGCommand::enqueueImpQueue() {
   auto RawEvents = getUrEvents(EventImpls);
   flushCrossQueueDeps(EventImpls, MWorkerQueue);
 
-  // We can omit creating a UR event and create a "discarded" event if the
-  // command has been explicitly marked as not needing an event, e.g. if the
-  // user did not ask for one, and there are no requirements.
-  bool DiscardUrEvent = MQueue && !MEventNeeded &&
-                        MQueue->supportsDiscardingPiEvents() &&
-                        MCommandGroup->getRequirements().size() == 0;
-
   ur_event_handle_t UREvent = nullptr;
-  ur_event_handle_t *Event = DiscardUrEvent ? nullptr : &UREvent;
-  detail::event_impl *EventImpl = DiscardUrEvent ? nullptr : MEvent.get();
+  ur_event_handle_t *Event = MDiscardEvent ? nullptr : &UREvent;
+  detail::event_impl *EventImpl = MDiscardEvent ? nullptr : MEvent.get();
 
   auto SetEventHandleOrDiscard = [&]() {
-    if (Event)
+    if (MDiscardEvent) {
+      assert(MEvent->isDiscarded());
+    } else {
+      assert(!MEvent->isDiscarded());
       MEvent->setHandle(*Event);
-    else
-      MEvent->setStateDiscarded();
+    }
   };
 
   switch (MCommandGroup->getType()) {

sycl/source/detail/scheduler/commands.hpp

@@ -661,10 +661,10 @@ class ExecCGCommand : public Command {
   // the cleanup process.
   EmptyCommand *MEmptyCmd = nullptr;
 
-  // MEventNeeded is true if the command needs to produce a valid event. The
+  // MDiscardEvent is false if the command needs to produce a valid event. The
   // implementation may elect to not produce events (native or SYCL) if this
-  // is false.
-  bool MEventNeeded = true;
+  // is true.
+  bool MDiscardEvent = false;
 
   bool producesPiEvent() const final;
 

sycl/source/detail/scheduler/scheduler.cpp

@@ -133,14 +133,22 @@ EventImplPtr Scheduler::addCG(
     }
     NewEvent = NewCmd->getEvent();
     NewEvent->setSubmissionTime();
+    if (!EventNeeded) {
+      NewEvent->setStateDiscarded();
+    }
   }
 
   enqueueCommandForCG(NewEvent, AuxiliaryCmds);
 
   if (!AuxiliaryResources.empty())
     registerAuxiliaryResources(NewEvent, std::move(AuxiliaryResources));
 
-  return NewEvent;
+  if (EventNeeded) {
+    return NewEvent;
+  } else {
+    assert(NewEvent->isDiscarded());
+    return nullptr;
+  }
 }
 
 void Scheduler::enqueueCommandForCG(EventImplPtr NewEvent,

sycl/source/handler.cpp

@@ -895,8 +895,12 @@ event handler::finalize() {
 #endif
   }
 
+  bool DiscardEvent = !impl->MEventNeeded && Queue &&
+                      Queue->supportsDiscardingPiEvents() &&
+                      CommandGroup->getRequirements().size() == 0;
+
   detail::EventImplPtr Event = detail::Scheduler::getInstance().addCG(
-      std::move(CommandGroup), Queue->shared_from_this(), impl->MEventNeeded);
+      std::move(CommandGroup), Queue->shared_from_this(), !DiscardEvent);
 
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   MLastEvent = Event;