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

src/thread/thread_pool.h

@@ -11,92 +11,32 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// IWYU pragma: private, include "third_party/mujoco/include/mujoco.h"
-// IWYU pragma: friend "third_party/(py/)?mujoco/.*"
 
 #ifndef MUJOCO_SRC_THREAD_THREAD_POOL_H_
 #define MUJOCO_SRC_THREAD_THREAD_POOL_H_
 
+#include <stddef.h>
+
+#include <mujoco/mjexport.h>
+#include <mujoco/mjthread.h>
+
 #ifdef __cplusplus
-
-#include <atomic>
-#include <cstddef>
-#include <thread>
-
-#include "thread/lockless_queue.h"
-#include "thread/task.h"
-
 namespace mujoco {
+extern "C" {
+#endif
 
-static constexpr size_t kThreadPoolQueueSize = 640;
+// Create a thread pool with the specified number of threads running.
+MJAPI mjThreadPool* mju_threadPoolCreate(size_t number_of_threads);
 
-template <size_t max_number_of_threads>
-class ThreadPool {
- public:
-  ThreadPool(size_t number_of_threads)
-      : number_of_threads_(number_of_threads) {
-    for (int i = 0; i < number_of_threads_; ++i) {
-      threads_[i] = std::thread(ThreadPoolWorker, static_cast<void*>(this));
-    }
-  }
+// Enqueue a task in a thread pool.
+MJAPI void mju_threadPoolEnqueue(mjThreadPool* thread_pool, mjTask* task);
 
-  // start a task in the threadpool
-  void Enqueue(
-      Task* task, Task::FunctionPtr start_routine, void* args) {
-    Task::Initialize(task, start_routine, args);
-    lockless_queue_.push(static_cast<void*>(task));
-  }
-
-  // shutdown the threadpool
-  void Shutdown() {
-    if (shutdown_) {
-      return;
-    }
-
-    shutdown_ = true;
-    Task shutdown_tasks[max_number_of_threads];
-    for (int i = 0; i < number_of_threads_; ++i) {
-      Enqueue(&shutdown_tasks[i], ShutdownFunction, nullptr);
-    }
-
-    for (int i = 0; i < number_of_threads_; ++i) {
-      threads_[i].join();
-    }
-  }
-
-  ~ThreadPool() { Shutdown(); }
-
- private:
-  // method executed by running threads
-  static void ThreadPoolWorker(void* arg) {
-    ThreadPool<max_number_of_threads>* thread_pool =
-        static_cast<ThreadPool<max_number_of_threads>*>(arg);
-    while (!thread_pool->shutdown_) {
-      Task* task = static_cast<Task*>(thread_pool->lockless_queue_.pop());
-      task->Execute();
-    }
-  }
-
-  // shutdown function passed to running threads to ensure cleans shutdown
-  static void* ShutdownFunction(void* args) {
-    return NULL;
-  }
-
-  // is the thread pool is being shut down
-  std::atomic<bool> shutdown_ = false;
-
-  // actual number of running threads in the threadpool
-  const size_t number_of_threads_;
-
-  // OS threads that are running in this pool
-  std::thread threads_[max_number_of_threads];
-
-  // queue of tasks to execute
-  LocklessQueue<void*, kThreadPoolQueueSize> lockless_queue_;
-};
+// Destroy a thread pool.
+MJAPI void mju_threadPoolDestroy(mjThreadPool* thread_pool);
 
+#ifdef __cplusplus
+}  // extern "C"
 }  // namespace mujoco
-
 #endif  // __cplusplus
 
 #endif  // MUJOCO_SRC_THREAD_THREAD_POOL_H_