[SYCL] Defer buffer release when no host memory to be updated

sycl/include/sycl/buffer.hpp

@@ -125,6 +125,8 @@ class __SYCL_EXPORT buffer_plain {
 
   size_t getSize() const;
 
+  void handleRelease() const;
+
   std::shared_ptr<detail::buffer_impl> impl;
 };
 
@@ -466,7 +468,7 @@ class buffer : public detail::buffer_plain,
 
   buffer &operator=(buffer &&rhs) = default;
 
-  ~buffer() = default;
+  ~buffer() { buffer_plain::handleRelease(); }
 
   bool operator==(const buffer &rhs) const { return impl == rhs.impl; }
 

sycl/plugins/esimd_emulator/pi_esimd_emulator.cpp

@@ -1381,8 +1381,40 @@ pi_result piKernelRelease(pi_kernel) { DIE_NO_IMPLEMENTATION; }
 
 pi_result piEventCreate(pi_context, pi_event *) { DIE_NO_IMPLEMENTATION; }
 
-pi_result piEventGetInfo(pi_event, pi_event_info, size_t, void *, size_t *) {
-  DIE_NO_IMPLEMENTATION;
+pi_result piEventGetInfo(pi_event Event, pi_event_info ParamName,
+                         size_t ParamValueSize, void *ParamValue,
+                         size_t *ParamValueSizeRet) {
+  if (ParamName != PI_EVENT_INFO_COMMAND_EXECUTION_STATUS) {
+    DIE_NO_IMPLEMENTATION;
+  }
+
+  auto CheckAndFillStatus = [&](const cm_support::CM_STATUS &State) {
+    pi_int32 Result = PI_EVENT_RUNNING;
+    if (State == cm_support::CM_STATUS_FINISHED)
+      Result = PI_EVENT_COMPLETE;
+    if (ParamValue) {
+      if (ParamValueSize < sizeof(Result))
+        return PI_ERROR_INVALID_VALUE;
+      *static_cast<pi_int32 *>(ParamValue) = Result;
+    }
+    if (ParamValueSizeRet) {
+      *ParamValueSizeRet = sizeof(Result);
+    }
+    return PI_SUCCESS;
+  };
+  // Dummy event is already completed ones done by CM.
+  if (Event->IsDummyEvent)
+    return CheckAndFillStatus(cm_support::CM_STATUS_FINISHED);
+
+  if (Event->CmEventPtr == nullptr)
+    return PI_ERROR_INVALID_EVENT;
+
+  cm_support::CM_STATUS Status;
+  int32_t Result = Event->CmEventPtr->GetStatus(Status);
+  if (Result != cm_support::CM_SUCCESS)
+    return PI_ERROR_COMMAND_EXECUTION_FAILURE;
+
+  return CheckAndFillStatus(Status);
 }
 
 pi_result piEventGetProfilingInfo(pi_event Event, pi_profiling_info ParamName,

sycl/source/buffer.cpp

@@ -121,6 +121,13 @@ void buffer_plain::addOrReplaceAccessorProperties(
 
 size_t buffer_plain::getSize() const { return impl->getSizeInBytes(); }
 
+void buffer_plain::handleRelease() const {
+  // Try to detach memory object only if impl is going to be released.
+  // Buffer copy will have pointer to the same impl.
+  if (impl.use_count() == 1)
+    impl->detachMemoryObject(impl);
+}
+
 } // namespace detail
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/source/detail/event_impl.cpp

@@ -80,17 +80,19 @@ void event_impl::waitInternal() {
 
 void event_impl::setComplete() {
   if (MHostEvent || !MEvent) {
-    std::unique_lock<std::mutex> lock(MMutex);
+    {
+      std::unique_lock<std::mutex> lock(MMutex);
 #ifndef NDEBUG
-    int Expected = HES_NotComplete;
-    int Desired = HES_Complete;
+      int Expected = HES_NotComplete;
+      int Desired = HES_Complete;
 
-    bool Succeeded = MState.compare_exchange_strong(Expected, Desired);
+      bool Succeeded = MState.compare_exchange_strong(Expected, Desired);
 
-    assert(Succeeded && "Unexpected state of event");
+      assert(Succeeded && "Unexpected state of event");
 #else
-    MState.store(static_cast<int>(HES_Complete));
+      MState.store(static_cast<int>(HES_Complete));
 #endif
+    }
     cv.notify_all();
     return;
   }
@@ -144,8 +146,8 @@ event_impl::event_impl(RT::PiEvent Event, const context &SyclContext)
 }
 
 event_impl::event_impl(const QueueImplPtr &Queue)
-    : MQueue{Queue}, MIsProfilingEnabled{Queue->is_host() ||
-                                         Queue->MIsProfilingEnabled} {
+    : MQueue{Queue},
+      MIsProfilingEnabled{Queue->is_host() || Queue->MIsProfilingEnabled} {
   this->setContextImpl(Queue->getContextImplPtr());
 
   if (Queue->is_host()) {
@@ -429,6 +431,11 @@ void event_impl::cleanDepEventsThroughOneLevel() {
   }
 }
 
+bool event_impl::isCompleted() {
+  return get_info<info::event::command_execution_status>() ==
+         info::event_command_status::complete;
+}
+
 } // namespace detail
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl

sycl/source/detail/event_impl.hpp

@@ -243,6 +243,8 @@ class event_impl {
   /// state.
   bool isInitialized() const noexcept { return MIsInitialized; }
 
+  bool isCompleted();
+
   void attachEventToComplete(const EventImplPtr &Event) {
     std::lock_guard<std::mutex> Lock(MMutex);
     MPostCompleteEvents.push_back(Event);

sycl/source/detail/global_handler.cpp

@@ -27,6 +27,36 @@
 namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
 namespace detail {
+
+// Utility class to track references on object.
+// Used for Scheduler now and created as thread_local object.
+// Origin idea is to track usage of Scheduler from main and other used threads -
+// they increment MCounter; and to use but not add extra reference by our
+// thread_pool threads. For this control MIncrementCounter class member is used.
+template <class ResourceHandler> class ObjectUsageCounter {
+public:
+  ObjectUsageCounter(std::unique_ptr<ResourceHandler> &Obj, bool ModifyCounter)
+      : MModifyCounter(ModifyCounter), MObj(Obj) {
+    if (MModifyCounter)
+      MCounter++;
+  }
+  ~ObjectUsageCounter() {
+    if (!MModifyCounter)
+      return;
+
+    MCounter--;
+    if (!MCounter && MObj)
+      MObj->releaseResources();
+  }
+
+private:
+  static std::atomic_uint MCounter;
+  bool MModifyCounter;
+  std::unique_ptr<ResourceHandler> &MObj;
+};
+template <class ResourceHandler>
+std::atomic_uint ObjectUsageCounter<ResourceHandler>::MCounter{0};
+
 using LockGuard = std::lock_guard<SpinLock>;
 
 GlobalHandler::GlobalHandler() = default;
@@ -47,7 +77,24 @@ T &GlobalHandler::getOrCreate(InstWithLock<T> &IWL, Types... Args) {
   return *IWL.Inst;
 }
 
-Scheduler &GlobalHandler::getScheduler() { return getOrCreate(MScheduler); }
+void GlobalHandler::attachScheduler(Scheduler *Scheduler) {
+  // The method is used in unit tests only. Do not protect with lock since
+  // releaseResources will cause dead lock due to host queue release
+  if (MScheduler.Inst)
+    MScheduler.Inst->releaseResources();
+  MScheduler.Inst.reset(Scheduler);
+}
+
+Scheduler &GlobalHandler::getScheduler() {
+  getOrCreate(MScheduler);
+  registerSchedulerUsage();
+  return *MScheduler.Inst;
+}
+
+void GlobalHandler::registerSchedulerUsage(bool ModifyCounter) {
+  thread_local ObjectUsageCounter SchedulerCounter(MScheduler.Inst,
+                                                   ModifyCounter);
+}
 
 ProgramManager &GlobalHandler::getProgramManager() {
   return getOrCreate(MProgramManager);
@@ -141,9 +188,18 @@ void GlobalHandler::unloadPlugins() {
   GlobalHandler::instance().getPlugins().clear();
 }
 
+void GlobalHandler::drainThreadPool() {
+  if (MHostTaskThreadPool.Inst)
+    MHostTaskThreadPool.Inst->drain();
+}
+
 void shutdown() {
   // Ensure neither host task is working so that no default context is accessed
   // upon its release
+
+  if (GlobalHandler::instance().MScheduler.Inst)
+    GlobalHandler::instance().MScheduler.Inst->releaseResources();
+
   if (GlobalHandler::instance().MHostTaskThreadPool.Inst)
     GlobalHandler::instance().MHostTaskThreadPool.Inst->finishAndWait();
 

sycl/source/detail/global_handler.hpp

@@ -54,6 +54,7 @@ class GlobalHandler {
   GlobalHandler(const GlobalHandler &) = delete;
   GlobalHandler(GlobalHandler &&) = delete;
 
+  void registerSchedulerUsage(bool ModifyCounter = true);
   Scheduler &getScheduler();
   ProgramManager &getProgramManager();
   Sync &getSync();
@@ -74,6 +75,10 @@ class GlobalHandler {
   static void registerDefaultContextReleaseHandler();
 
   void unloadPlugins();
+  void drainThreadPool();
+
+  // For testing purposes only
+  void attachScheduler(Scheduler *Scheduler);
 
 private:
   friend void releaseDefaultContexts();