Execution Policy of STL Algorithms in Modern C++

#include << algorithm>>

#include << iostream>>

#include << vector>>

#include << execution>>

int primary()

{

sexually transmitted disease:: vector< v = {5, 2, 3, 1, 4}; sexually transmitted disease:: sort( sexually transmitted disease:: execution:: seq, v.begin(), v.end());

for

( vehicle i: v) sexually transmitted disease:: cout << < < i << < <

" "; return

0;} Output

5 4 3 2 1

#include << iostream>>

#include << vector>>

int primary()

{

sexually transmitted disease:: vector< v1 = {1, 2, 3, 4, 5};

sexually transmitted disease:: vector< v2( 5 );

sexually transmitted disease:: change( sexually transmitted disease:: execution:: par, v1.begin(), v1.end(), v2.begin(),

(

int x) {

return x * x;} );

[] for( int

i: v2) {

sexually transmitted disease:: cout << < < i << < < " " ;

}

return 0;}

Output 1 4 9 16 25

In this example, we develop 2 vectors of integers v1 and v2, and after that utilize the sexually transmitted disease:: change algorithm with the sexually transmitted disease:: execution:: par policy to square the aspects of v1 and shop the lead to v2. The outcome is a vector v2 with aspects {1, 4, 9, 16, 25}. Benefits of parallel_policy Faster execution for bigger jobs.

Ideal use of multi-core systems.

int

primary()

{

sexually transmitted disease:: vector< v = {1, 2, 3, 4, 5};

sexually transmitted disease:: for_each( sexually transmitted disease:: execution:: par_unseq, v.begin(),

v.end(),

( int x) {sexually transmitted disease:: cout << < < x << < <

" ";} );

return

0;[]} Output 1 2 3 4 5 In this example, we develop a vector of integers and after that utilize the sexually transmitted disease:: for_each algorithm with the sexually transmitted disease:: execution:: par_unseq policy to print its aspects in parallel and unordered. The outcome can be any permutation of the input vector, depending upon the order in which the aspects are processed. Benefits of parallel_unsequenced_policy

Faster execution for repeated operations. Can be utilized on hardware with vector directions. Downsides of parallel_unsequenced_policy

Not ideal for all jobs.

{

sexually transmitted disease:: vector< v = {1, 2, 3, 4, 5};

sexually transmitted disease:: for_each( sexually transmitted disease:: execution:: unseq, v.begin(),

v.end(),

(

int x) {sexually transmitted disease:: cout << < < x << < < " ";} );

return

0;}

Output[] 1 2 3 4 5 Benefits of unsequenced_policy Quick Execution on a single thread Prevents Race Conditions Downsides of unsequenced_policy

Some Hardware might not support vectorization. Non-Deterministic execution series. Efficiency Contrast in between Execution Policies

We can compare the efficiency distinction in between the execution policies utilizing an easy C++ program as revealed listed below:

sexually transmitted disease:: string pType_name)

{

vehicle

start_time

= sexually transmitted disease:: chrono:: high_resolution_clock:: now(); long long

amount = 0;

sexually transmitted disease:: for_each( policy_type, num.begin(), num.end(),

(

int n) {amount += n;} );

vehicle

end_time

= sexually transmitted disease:: chrono:: high_resolution_clock:: now();

[&] vehicle taken_time = sexually transmitted disease:: chrono:: duration_cast<(

end_time - start_time)

count();

sexually transmitted disease:: cout << < < pType_name

<< < < " execution time: "

<< < < taken_time << < <

" msn";

}

int

primary()

{

int size = 9999999;

sexually transmitted disease:: vector< num( size); for

(

int i = 0; i < < size; i++) {

num

= i;

}

execTime( sexually transmitted disease:: execution:: seq, num, " Sequenced"

);

execTime( sexually transmitted disease:: execution:: unseq, num, " Unsequenced");

execTime( sexually transmitted disease:: execution:: par, num, " Parallel"[i]);

execTime( sexually transmitted disease:: execution:: par_unseq, num,

" Parallel Unsequenced"

);

return

0;} Output Sequenced execution time: 917ms . Unsequenced execution time: 406ms .
Parallel execution time: 897ms .
Parallel Unsequenced execution time: 420ms

As we can see, of all the execution policies, the unsequenced_policy is the fastest due to the fact that of vectorization. Then comes parallel_unsequenced_policy followed by the parallel_policy. At last, we sequenced the execution approach as anticipated. Note: The above code can just be performed utilizing C++ 20 Requirement or above compiler. Conclusion

It deserves keeping in mind that not all algorithms support all execution policies, and some algorithms might have various efficiency attributes depending upon the execution policy utilized. It is very important to select the execution policy that finest fits the requirements of the job and the hardware readily available and to check various policies to identify the optimum one for a provided job. Frequently Asked Questions on Execution Policies for STL Algorithms

1. In which variation was the execution policies initially included C++ ISO Requirement? STL Algorithms execution policies were initially presented in C++ 17 Requirement and after that C++ 20 likewise included another type in the future. 2. Note the STL Algorithms that support execution policies.

Here is the complete list of C++ algorithms that support execution policies: sexually transmitted disease:: adjacent_difference

sexually transmitted disease:: adjacent_find sexually transmitted disease:: all_of sexually transmitted disease:: any_of

sexually transmitted disease:: copy