Refactor patch to avoid code duplication

Signed-off-by: Dmitry Vodopyanov <[email protected]>

Author: dm-vodopyanov

sycl/source/detail/scheduler/scheduler.cpp

@@ -67,13 +67,7 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
   const bool IsKernel = CommandGroup->getType() == CG::KERNEL;
   {
     std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
-#ifdef _WIN32
-    while (!Lock.owns_lock()) {
-      Lock.try_lock();
-    }
-#else
-    Lock.lock();
-#endif // _WIN32
+    lockSharedTimedMutex(Lock);
 
     switch (CommandGroup->getType()) {
     case CG::UPDATE_HOST:
@@ -99,13 +93,7 @@ EventImplPtr Scheduler::addCG(std::unique_ptr<detail::CG> CommandGroup,
 
 EventImplPtr Scheduler::addCopyBack(Requirement *Req) {
   std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
-#ifdef _WIN32
-  while (!Lock.owns_lock()) {
-    Lock.try_lock();
-  }
-#else
-  Lock.lock();
-#endif // _WIN32
+  lockSharedTimedMutex(Lock);
   Command *NewCmd = MGraphBuilder.addCopyBack(Req);
   // Command was not creted because there were no operations with
   // buffer.
@@ -162,13 +150,7 @@ void Scheduler::cleanupFinishedCommands(EventImplPtr FinishedEvent) {
 
 void Scheduler::removeMemoryObject(detail::SYCLMemObjI *MemObj) {
   std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
-#ifdef _WIN32
-  while (!Lock.owns_lock()) {
-    Lock.try_lock();
-  }
-#else
-  Lock.lock();
-#endif // _WIN32
+  lockSharedTimedMutex(Lock);
 
   MemObjRecord *Record = MGraphBuilder.getMemObjRecord(MemObj);
   if (!Record)
@@ -183,19 +165,7 @@ void Scheduler::removeMemoryObject(detail::SYCLMemObjI *MemObj) {
 EventImplPtr Scheduler::addHostAccessor(Requirement *Req,
                                         const bool destructor) {
   std::unique_lock<std::shared_timed_mutex> Lock(MGraphLock, std::defer_lock);
-  // Avoiding deadlock situation for MSVC. std::shared_timed_mutex specification
-  // does not specify a priority for shared and exclusive accesses. It will be a
-  // deadlock in MSVC's std::shared_timed_mutex implementation, if exclusive
-  // access occurs after shared access.
-  // TODO: after switching to C++17, change std::shared_timed_mutex to
-  // std::shared_mutex and use std::lock_guard here both for Windows and Linux.
-#ifdef _WIN32
-  while (!Lock.owns_lock()) {
-    Lock.try_lock();
-  }
-#else
-  Lock.lock();
-#endif // _WIN32
+  lockSharedTimedMutex(Lock);
 
   Command *NewCmd = MGraphBuilder.addHostAccessor(Req, destructor);
 
@@ -231,6 +201,25 @@ Scheduler::Scheduler() {
                      QueueOrder::Ordered, /*PropList=*/{}));
 }
 
+void Scheduler::lockSharedTimedMutex(
+    std::unique_lock<std::shared_timed_mutex> &Lock) {
+#ifdef _WIN32
+  // Avoiding deadlock situation for MSVC. std::shared_timed_mutex specification
+  // does not specify a priority for shared and exclusive accesses. It will be a
+  // deadlock in MSVC's std::shared_timed_mutex implementation, if exclusive
+  // access occurs after shared access.
+  // TODO: after switching to C++17, change std::shared_timed_mutex to
+  // std::shared_mutex and use std::lock_guard here both for Windows and Linux.
+  while (!Lock.owns_lock()) {
+    Lock.try_lock();
+  }
+#else
+  // It is a deadlock on UNIX in implementation of lock and lock_shared, if
+  // try_lock in the loop above will be executed, so using a single lock here
+  Lock.lock();
+#endif // _WIN32
+}
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/scheduler/scheduler.hpp

@@ -428,6 +428,13 @@ class Scheduler {
   Scheduler();
   static Scheduler instance;
 
+  /// Provides exclusive access to std::shared_timed_mutex object with deadlock
+  /// avoidance
+  ///
+  /// \param Lock is an instance of std::unique_lock<std::shared_timed_mutex>
+  /// class
+  void lockSharedTimedMutex(std::unique_lock<std::shared_timed_mutex> &Lock);
+
   /// Graph builder class.
   ///
   /// The graph builder provides means to change an existing graph (e.g. add