[SYCL] Removed mutex leading to deadlock

The deadlock appeared under following circumstances:
1) thread1: adds nodes to the graph for host accessor A1 to the buffer B;
2) thread2: adds nodes to the graph for host accessor A2 to the buffer B;
3) thread2: waits for host accessor A2 nodes to complete;
4) thread1: waits for host accessor A1 nodes to complete.

On step 3 thread2 locks a mutex in `Scheduler::waitForEvent`
and waits for destruction of host accessor A1.
Actions on step 4 cannot be completed because thread1 waits for the
mutex to be unlocked.

Signed-off-by: Ivan Karachun <[email protected]>

Author: Ivan Karachun

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,4 @@
+add_sycl_unittest(ThreadSafetyTests
+    ThreadUtils.cpp
+    HostAccessorDeadLock.cpp
+)

sycl/unittests/thread_safety/HostAccessorDeadLock.cpp

@@ -0,0 +1,54 @@
+//==---- SchedulerThreadSafety.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;
+
+template <typename T, int Dim> class TestDeadLock : public ParallelTask {
+public:
+  TestDeadLock(T *Data, std::size_t Size)
+      : MBuffer(Data, cl::sycl::range<Dim>(Size)), MBufferSize(Size) {}
+
+  void taskBody(size_t ThreadId) {
+    auto acc = MBuffer.template get_access<sycl_read_write>();
+    for (std::size_t i = 0; i < MBufferSize; ++i) {
+      acc[i] = ThreadId;
+      if (i == 0) {
+        MMutex.lock();
+        MThreadOrder.push_back(ThreadId);
+        MMutex.unlock();
+      }
+    }
+  }
+
+  std::size_t getLastWorkingThread() { return MThreadOrder.back(); }
+
+private:
+  std::vector<std::size_t> MThreadOrder;
+  cl::sycl::buffer<T, Dim> MBuffer;
+  std::size_t MBufferSize;
+  std::mutex MMutex;
+};
+
+class HostAccessorDeadLockTest : public ::testing::Test {};
+
+TEST_F(HostAccessorDeadLockTest, CheckThreadOrder) {
+  constexpr size_t size = 1024;
+  constexpr size_t threadCount = 4;
+  std::size_t data[size];
+  TestDeadLock<std::size_t, 1> Task(data, size);
+  Task.execute(threadCount);
+  EXPECT_EQ(data[size - 1], Task.getLastWorkingThread());
+}
+} // namespace

sycl/unittests/thread_safety/ThreadUtils.cpp

@@ -0,0 +1,47 @@
+#include "ThreadUtils.h"
+#include <iostream>
+
+static void *threadMainBody(Thread *thread, size_t id) {
+  thread->body(id);
+  return NULL;
+}
+
+void Thread::start(size_t id) {
+  MThread = std::move(std::thread(threadMainBody, this, id));
+}
+
+void Thread::wait() { MThread.join(); }
+
+void Thread::body(size_t id) { MTask->taskBody(id); }
+
+ThreadPool::ThreadPool(ParallelTask *p) : MTask(p) {}
+
+void ThreadPool::initialize(int size) {
+  for (int i = 0; i < size; ++i) {
+    MThreadPool.push_back(new Thread(MTask));
+  }
+}
+
+void ThreadPool::start() {
+  for (std::size_t i = 0; i < MThreadPool.size(); ++i) {
+    MThreadPool[i]->start(i);
+  }
+}
+
+void ThreadPool::wait() {
+  for (auto it : MThreadPool) {
+    it->wait();
+  }
+}
+
+void ParallelTask::execute(int threadCount) {
+  try {
+    MPool.initialize(threadCount);
+    MPool.start();
+    MPool.wait();
+  } catch (std::exception &ex) {
+    std::cerr << ex.what();
+  } catch (...) {
+    std::cerr << "Unknown exception";
+  }
+}

sycl/unittests/thread_safety/ThreadUtils.h

@@ -0,0 +1,42 @@
+#include <thread>
+#include <vector>
+
+class ParallelTask;
+
+class Thread {
+public:
+  Thread(ParallelTask *Ptr) : MTask(Ptr) {}
+  void start(size_t id);
+  void wait();
+  void body(size_t id);
+
+private:
+  std::thread MThread;
+  ParallelTask *MTask;
+};
+
+class ThreadPool {
+public:
+  ThreadPool(ParallelTask *p);
+  void initialize(int size);
+  void start();
+  void wait();
+
+private:
+  std::vector<Thread *> MThreadPool;
+  ParallelTask *MTask;
+};
+
+class ParallelTask {
+  friend class ThreadPool;
+
+public:
+  ParallelTask() : MPool(this) {}
+
+  void execute(int threadCount);
+
+  virtual void taskBody(std::size_t id) = 0;
+
+private:
+  ThreadPool MPool;
+};