Parallel Algorithm Execution

Controlling the Number of Threads Used by Execution Policies in C++

How do I control the number of threads used by `std::execution::par`?

Abstract art representing computer programming

Controlling the number of threads used by std::execution::par in C++ can be crucial for optimizing performance and avoiding resource contention.

The C++ standard library does not provide direct control over the number of threads used by the parallel execution policy (std::execution::par). However, you can influence thread usage indirectly through various techniques.

Thread Pool Libraries: Use third-party thread pool libraries that allow you to set the number of threads. For example, Intel Threading Building Blocks (TBB) or Boost.Thread.
Custom Thread Pool: Implement your own thread pool to control the number of threads and use it within your parallel algorithms.

Here’s an example of using a custom thread pool with a parallel execution policy:

1#include <condition_variable>
2#include <execution>
3#include <functional>
4#include <future>
5#include <iostream>
6#include <mutex>
7#include <queue>
8#include <thread>
9#include <vector>
10
11class ThreadPool {
12 public:
13  ThreadPool(size_t numThreads);
14  ~ThreadPool();
15
16  template <class F>
17  void enqueue(F&& f);
18
19 private:
20  std::vector<std::thread> workers;
21  std::queue<std::function<void()>> tasks;
22  std::mutex queueMutex;
23  std::condition_variable condition;
24  bool stop;
25};
26
27ThreadPool::ThreadPool(size_t numThreads)
28  : stop(false) {
29  for (size_t i = 0; i < numThreads; ++i) {
30    workers.emplace_back([this] {
31      for (;;) {
32        std::function<void()> task;
33        {
34          std::unique_lock<std::mutex> lock(
35            this->queueMutex);
36          this->condition.wait(lock, [this] {
37            return this->stop || !this->tasks.empty();
38          });
39          if (this->stop && this->tasks.empty())
40            return;
41          task = std::move(this->tasks.front());
42          this->tasks.pop();
43        }
44        task();
45      }
46    });
47  }
48}
49
50ThreadPool::~ThreadPool() {
51  {
52    std::unique_lock<std::mutex> lock(queueMutex);
53    stop = true;
54  }
55  condition.notify_all();
56  for (std::thread& worker : workers) {
57    worker.join();
58  }
59}
60
61template <class F>
62void ThreadPool::enqueue(F&& f) {
63  {
64    std::unique_lock<std::mutex> lock(queueMutex);
65    tasks.emplace(std::forward<F>(f));
66  }
67  condition.notify_one();
68}
69
70void Log(int number) {
71  std::cout << "Number: " << number << '\n';
72}
73
74int main() {
75  // Control the number of threads here
76  ThreadPool pool(4);
77  std::vector<int> numbers{1, 2, 3, 4, 5};
78
79  for (int number : numbers) {
80    pool.enqueue([number] { Log(number); });
81  }
82}

1Number: 1
2Number: 5
3Number: 2
4Number: 4
5Number: 3

In this example, a ThreadPool class is implemented to manage a fixed number of threads. The Log function is then enqueued into the thread pool, which controls the execution of tasks.

Key points:

C++ standard does not directly control the number of threads for std::execution::par.
Use thread pool libraries or custom thread pools for better control.
Ensure thread pools handle task synchronization and avoid race conditions.

By managing your thread pool, you can control the number of threads used in parallel execution, improving performance and resource management.

This Question is from the Lesson: