Execution Policy of STL Algorithms in Modern C++

The Standard Template Library (STL) in Modern C++ offers extensive algorithms that function on elemental sequences, including vectors, arrays, and lists. These algorithms work with different iterators and are implemented as template functions. These algorithms are built with the fundamentals of generic programming in mind, and they make extensive use of iterators to abstract away the underlying data structures.

In the context of STL algorithms, the execution policy describes how the algorithm can run in parallel. This was added in C++17 to enable programmers to use parallelism in specific algorithms when handling big datasets. The following are the three execution policies:

1. Sequential execution:

This policy, std::execution::seq (Sequential Execution), makes sure of that. The default execution policy is used if none is provided. It ensures that the algorithm will run in a single thread and that the execution order will match the input iterators' sequence.

Syntax:

It has the following syntax:

Example:

Let us take an example to illustrate the sequential execution in C++:

#include <algorithm>
#include <iostream>
#include <vector>
#include <execution>
int main()
{
std::vector<int> v = { 7, 9, 8, 1, 1 };
std::sort(std::execution::seq, v.begin(), v.end());
for (auto i : v)
std::cout << i << " ";
return 0;
}

Output:

Execution Policy of STL Algorithms in Modern C++

2. Standard::Execution::Par (Parallel Execution):

This policy permits parallel algorithm execution. Whether or not to use threads, vectorization, or any other parallelization technique is up to the implementation; the C++ Standard Library does not mandate how parallelism is achieved.

Syntax:

It has the following syntax:

Example:

Let us take an example to illustrate the parallel execution in C++:

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v1 = { 1, 2, 3, 4, 5 };
std::vector<int> v2(5);
std::transform(std::execution::par, v1.begin(),
				v1.end(), v2.begin(),
[](int x) { return x * x; });
for (int i : v2) {
std::cout << i << " ";
}
return 0;
}

Output:

3. Parallel Unsequenced Execution, or std::execution::par_unseq, is a policy that is comparable to std::execution::par but permits vectorization of the algorithm. It implies that in addition to being able to run in parallel, the algorithm may also be vectorized for improved performance on individual iterations.

Syntax:

It has the following syntax:

Example:

Let us take an example to illustrate the parallel unsequenced execution in C++:

#include <algorithm>
#include <iostream>
#include <vector>
#include <execution>
int main()
{
std::vector<int> v = { 1, 2, 3, 4, 5 };
std::for_each(std::execution::par_unseq, v.begin(),v.end(),
				[](int x) { std::cout << x << " "; });
return 0;
}

Output:

It's crucial to remember that not all algorithms can benefit from parallel execution when utilizing these execution policies, and the amount of performance gain will vary depending on the algorithm's nature, the size of the data, and the hardware architecture. Before selecting a parallel execution policy, performance should be profiled and measured as synchronization, and other factors may cause overhead that may be introduced by parallel execution.

Example:

Here's a simple example demonstrating the use of std::execution::par with std::for_each:

#include <algorithm>
#include <execution>
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::for_each(std::execution::par, numbers.begin(), numbers.end(), [](int& num) {
num *= 2;
});

for (const auto& num : numbers) {
std::cout << num << " ";
}
return 0;
}

Output:

Explanation:

In this example, the lambda function is applied to each vector element in parallel, doubling each element.

Performance Comparison Between Execution Policies:

A simple C++ program can be used to compare the performance variations between the execution policies, as demonstrated below:

// C++ Program to evaluate the performance of the four
// execution policies
#include <chrono>
#include <execution>
#include <iostream>
#include <vector>
// Function to calculate the execution time of different
// execution policies
void execTime(auto policy_type, std::vector<int>& num,
			std::string pType_name)
{
auto start_time= std::chrono::high_resolution_clock::now();

long long sum = 0;

// finding sum of each element in the vector
std::for_each(policy_type, num.begin(), num.end(),
				[&](int n) { sum += n; });

auto end_time= std::chrono::high_resolution_clock::now();
auto taken_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
// printing execution time
std::cout << pType_name
<< " execution time: " << taken_time<< "ms\n";
}
int main()
{
// Creating large vector of int
int size = 9999999;
std::vector<int> num(size);
// initializing vector
for (int i = 0; i < size; i++) {
num[i] = i;
}
// execution time
execTime(std::execution::seq, num, "Sequenced");
execTime(std::execution::unseq, num, "Unsequenced");
execTime(std::execution::par, num, "Parallel");
execTime(std::execution::par_unseq, num,"Parallel Unsequenced");
return 0;
}

Output:

Explanation:

As you can see, the quickest execution policies are the unsequenced_policy due to vectorization. Parallel_policy comes next, and parallel_unsequenced_policy comes after that. Ultimately, you carried out the execution technique in the planned order.

It's important to keep in mind that not every algorithm supports every execution policy and that depending on the execution policy chosen, some algorithms may perform differently. It's crucial to select the execution strategy that best suits the task's requirements and the hardware at hand. You should also test various strategies to find the best one for a particular task.

Benefits of Execution Policy of STL Algorithms in Modern C++

Developers can now manage the parallel execution of specific algorithms due to the addition of execution policies in STL algorithms in C++17. This feature has several advantages:

Performance Gains from Parallelism: The main advantage is using parallelism to boost multi-core processor performance. Large datasets can be processed more quickly by parallelizing some algorithms to handle data concurrently.
Enhanced Responsiveness: Applications handling big datasets may benefit from parallel execution, which can enhance responsiveness. Algorithms can execute and respond faster by splitting the workload among several threads or cores.
Scalability: By utilizing available hardware resources, execution policies make applications more scalable. Achieving optimal performance depends more on parallel execution as processors' core counts rise.
Flexibility and Portability: Depending on their application's parameters and their algorithms' properties, developers can select the best execution strategy. Because of its adaptability, optimization can be done to meet the unique requirements of various scenarios.
Fine-grained Control: The amount of parallelism can be managed finely using execution policies. Depending on the algorithm and its requirements, developers can select between sequential execution (std::execution::seq), parallel execution (std::execution::par), and parallel unsequenced execution (std::execution::par_unseq).
Compatibility with Current Code: Sequential execution by default functions flawlessly for existing code that uses STL algorithms without defining an execution policy. As a result, backward compatibility is guaranteed, and developers can progressively implement parallelism as needed.
Performance Profiling: The ability to switch between execution policies makes performance profiling and tuning easier. When developers can test various policies and gauge their effect on performance, it becomes simpler to locate bottlenecks and optimize crucial code segments.
Concise and Readable Code: Using execution policies in STL algorithms enables developers to express parallelism concisely and readably despite the underlying complexity of parallel execution. The algorithm calls are still known, and behaviour is controlled by the execution policy acting as a modifier.

It's important to remember that not all algorithms benefit equally from parallelization and that the efficiency of parallel execution varies depending on several variables, including the algorithm's nature, size, and hardware architecture. Using performance profiling and careful thought to determine the best use of execution policies in a particular situation is advised.

Next TopicFeclearexcept in C++

← prev next →