Using Execution Policies with Custom Algorithms in C++

Execution policies in C++ are primarily designed for use with standard library algorithms to enable parallel and vectorized execution.

However, you can also apply the concept of execution policies to your custom algorithms with some additional work. This involves explicitly managing how tasks are dispatched and executed.

Here's how you can create a custom algorithm that supports execution policies:

1. Define the Execution Policy: Decide whether your custom algorithm will support std::execution::seq, std::execution::par, or std::execution::par_unseq.
2. Implement the Algorithm: Use threading libraries like <thread>, <future>, or parallel algorithms from the <execution> header to manage task execution based on the provided policy.

Here's an example:

1#include <algorithm>
2#include <execution>
3#include <iostream>
4#include <mutex>
5#include <thread>
6#include <vector>
7
8// Mutex to make Log function atomic
9std::mutex log_mutex;
10
11template <typename Iterator, typename Function>
12void custom_for_each(
13  std::execution::sequenced_policy,
14  Iterator first, Iterator last, Function fn
15) {
16  std::for_each(first, last, fn);
17}
18
19template <typename Iterator, typename Function>
20void custom_for_each(
21  std::execution::parallel_policy,
22  Iterator first, Iterator last, Function fn) {
23  std::vector<std::thread> threads;
24  for (auto it = first; it != last; ++it) {
25    threads.emplace_back(fn, *it);
26  }
27  for (auto& t : threads) {
28    t.join();
29  }
30}
31
32template <typename Iterator, typename Function>
33void custom_for_each(
34  std::execution::parallel_unsequenced_policy,
35  Iterator first, Iterator last, Function fn
36) {
37  std::for_each(
38    std::execution::par_unseq, first, last, fn);
39}
40
41void Log(int number) {
42  std::lock_guard<std::mutex> guard(log_mutex);
43  std::cout << "Number: " << number << '\n';
44}
45
46int main() {
47  std::vector<int> numbers{1, 2, 3, 4, 5};
48
49  custom_for_each(
50    std::execution::par,
51    numbers.begin(), numbers.end(), Log
52  );
53}

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

In this example, custom_for_each() supports both sequential and parallel execution policies. For parallel execution, it spawns a new thread for each element in the range.

Key points:

• Standard library execution policies (std::execution::seq, std::execution::par, std::execution::par_unseq) can inspire the design of custom algorithms.
• Custom algorithms must manage task execution explicitly, often using threading libraries.
• Ensure that your custom algorithm properly handles synchronization and resource sharing to avoid race conditions.

By following these guidelines, you can extend the power of execution policies to your custom algorithms, improving their performance and scalability.