Use NEO::Thread instead of std::thread

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>

shared/source/direct_submission/direct_submission_controller.cpp

@@ -8,6 +8,7 @@
 #include "shared/source/direct_submission/direct_submission_controller.h"
 
 #include "shared/source/command_stream/command_stream_receiver.h"
+#include "shared/source/os_interface/os_thread.h"
 
 #include <chrono>
 
@@ -20,13 +21,14 @@ DirectSubmissionController::DirectSubmissionController() {
         timeout = DebugManager.flags.DirectSubmissionControllerTimeout.get();
     }
 
-    directSubmissionControllingThread = std::thread(&DirectSubmissionController::controlDirectSubmissionsState, this);
+    directSubmissionControllingThread = Thread::create(controlDirectSubmissionsState, reinterpret_cast<void *>(this));
 };
 
 DirectSubmissionController::~DirectSubmissionController() {
     keepControlling.store(false);
-    if (directSubmissionControllingThread.joinable()) {
-        directSubmissionControllingThread.join();
+    if (directSubmissionControllingThread) {
+        directSubmissionControllingThread->join();
+        directSubmissionControllingThread.reset();
     }
 }
 
@@ -40,21 +42,23 @@ void DirectSubmissionController::unregisterDirectSubmission(CommandStreamReceive
     directSubmissions.erase(csr);
 }
 
-void DirectSubmissionController::controlDirectSubmissionsState() {
+void *DirectSubmissionController::controlDirectSubmissionsState(void *self) {
+    auto controller = reinterpret_cast<DirectSubmissionController *>(self);
+
     while (true) {
 
         auto start = std::chrono::steady_clock::now();
         int diff = 0u;
         do {
-            if (!keepControlling.load()) {
-                return;
+            if (!controller->keepControlling.load()) {
+                return nullptr;
             }
 
             auto timestamp = std::chrono::steady_clock::now();
             diff = static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(timestamp - start).count());
-        } while (diff <= timeout);
+        } while (diff <= controller->timeout);
 
-        this->checkNewSubmissions();
+        controller->checkNewSubmissions();
     }
 }
 

shared/source/direct_submission/direct_submission_controller.h

@@ -8,13 +8,14 @@
 #pragma once
 
 #include <atomic>
+#include <memory>
 #include <mutex>
-#include <thread>
 #include <unordered_map>
 
 namespace NEO {
 class MemoryManager;
 class CommandStreamReceiver;
+class Thread;
 
 class DirectSubmissionController {
   public:
@@ -30,13 +31,13 @@ class DirectSubmissionController {
         uint32_t taskCount = 0u;
     };
 
-    void controlDirectSubmissionsState();
+    static void *controlDirectSubmissionsState(void *self);
     void checkNewSubmissions();
 
     std::unordered_map<CommandStreamReceiver *, DirectSubmissionState> directSubmissions;
     std::mutex directSubmissionsMutex;
 
-    std::thread directSubmissionControllingThread;
+    std::unique_ptr<Thread> directSubmissionControllingThread;
     std::atomic_bool keepControlling = true;
 
     int timeout = 5;

shared/test/unit_test/direct_submission/direct_submission_controller_tests.cpp

@@ -36,7 +36,8 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenRegiste
 
     DirectSubmissionControllerMock controller;
     controller.keepControlling.store(false);
-    controller.directSubmissionControllingThread.join();
+    controller.directSubmissionControllingThread->join();
+    controller.directSubmissionControllingThread.reset();
     controller.registerDirectSubmission(&csr);
 
     controller.checkNewSubmissions();
@@ -91,7 +92,7 @@ TEST(DirectSubmissionControllerTests, givenDirectSubmissionControllerWhenTimeout
     while (!controller.directSubmissions[&csr].isStopped) {
     }
 
-    EXPECT_TRUE(controller.directSubmissionControllingThread.joinable());
+    EXPECT_NE(controller.directSubmissionControllingThread.get(), nullptr);
     EXPECT_TRUE(controller.directSubmissions[&csr].isStopped);
     EXPECT_EQ(controller.directSubmissions[&csr].taskCount, 9u);