[SYCL] Removed mutex leading to deadlock

sycl/source/detail/scheduler/scheduler.cpp

@@ -109,7 +109,6 @@ std::vector<EventImplPtr> Scheduler::getWaitList(EventImplPtr Event) {
 }
 
 void Scheduler::waitForEvent(EventImplPtr Event) {
-  std::lock_guard<std::mutex> lock(MGraphLock);
   GraphProcessor::waitForEvent(std::move(Event));
 }
 

sycl/unittests/CMakeLists.txt

@@ -34,3 +34,4 @@ endfunction()
 
 add_subdirectory(pi)
 add_subdirectory(misc)
+add_subdirectory(thread_safety)

sycl/unittests/thread_safety/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_sycl_unittest(ThreadSafetyTests
+    HostAccessorDeadLock.cpp
+)

sycl/unittests/thread_safety/HostAccessorDeadLock.cpp

@@ -0,0 +1,34 @@
+//==----- HostAccessorDeadLock.cpp --- Thread Safety unit tests ------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ThreadUtils.h"
+#include <CL/sycl.hpp>
+#include <gtest/gtest.h>
+#include <mutex>
+#include <vector>
+
+namespace {
+constexpr auto sycl_read_write = cl::sycl::access::mode::read_write;
+
+TEST(HostAccessorDeadLockTest, CheckThreadOrder) {
+  constexpr std::size_t size = 1;
+  constexpr std::size_t threadCount = 4, launchCount = 5;
+
+  {
+    cl::sycl::buffer<std::size_t, 1> buffer(size);
+
+    auto testLambda = [&](std::size_t threadId) {
+      auto acc = buffer.get_access<sycl_read_write>();
+    };
+
+    for (std::size_t k = 0; k < launchCount; ++k) {
+      ThreadPool MPool(threadCount, testLambda);
+    }
+  }
+}
+} // namespace

sycl/unittests/thread_safety/ThreadUtils.h

@@ -0,0 +1,48 @@
+#include <thread>
+#include <vector>
+
+class ThreadPool {
+public:
+  ThreadPool() = delete;
+  ThreadPool(ThreadPool &) = delete;
+
+  template <typename Func>
+  ThreadPool(std::size_t N, Func func) {
+    for (std::size_t i = 0; i < N; ++i) {
+      enqueue(func, i);
+    }
+  }
+
+  template <typename Func, typename... Funcs>
+  ThreadPool(Func &&func, Funcs &&... funcs) {
+    constexpr int N = sizeof...(funcs);
+    enqueue(std::forward<Func>(func), N);
+    enqueueHelper<N>(std::forward<Funcs>(funcs)...);
+  }
+
+  ~ThreadPool() { wait(); }
+
+private:
+  template <int N, typename Func, typename... Funcs>
+  void enqueueHelper(Func &&func, Funcs &&... funcs) {
+    enqueue(std::forward<Func>(func), N - 1);
+    enqueueHelper<N - 1>(std::forward<Funcs>(funcs)...);
+  }
+
+  template <int N>
+  void enqueueHelper() {}
+
+  template <typename Func, typename... Args>
+  void enqueue(Func &&func, Args &&... args) {
+    MThreadPool.emplace_back(std::forward<Func>(func),
+                             std::forward<Args>(args)...);
+  }
+
+  void wait() {
+    for (auto &t : MThreadPool) {
+      t.join();
+    }
+  }
+
+  std::vector<std::thread> MThreadPool;
+};