Host task user events way forced

sycl/source/detail/device_global_map_entry.cpp

@@ -47,7 +47,9 @@ DeviceGlobalUSMMem &DeviceGlobalMapEntry::getOrAllocateDeviceGlobalUSM(
          "USM allocations should not be acquired for device_global with "
          "device_image_scope property.");
   const std::shared_ptr<context_impl> &CtxImpl = QueueImpl->getContextImplPtr();
-  const device_impl &DevImpl = QueueImpl->getDeviceImpl();
+  // DevImpl is not const since alignedAllocInternal may add mark about shared
+  // USM usage needed for host task handling.
+  device_impl &DevImpl = QueueImpl->getDeviceImpl();
   std::lock_guard<std::mutex> Lock(MDeviceToUSMPtrMapMutex);
 
   auto DGUSMPtr = MDeviceToUSMPtrMap.find({&DevImpl, CtxImpl.get()});

sycl/source/detail/device_impl.hpp

@@ -296,6 +296,9 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
   /// Get device architecture
   ext::oneapi::experimental::architecture getDeviceArch() const;
 
+  void setUSMAllocationPresent() { MSharedUSMAllocationPresent = true; }
+  bool isUSMAllocationPresent() const { return MSharedUSMAllocationPresent; }
+
 private:
   ur_device_handle_t MDevice = 0;
   ur_device_type_t MType;
@@ -307,6 +310,7 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
   mutable ext::oneapi::experimental::architecture MDeviceArch{};
   mutable std::once_flag MDeviceArchFlag;
   std::pair<uint64_t, uint64_t> MDeviceHostBaseTime{0, 0};
+  bool MSharedUSMAllocationPresent{};
 }; // class device_impl
 
 } // namespace detail

sycl/source/detail/event_impl.cpp

@@ -159,6 +159,14 @@ event_impl::event_impl(ur_event_handle_t Event, const context &SyclContext)
   }
 }
 
+void event_impl::allocateHostProfilingInfo() {
+  MHostProfilingInfo.reset(new HostProfilingInfo());
+  if (!MHostProfilingInfo)
+    throw sycl::exception(sycl::make_error_code(sycl::errc::runtime),
+                          "Out of host memory " +
+                              codeToString(UR_RESULT_ERROR_OUT_OF_HOST_MEMORY));
+}
+
 event_impl::event_impl(const QueueImplPtr &Queue)
     : MQueue{Queue}, MIsProfilingEnabled{!Queue || Queue->MIsProfilingEnabled},
       MFallbackProfiling{MIsProfilingEnabled && Queue &&
@@ -167,12 +175,7 @@ event_impl::event_impl(const QueueImplPtr &Queue)
     this->setContextImpl(Queue->getContextImplPtr());
   else {
     MState.store(HES_NotComplete);
-    MHostProfilingInfo.reset(new HostProfilingInfo());
-    if (!MHostProfilingInfo)
-      throw sycl::exception(
-          sycl::make_error_code(sycl::errc::runtime),
-          "Out of host memory " +
-              codeToString(UR_RESULT_ERROR_OUT_OF_HOST_MEMORY));
+    allocateHostProfilingInfo();
     return;
   }
   MState.store(HES_Complete);
@@ -400,7 +403,7 @@ uint64_t event_impl::get_profiling_info<info::event_profiling::command_end>() {
 
 template <> uint32_t event_impl::get_info<info::event::reference_count>() {
   auto Handle = this->getHandle();
-  if (!MIsHostEvent && Handle) {
+  if (Handle) {
     return get_event_info<info::event::reference_count>(Handle,
                                                         this->getAdapter());
   }
@@ -496,18 +499,20 @@ void HostProfilingInfo::start() { StartTime = getTimestamp(); }
 void HostProfilingInfo::end() { EndTime = getTimestamp(); }
 
 ur_native_handle_t event_impl::getNative() {
-  if (isHost())
+  auto Handle = getHandle();
+  if (MIsHostEvent && !Handle)
     return {};
-  initContextIfNeeded();
 
+  initContextIfNeeded();
   auto Adapter = getAdapter();
-  auto Handle = getHandle();
+
   if (MIsDefaultConstructed && !Handle) {
     auto TempContext = MContext.get()->getHandleRef();
     ur_event_native_properties_t NativeProperties{};
     ur_event_handle_t UREvent = nullptr;
     Adapter->call<UrApiKind::urEventCreateWithNativeHandle>(
         0, TempContext, &NativeProperties, &UREvent);
+    Adapter->call<UrApiKind::urEventHostSignal>(UREvent);
     this->setHandle(UREvent);
     Handle = UREvent;
   }
@@ -631,8 +636,14 @@ bool event_impl::isCompleted() {
 void event_impl::setCommand(void *Cmd) {
   MCommand = Cmd;
   auto TypedCommand = static_cast<Command *>(Cmd);
-  if (TypedCommand)
-    MIsHostEvent = TypedCommand->getWorkerContext() == nullptr;
+  if (TypedCommand && TypedCommand->getWorkerContext() == nullptr)
+    markAsHost();
+}
+
+void event_impl::markAsHost() {
+  MIsHostEvent = true;
+  if (!MHostProfilingInfo)
+    allocateHostProfilingInfo();
 }
 
 } // namespace detail

sycl/source/detail/event_impl.hpp

@@ -352,6 +352,8 @@ class event_impl {
     return MEvent && MQueue.expired() && !MIsEnqueued && !MCommand;
   }
 
+  void markAsHost();
+
 protected:
   // When instrumentation is enabled emits trace event for event wait begin and
   // returns the telemetry event generated for the wait
@@ -361,6 +363,7 @@ class event_impl {
   void instrumentationEpilog(void *TelementryEvent, const std::string &Name,
                              int32_t StreamID, uint64_t IId) const;
   void checkProfilingPreconditions() const;
+  void allocateHostProfilingInfo();
 
   std::atomic<ur_event_handle_t> MEvent = nullptr;
   // Stores submission time of command associated with event

sycl/source/detail/queue_impl.cpp

@@ -302,7 +302,7 @@ void queue_impl::addEvent(const event &Event) {
   const EventImplPtr &EImpl = getSyclObjImpl(Event);
   assert(EImpl && "Event implementation is missing");
   auto *Cmd = static_cast<Command *>(EImpl->getCommand());
-  if (Cmd != nullptr && EImpl->getHandle() == nullptr &&
+  if (Cmd != nullptr && (EImpl->getHandle() == nullptr || EImpl->isHost()) &&
       !EImpl->isDiscarded()) {
     std::weak_ptr<event_impl> EventWeakPtr{EImpl};
     std::lock_guard<std::mutex> Lock{MMutex};
@@ -646,7 +646,8 @@ void queue_impl::wait(const detail::code_location &CodeLoc) {
             EventImplWeakPtrIt->lock()) {
       // A nullptr UR event indicates that urQueueFinish will not cover it,
       // either because it's a host task event or an unenqueued one.
-      if (nullptr == EventImplSharedPtr->getHandle()) {
+      if (nullptr == EventImplSharedPtr->getHandle() ||
+          EventImplSharedPtr->isHost()) {
         EventImplSharedPtr->wait(EventImplSharedPtr);
       }
     }

sycl/source/detail/queue_impl.hpp

@@ -275,7 +275,8 @@ class queue_impl {
     ur_native_handle_t nativeHandle = 0;
     getAdapter()->call<UrApiKind::urQueueGetNativeHandle>(MQueue, nullptr,
                                                           &nativeHandle);
-    __SYCL_OCL_CALL(clRetainCommandQueue, ur::cast<cl_command_queue>(nativeHandle));
+    __SYCL_OCL_CALL(clRetainCommandQueue,
+                    ur::cast<cl_command_queue>(nativeHandle));
     return ur::cast<cl_command_queue>(nativeHandle);
   }
 
@@ -682,6 +683,12 @@ class queue_impl {
     return ResEvent;
   }
 
+  bool nativeHostTaskHandling() {
+    return std::getenv("SYCL_ENABLE_USER_EVENTS_PATH") &&
+           !MDevice.isUSMAllocationPresent() &&
+           (MDevice.getBackend() == backend::ext_oneapi_level_zero);
+  }
+
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   // CMPLRLLVM-66082
   // These methods are for accessing a member that should live in the