Updated the test

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

Author: Ivan Karachun

sycl/unittests/thread_safety/CMakeLists.txt

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

sycl/unittests/thread_safety/HostAccessorDeadLock.cpp

@@ -1,4 +1,4 @@
-//==---- SchedulerThreadSafety.cpp --- Thread Safety unit tests ------------==//
+//==----- 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.
@@ -15,40 +15,47 @@
 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();
-      }
-    }
-  }
+class HostAccessorDeadLockTest : public ::testing::Test {
+protected:
+  HostAccessorDeadLockTest() : MPool() {}
+  ~HostAccessorDeadLockTest() override = default;
 
-  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;
+  ThreadPool MPool;
 };
 
-class HostAccessorDeadLockTest : public ::testing::Test {};
-
 TEST_F(HostAccessorDeadLockTest, CheckThreadOrder) {
-  constexpr size_t size = 1024;
-  constexpr size_t threadCount = 4;
+  constexpr std::size_t size = 1024;
+  constexpr std::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());
+  std::size_t lastThreadNum = -1, launchCount = 5;
+
+  {
+    std::vector<std::size_t> threadOrder;
+    cl::sycl::buffer<std::size_t, 1> buffer(data, size);
+    std::mutex mutex;
+
+    auto testLambda = [&](std::size_t threadId) {
+      auto acc = buffer.get_access<sycl_read_write>();
+      for (std::size_t i = 0; i < size; ++i) {
+        acc[i] = threadId;
+        if (i == 0) {
+          mutex.lock();
+          threadOrder.push_back(threadId);
+          mutex.unlock();
+        }
+      }
+    };
+
+    for (std::size_t k = 0; k < launchCount; ++k) {
+      MPool.clear();
+      for (std::size_t i = 0; i < threadCount; ++i)
+        MPool.enqueue(testLambda, i);
+      MPool.wait();
+    }
+
+    lastThreadNum = threadOrder.back();
+  }
+
+  EXPECT_EQ(data[size - 1], lastThreadNum);
 }
 } // namespace

sycl/unittests/thread_safety/ThreadUtils.cpp

@@ -1,42 +1,28 @@
 #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;
+  void clear() { MThreadPool.clear(); }
+
+  template <typename Func, typename... Args>
+  void enqueueNTimes(std::size_t N, Func &&func, Args &&... args) {
+    for (std::size_t i = 0; i < N; ++i)
+      enqueue(std::forward<Func>(func), std::forward<Args>(args)...);
+  }
+
+  template <typename Func, typename... Args>
+  void enqueue(Func &&func, Args &&... args) {
+    MThreadPool.push_back(
+        std::thread(std::forward<Func>(func), std::forward<Args>(args)...));
+  }
+
+  void wait() {
+    for (auto &t : MThreadPool) {
+      t.join();
+    }
+  }
 
 private:
-  ThreadPool MPool;
+  std::vector<std::thread> MThreadPool;
 };