[SYCL] Defer buffer release when no host memory to be updated (#6837)

SYCL2020 4.7.2.3. Buffer synchronization rules states that "A buffer can
be constructed from a range (and without a hostData pointer). The memory
management for this type of buffer is entirely handled by the SYCL
system. The destructor for this type of buffer does not need to block,
even if work on the buffer has not completed. Instead, the SYCL system
frees any storage required for the buffer asynchronously when it is no
longer in use in queues."
This commit implements this behavior for sycl::buffer.

This feature introduced more resources to be released in the end of
program if there was no chance to release them earlier. This commit
implements WA of known issues with global object destruction based on
thread_local usage, thread_local variables destroy earlier than global
variables that allow us to do release resources earlier.

Signed-off-by: Tikhomirova, Kseniya <[email protected]>

Author: KseniyaTikhomirova

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();