Refactor thread pool implementation.

- Make mjTask non-opaque and remove C++ Task class.
- Make C++ thread pool a subclass of a skeletal mjThreadPool C struct.
- Make the mjTask status enum more consistent with the rest of MuJoCo.
- Change mju_threadPoolEnqueue to take just the mjTask. Users must now prepare the mjTask by assigning the function pointer and argument into the struct.
- Rename files in thread/ to be more consistent with the rest of MuJoCo.
- Run threading tests in CMake.
- Allow use of C++20 designated initializers.

Otherwise the functionality remains identical.

PiperOrigin-RevId: 564374675
Change-Id: I37c9894566bc39faf217e5aa97a4e2713a70e467

test/thread/thread_pool_test.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/thread/thread_pool.h"
-
 #include <atomic>
 #include <condition_variable>
 #include <memory>
@@ -21,75 +19,82 @@
 #include <thread>
 
 #include <gtest/gtest.h>
-#include "src/thread/task.h"
+#include <mujoco/mujoco.h>
 
 namespace mujoco {
 namespace {
 
-struct TestFunctionArgs {
+struct TestFunctionArgs_ {
   int input;
   // make this atomic to avoid red-herring tsan failures.
   std::atomic<int> output;
 };
+typedef struct TestFunctionArgs_ TestFunctionArgs;
 
 void* test_function(void* args) {
   TestFunctionArgs* test_function_args = static_cast<TestFunctionArgs*>(args);
+  if (!test_function_args) {
+    return nullptr;
+  }
   test_function_args->output = test_function_args->input;
   return nullptr;
 }
 
 TEST(TestMjThreadPool, TestMjThreadPool10Threads) {
-  ThreadPool<10> thread_pool(10);
+  mjThreadPool* thread_pool = mju_threadPoolCreate(10);
 
   constexpr int kTasks = 1000;
   TestFunctionArgs test_function_args[kTasks];
-  Task tasks[kTasks];
+  mjTask tasks[kTasks];
   for (int i = 0; i < kTasks; ++i) {
     test_function_args[i].input = i;
-    thread_pool.Enqueue(
-        &tasks[i], test_function, static_cast<void*>(&test_function_args[i]));
+    mju_defaultTask(&tasks[i]);
+    tasks[i].func = test_function;
+    tasks[i].args = &test_function_args[i];
+    mju_threadPoolEnqueue(thread_pool, &tasks[i]);
   }
 
   for (int i = 0; i < kTasks; ++i) {
-    tasks[i].Join();
+    mju_taskJoin(&tasks[i]);
   }
 
   for (int i = 0; i < kTasks; ++i) {
     EXPECT_EQ(test_function_args[i].input, test_function_args[i].output);
   }
-
-  thread_pool.Shutdown();
+  mju_threadPoolDestroy(thread_pool);
 }
 
 TEST(TestMjThreadPool, TestMjThreadPool100Threads) {
-  ThreadPool<100> thread_pool(100);
+  mjThreadPool* thread_pool = mju_threadPoolCreate(100);
 
   constexpr int kTasks = 1000;
   TestFunctionArgs test_function_args[kTasks];
-  Task tasks[kTasks];
+  mjTask tasks[kTasks];
   for (int i = 0; i < kTasks; ++i) {
     test_function_args[i].input = i;
-    thread_pool.Enqueue(
-        &tasks[i], test_function, static_cast<void*>(&test_function_args[i]));
+    mju_defaultTask(&tasks[i]);
+    tasks[i].func = test_function;
+    tasks[i].args = &test_function_args[i];
+    mju_threadPoolEnqueue(thread_pool, &tasks[i]);
   }
 
   for (int i = 0; i < kTasks; ++i) {
-    tasks[i].Join();
+    mju_taskJoin(&tasks[i]);
   }
 
   for (int i = 0; i < kTasks; ++i) {
     EXPECT_EQ(test_function_args[i].input, test_function_args[i].output);
   }
 
-  thread_pool.Shutdown();
+  mju_threadPoolDestroy(thread_pool);
 }
 
 TEST(TestMjThreadPool, TestMjThreadPoolManyWriters) {
-  ThreadPool<10> thread_pool(10);
+  mjThreadPool* thread_pool = mju_threadPoolCreate(10);
 
   constexpr int kTasks = 20;
   TestFunctionArgs test_function_args[kTasks];
-  Task tasks[kTasks];
+  mjTask tasks[kTasks];
   std::unique_ptr<std::thread> enqueue_threads[kTasks];
 
   // add tasks to the thread pool from many threads
@@ -98,6 +103,10 @@ TEST(TestMjThreadPool, TestMjThreadPoolManyWriters) {
   bool start = false;
   for (int i = 0; i < kTasks; ++i) {
     test_function_args[i].input = i;
+    mju_defaultTask(&tasks[i]);
+    tasks[i].func = &test_function;
+    tasks[i].args = &test_function_args[i];
+
     enqueue_threads[i] = std::make_unique<std::thread>([&, i] {
       // synchronize all threads adding to the thread_pool at the same time
       {
@@ -105,8 +114,7 @@ TEST(TestMjThreadPool, TestMjThreadPoolManyWriters) {
         start_cv.wait(lock, [&] { return start; });
       }
       // enqueue outside the lock, to get some concurrency
-      thread_pool.Enqueue(
-          &tasks[i], test_function, static_cast<void*>(&test_function_args[i]));
+      mju_threadPoolEnqueue(thread_pool, &tasks[i]);
     });
   }
   {
@@ -120,14 +128,14 @@ TEST(TestMjThreadPool, TestMjThreadPoolManyWriters) {
   }
 
   for (int i = 0; i < kTasks; ++i) {
-    tasks[i].Join();
+    mju_taskJoin(&tasks[i]);
   }
 
   for (int i = 0; i < kTasks; ++i) {
     EXPECT_EQ(test_function_args[i].input, test_function_args[i].output);
   }
 
-  thread_pool.Shutdown();
+  mju_threadPoolDestroy(thread_pool);
 }
 
 }  // namespace