[pstl] Do not inject execution policies into namespace ::pstl in the tests

[ldionne]

Summary

Doing so makes the test suite test non-conforming behavior that neither
libc++ nor libstdc++ needs.

[MikeDvorskiy]

Guys,
I understand that given pstl code is becoming a part of C++ standard library and , of course should be std::execution::unsequenced_policy and so on..

But, there is PSTL standalone version, which works with the other compilers and environment , MSVC for example, where there is another implementation of Parallel STL.
In that case we have to differ a namespace where the execution policies are defined, otherwise a user code (and the tests) will use MSVC implementation of parallel algorithms instead of our...

I have two alternative ideas here:

1. Using a special macro like

__PSTL_NAMESPACE_FOR_EXECUTION

On LLVM side it will be defined as

#define __PSTL_NAMESPACE_FOR_EXECUTION std

On our side it will be defined as

#define __PSTL_NAMESPACE_FOR_EXECUTION __pstl

2. Or just use

using namespace std;

or (depends on a macro like PSTL_POLICY_USAGE)

using namespace __pstl;

in test\support\pstl_test_config.h or test\support\utils.h

[ldionne]

In D60537#1462371, @MikeDvorskiy wrote:

Guys,
I understand that given pstl code is becoming a part of C++ standard library and , of course should be std::execution::unsequenced_policy and so on..

But, there is PSTL standalone version, which works with the other compilers and environment , MSVC for example, where there is another implementation of Parallel STL.
In that case we have to differ a namespace where the execution policies are defined, otherwise a user code (and the tests) will use MSVC implementation of parallel algorithms instead of our...

I have two alternative ideas here:
[...]

Of course, we should still support the use case you have in mind. My goal is not to make the PSTL *only* useful for standard libraries -- the PSTL shouldn't inject its declarations into namespace std, and this was a follow-up fix I planned on making. Let me address your concern first and I think this patch will then make more sense to you.

Basically, I was thinking (like you) that we should have a way to customize the namespace in which pstl injects the algorithms. Then standard libraries can use something like std::__1, and you can use something like pstl::execution or whatever you want. I think we're in agreement here -- let me put this mechanism in place before removing this namespace injection.

[MikeDvorskiy]

we should have a way to customize the namespace in which pstl injects the algorithms

Actually, pstl the algorithms are defined in "std" namespace.
pstl injects just execution policy into "std".

I would like to pay your attention for changing like this in the tests

std::for_each_n(std::execution::seq, expected_first, n, Flip<T>(1));

Where a passed execution specifies an overloaded(by a policy type) implementation of std::for_each

and now the code is not correct in general I guess, because the test engine passes __pstl::execution::seg etc policies.

So, just for the test I suggest

std::for_each_n(__PSTL_POLICY_NAMESPACE::execution::seq, expected_first, n, Flip<T>(1));

to specify a proper overload in case of standalone PSTL version and there is a standard PSTL from a standard library delivered with a compiler.

[MikeDvorskiy]

Continuing the discussion - the code snippet of the test engine - pay your attention to using namespace __pstl::execution

invoke_on_all_policies(Op op, T&&... rest)
{
    using namespace __pstl::execution;

    // Try static execution policies
    invoke_on_all_iterator_types()(seq, op, std::forward<T>(rest)...);
    invoke_on_all_iterator_types()(unseq, op, std::forward<T>(rest)...);
#if _PSTL_USE_PAR_POLICIES
    invoke_on_all_iterator_types()(par, op, std::forward<T>(rest)...);
    invoke_on_all_iterator_types()(par_unseq, op, std::forward<T>(rest)...);
#endif
}

[MikeDvorskiy]

Louis,

I have an issue regarding the dummy stdlib headers.
Proposed location is valid only for the test. (/test/support/stdlib)

The tests is not necessary part of standalone PSTL because is not a part of implementation of PSTL.
For example, If i have an application which use standalone pstl include "pstl/test/support/stdlib" would look strange at least.

So, I suggest moving the dummy stdlib headers into ..pstl\internal\stdlib or into ..pstl\stdlib

[ldionne]

In D60537#1471308, @MikeDvorskiy wrote:

Louis,

I have an issue regarding the dummy stdlib headers.
Proposed location is valid only for the test. (/test/support/stdlib)

The tests is not necessary part of standalone PSTL because is not a part of implementation of PSTL.
For example, If i have an application which use standalone pstl include "pstl/test/support/stdlib" would look strange at least.

So, I suggest moving the dummy stdlib headers into ..pstl\internal\stdlib or into ..pstl\stdlib

I believe what's wrong here is the expectation that the PSTL is something that can be shipped as-is by implementations. The idea is that the PSTL provides the functionality but not necessarily the packaging for the parallel algorithms. Hence, Standard libraries have a little bit of boilerplate to include this functionality, and a "standalone" version of the PSTL should also wrap the internal headers to package the functionality however they want to.

In other words, I think the correct thing to do is for you guys to define <algorithm> & friends headers that #include <pstl/internal/XXX.h> while making sure that it works with the underlying standard library. I don't think the pstl should include headers that are useless to all but one specific shipping vehicle of the PSTL (the standalone version). That being said, if we realize that there's something useful to factor out for several shipping vehicles, of course we should do it. WDYT?

[MikeDvorskiy]

I don't think the pstl should include headers that are useless to all but one specific shipping vehicle of the PSTL (the standalone version)

Why cannot it be lie onto high "include\pstl" (or even "pstl") level of "LLVM upstream" as a special folder, which will not be taken into libcxx and libcstd++ libraries? (BTW, and as well the other extra functionality which is not going to be released with the next libcxx/libcstd release?, for e[ample alternative back-ends, experimental features, etc)
Just ignore it "extra" folders when the code are integrating into libcxx and libcstd repositories.
What do you think here?

[ldionne]

In D60537#1471786, @MikeDvorskiy wrote:

I don't think the pstl should include headers that are useless to all but one specific shipping vehicle of the PSTL (the standalone version)

Why cannot it be lie onto high "include\pstl" (or even "pstl") level of "LLVM upstream" as a special folder, which will not be taken into libcxx and libcstd++ libraries? (BTW, and as well the other extra functionality which is not going to be released with the next libcxx/libcstd release?, for e[ample alternative back-ends, experimental features, etc)
Just ignore it "extra" folders when the code are integrating into libcxx and libcstd repositories.
What do you think here?

I don't think it should be necessary to subset the library when shipping it, and in fact I didn't plan on needing that for libc++. However, if all we're arguing about is the path for these headers, then we can put them into include/pstl/internal/test_stdlib or something similar. But let's avoid any name/path that suggests these headers are part of the public interface of the library, because they are not (that specific bit is the point I'm trying to make).

[MikeDvorskiy]

But let's avoid any name/path that suggests these headers are part of the public interface of the library, because they are not

I'm absolutely agree.
And I suggest put these "dummy" standard headers on the rPSTL repo root level, where there are other folder which not be taken for the library, such as "doc", "cmake" and "test".
So, I suggest adding "stdlib\pstl" where "dummy" standard headers are placed, and "experimental" folder for future C++ features:
cmake
doc
include
stdlib\pstl
stdlib\experimental or just experimental
test

Arguments for "stdlib\pstl" folder:

Many people have already use standalone PSTL and a usage model is following:

---

Add the <install_dir>/include folder to the compiler include paths. You can do this by calling the pstlvars script.

Add #include "pstl/execution" to your code. Then add a subset of the following set of lines, depending on the algorithms you intend to use:

#include "pstl/algorithm"
#include "pstl/numeric"
#include "pstl/memory"

---

Arguments for "experimental" folder:
We would prefer keeping One main repository for PSTL further development (on LLVM site). And we are going to develop just features which already have had "Technical Specification" and to be going to added into one of the next C++ standard. Otherwise we have to support the second active development in the our own repo and "sync-up with LLVM repo" overheads will be very big in that case.

[MikeDvorskiy]

Louis, Rodgers,

What do you think about my last proposal regarding

stdlib\pstl

and

stdlib\experimental

BTW, I've already had a patch which does that modification (moving to <rPSTL>\stdlib\pstl)

pstl/include/pstl/internal/pstl_config.h

 #    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
 #    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
 #else
 #    define _PSTL_PRAGMA_SIMD_SCAN(PRM)
 #    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
 #    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
 #endif
 
-// Should be defined to 1 for environments with a vendor implementation of C++17 execution policies
-#define _PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912)
-
 #define _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT                                                                      \
     (_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304)
 #define _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT                                                                      \
     (_MSC_VER >= 1900 || __cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402)
 #define _PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L)
 #define _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT                                                                         \
     (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L)
 

pstl/test/std/algorithms/alg.merge/inplace_merge.pass.cpp

 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
     void
-    operator()(pstl::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
+    operator()(std::execution::unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2, BiDirIt1 last2,
                Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
     {
     }
 
     template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2,
+    operator()(std::execution::parallel_unsequenced_policy, BiDirIt1 first1, BiDirIt1 last1, BiDirIt1 first2,
                BiDirIt1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
     {
     }
 #endif
 
     // inplace_merge works with bidirectional iterators at least
     template <typename Policy, typename BiDirIt1, typename Size, typename Generator1, typename Generator2,
               typename Compare>

pstl/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

 using namespace TestUtils;
 
 struct run_copy_if
 {
 #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>
     void
-    operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
                Predicate pred, T trash)
     {
     }
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
                OutputIterator2 expected_last, Size n, Predicate pred, T trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>

pstl/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

 
 struct test_one_policy
 {
     //dummy specialization by policy type, in case of broken configuration
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
 
     template <typename Iterator1, typename Predicate>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
+    operator()(std::execution::unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
     {
     }
     template <typename Iterator1, typename Predicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 begin1, Iterator1 end1, Predicate pred)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Predicate>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 begin1, Iterator1 end1, Predicate pred)
     {

pstl/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

 }
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specializations to skip testing in case of broken configuration
     template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
     void
-    operator()(pstl::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
+    operator()(std::execution::unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
                Size n, UnaryOp unary_op, Generator generator)
     {
     }
 
     template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
+    operator()(std::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
                BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
     {
     }
 #elif _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specializations to skip testing in case of broken configuration
     template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
     void
-    operator()(pstl::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
+    operator()(std::execution::parallel_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last,
                Size n, UnaryOp unary_op, Generator generator)
     {
     }
 
     template <typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
+    operator()(std::execution::parallel_unsequenced_policy, BiDirIt first, BiDirIt last, BiDirIt exp_first,
                BiDirIt exp_last, Size n, UnaryOp unary_op, Generator generator)
     {
     }
 #endif
 
     template <typename Policy, typename BiDirIt, typename Size, typename UnaryOp, typename Generator>
     typename std::enable_if<!is_same_iterator_category<BiDirIt, std::forward_iterator_tag>::value, void>::type
     operator()(Policy&& exec, BiDirIt first, BiDirIt last, BiDirIt exp_first, BiDirIt exp_last, Size n,

pstl/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first,
                         std::count_if(first, last, __pstl::__internal::__not_pred<UnaryOp>(unary_op)),
                     "partition_copy has wrong effect from false sequence");
     }
 
     //dummy specialization by iterator type and policy type, in case of broken configuration
 #if _PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
     void
-    operator()(pstl::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first,
+    operator()(std::execution::unsequenced_policy, std::reverse_iterator<InputIterator> first,
                std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
                std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
                OutputIterator2 false_last, UnaryOp unary_op)
     {
     }
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename UnaryOp>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, std::reverse_iterator<InputIterator> first,
+    operator()(std::execution::parallel_unsequenced_policy, std::reverse_iterator<InputIterator> first,
                std::reverse_iterator<InputIterator> last, std::reverse_iterator<OutputIterator> true_first,
                std::reverse_iterator<OutputIterator> true_last, std::reverse_iterator<OutputIterator2> false_first,
                OutputIterator2 false_last, UnaryOp unary_op)
     {
     }
 #endif
 };
 

pstl/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp

 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||     \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e)
     {
     }
     template <typename Iterator1, typename Iterator2>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
     typename std::enable_if<!is_same_iterator_category<Iterator1, std::forward_iterator_tag>::value>::type
     operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e)

pstl/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

struct test_one_policy
     Iterator data_b;
     Iterator data_e;
     test_one_policy(Iterator b, Iterator e) : data_b(b), data_e(e) {}
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
+    operator()(std::execution::unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
     {
     }
     template <typename Iterator1>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 actual_b, Iterator1 actual_e)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 actual_b, Iterator1 actual_e)
     {

pstl/test/std/algorithms/alg.modifying.operations/copy_move.pass.cpp

 
 struct run_copy
 {
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
                Size n, T trash)
     {
     }
 
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size, typename T>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
                OutputIterator2 expected_last, Size size, Size n, T trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename T>

 template <typename T>
 struct run_move
 {
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
                Size n, T trash)
     {
     }
 
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
                OutputIterator2 expected_last, Size size, Size n, T trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void

 template <typename T>
 struct run_move<Wrapper<T>>
 {
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size size,
                Size n, Wrapper<T> trash)
     {
     }
 
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
                OutputIterator2 expected_last, Size size, Size n, Wrapper<T> trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size>
     void

pstl/test/std/algorithms/alg.modifying.operations/remove.pass.cpp

 using namespace TestUtils;
 
 struct run_remove
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename Size, typename T>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
                const T& value)
     {
     }
     template <typename InputIterator, typename OutputIterator, typename Size, typename T>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first,
                OutputIterator expected_last, Size n, const T& value)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename T>
     void

 };
 
 struct run_remove_if
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
                Predicate pred)
     {
     }
     template <typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator expected_first,
                OutputIterator expected_last, Size n, Predicate pred)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename Predicate>
     void

pstl/test/std/algorithms/alg.modifying.operations/rotate.pass.cpp

 
 struct test_one_policy
 {
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specializations to skip testing in case of broken configuration
     template <typename Iterator, typename Size>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
+    operator()(std::execution::unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
                Iterator actual_e, Size shift)
     {
     }
     template <typename Iterator, typename Size>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator data_b, Iterator data_e, Iterator actual_b,
                Iterator actual_e, Size shift)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator, typename Size>
     void
     operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e,
operator()(ExecutionPolicy&& exec, Iterator data_b, Iterator data_e, Iterator actual_b, Iterator actual_e,
 
         EXPECT_TRUE(check, "wrong effect of rotate");
         EXPECT_TRUE(check_move(exec, actual_b, actual_e, shift), "wrong move test of rotate");
     }
 
     template <typename ExecutionPolicy, typename Iterator, typename Size>
     typename std::enable_if<
         is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
-            !std::is_same<ExecutionPolicy, pstl::execution::sequenced_policy>::value &&
+            !std::is_same<ExecutionPolicy, std::execution::sequenced_policy>::value &&
             std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value,
         bool>::type
     check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift)
     {
         bool result = all_of(b, e, [](wrapper<float32_t>& a) {
             bool temp = a.move_count > 0;
             a.move_count = 0;
             return temp;
         });
         return shift == 0 || result;
     }
 
     template <typename ExecutionPolicy, typename Iterator, typename Size>
     typename std::enable_if<
         !(is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
-          !std::is_same<ExecutionPolicy, pstl::execution::sequenced_policy>::value &&
+          !std::is_same<ExecutionPolicy, std::execution::sequenced_policy>::value &&
           std::is_same<typename std::iterator_traits<Iterator>::value_type, wrapper<float32_t>>::value),
         bool>::type
     check_move(ExecutionPolicy&& exec, Iterator b, Iterator e, Size shift)
     {
         return true;
     }
 };
 

pstl/test/std/algorithms/alg.modifying.operations/rotate_copy.pass.cpp

 
 struct test_one_policy
 {
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e, std::size_t shift)
     {
     }
     template <typename Iterator1, typename Iterator2>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e, std::size_t shift)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,

pstl/test/std/algorithms/alg.modifying.operations/unique.pass.cpp

 using namespace TestUtils;
 
 struct run_unique
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename ForwardIt, typename Generator>
     void
-    operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+    operator()(std::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
                ForwardIt last2, Generator generator)
     {
     }
 
     template <typename ForwardIt, typename Generator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+    operator()(std::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
                ForwardIt last2, Generator generator)
     {
     }
 
     template <typename ForwardIt, typename BinaryPred, typename Generator>
     void
-    operator()(pstl::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+    operator()(std::execution::unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
                ForwardIt last2, BinaryPred pred, Generator generator)
     {
     }
 
     template <typename ForwardIt, typename BinaryPred, typename Generator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
+    operator()(std::execution::parallel_unsequenced_policy, ForwardIt first1, ForwardIt last1, ForwardIt first2,
                ForwardIt last2, BinaryPred pred, Generator generator)
     {
     }
 #endif
 
     template <typename Policy, typename ForwardIt, typename Generator>
     void
     operator()(Policy&& exec, ForwardIt first1, ForwardIt last1, ForwardIt first2, ForwardIt last2, Generator generator)

pstl/test/std/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp

 using namespace TestUtils;
 
 struct run_unique_copy
 {
 #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>
     void
-    operator()(pstl::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::parallel_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator2 expected_first, OutputIterator2 expected_last, Size n,
                Predicate pred, T trash)
     {
     }
 
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, OutputIterator out_last, OutputIterator2 expected_first,
                OutputIterator2 expected_last, Size n, Predicate pred, T trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>

pstl/test/std/algorithms/alg.nonmodifying/find.pass.cpp

 using namespace TestUtils;
 
 struct test_find
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Value>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Value value)
+    operator()(std::execution::unsequenced_policy, Iterator first, Iterator last, Value value)
     {
     }
     template <typename Iterator, typename Value>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value)
+    operator()(std::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Value value)
     {
     }
 #endif
 
     template <typename Policy, typename Iterator, typename Value>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, Value value)
     {

pstl/test/std/algorithms/alg.nonmodifying/find_end.pass.cpp

 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2, typename Predicate>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+    operator()(std::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
                Predicate pred)
     {
     }
     template <typename Iterator1, typename Iterator2, typename Predicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
                Predicate pred)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred)

pstl/test/std/algorithms/alg.nonmodifying/find_first_of.pass.cpp

 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2, typename Predicate>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+    operator()(std::execution::unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
                Predicate pred)
     {
     }
     template <typename Iterator1, typename Iterator2, typename Predicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub,
                Predicate pred)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 b, Iterator1 e, Iterator2 bsub, Iterator2 esub, Predicate pred)

pstl/test/std/algorithms/alg.nonmodifying/find_if.pass.cpp

 using namespace TestUtils;
 
 struct test_find_if
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Predicate, typename NotPredicate>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred,
+    operator()(std::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred,
                NotPredicate not_pred)
     {
     }
     template <typename Iterator, typename Predicate, typename NotPredicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred,
                NotPredicate not_pred)
     {
     }
 #endif
 
     template <typename Policy, typename Iterator, typename Predicate, typename NotPredicate>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred, NotPredicate not_pred)

pstl/test/std/algorithms/alg.nonmodifying/for_each.pass.cpp

operator()(Policy&& exec, Iterator first, Iterator last, Iterator expected_first, Iterator expected_last, Size n)
         typedef typename std::iterator_traits<Iterator>::value_type T;
 
         // Try for_each
         std::for_each(expected_first, expected_last, Flip<T>(1));
         for_each(exec, first, last, Flip<T>(1));
         EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each");
 
         // Try for_each_n
-        std::for_each_n(pstl::execution::seq, expected_first, n, Flip<T>(1));
+        std::for_each_n(std::execution::seq, expected_first, n, Flip<T>(1));
         for_each_n(exec, first, n, Flip<T>(1));
         EXPECT_EQ_N(expected_first, first, n, "wrong effect from for_each_n");
     }
 };
 
 template <typename T>
 void
 test()

pstl/test/std/algorithms/alg.nonmodifying/mismatch.pass.cpp

struct test_mismatch
     }
     template <typename Policy, typename Iterator1, typename Iterator2>
     void
     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
     {
         using namespace std;
         typedef typename iterator_traits<Iterator1>::value_type T;
         {
-            const auto expected = mismatch(pstl::execution::seq, first1, last1, first2, last2, std::equal_to<T>());
+            const auto expected = mismatch(std::execution::seq, first1, last1, first2, last2, std::equal_to<T>());
             const auto res1 = mismatch(exec, first1, last1, first2, last2, std::equal_to<T>());
             EXPECT_TRUE(expected == res1, "wrong return result from mismatch");
             const auto res2 = mismatch(exec, first1, last1, first2, last2);
             EXPECT_TRUE(expected == res2, "wrong return result from mismatch");
         }
     }
 };
 

pstl/test/std/algorithms/alg.nonmodifying/nth_element.pass.cpp

 }
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
+    operator()(std::execution::unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
     {
     }
     template <typename Iterator1, typename Size, typename Generator1, typename Generator2, typename Compare>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 first1, Iterator1 last1, Iterator1 first2,
                Iterator1 last2, Size n, Size m, Generator1 generator1, Generator2 generator2, Compare comp)
     {
     }
 #endif
 
     // nth_element works only with random access iterators
     template <typename Policy, typename Iterator1, typename Size, typename Generator1, typename Generator2,
               typename Compare>

pstl/test/std/algorithms/alg.nonmodifying/search_n.pass.cpp

 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Size, typename T, typename Predicate>
     void
-    operator()(pstl::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
+    operator()(std::execution::unsequenced_policy, Iterator b, Iterator e, Size count, const T& value, Predicate pred)
     {
     }
     template <typename Iterator, typename Size, typename T, typename Predicate>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator b, Iterator e, Size count, const T& value,
                Predicate pred)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator, typename Size, typename T, typename Predicate>
     void
     operator()(ExecutionPolicy&& exec, Iterator b, Iterator e, Size count, const T& value, Predicate pred)

pstl/test/std/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp

 };
 
 struct test_is_heap
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Predicate>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred)
+    operator()(std::execution::unsequenced_policy, Iterator first, Iterator last, Predicate pred)
     {
     }
     template <typename Iterator, typename Predicate>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred)
+    operator()(std::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Predicate pred)
     {
     }
 #endif
 
     template <typename Policy, typename Iterator, typename Predicate>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
     operator()(Policy&& exec, Iterator first, Iterator last, Predicate pred)
     {

pstl/test/std/algorithms/alg.sorting/partial_sort_copy.pass.cpp

struct test_one_policy
     test_one_policy(RandomAccessIterator b1, RandomAccessIterator e1, RandomAccessIterator b2, RandomAccessIterator e2)
         : d_first(b1), d_last(e1), exp_first(b2), exp_last(e2)
     {
     }
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename Size, typename T, typename Compare>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
                const T& trash, Compare compare)
     {
     }
 
     template <typename InputIterator, typename Size, typename T, typename Compare>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
                const T& trash, Compare compare)
     {
     }
 
     template <typename InputIterator, typename Size, typename T>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
                const T& trash)
     {
     }
 
     template <typename InputIterator, typename Size, typename T>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last, Size n1, Size n2,
                const T& trash)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename Size, typename T, typename Compare>
     void
     operator()(Policy&& exec, InputIterator first, InputIterator last, Size n1, Size n2, const T& trash,

pstl/test/std/numerics/numeric.ops/adjacent_difference.pass.cpp

 }
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2, typename T, typename Function>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e, T trash, Function f)
     {
     }
     template <typename Iterator1, typename Iterator2, typename T, typename Function>
     typename std::enable_if<is_same_iterator_category<Iterator1, std::random_access_iterator_tag>::value, void>::type
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
+    operator()(std::execution::parallel_unsequenced_policy, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b,
                Iterator2 actual_e, T trash, Function f)
     {
     }
 #endif
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename T, typename Function>
     void
     operator()(ExecutionPolicy&& exec, Iterator1 data_b, Iterator1 data_e, Iterator2 actual_b, Iterator2 actual_e,

pstl/test/std/numerics/numeric.ops/reduce.pass.cpp

 }
 
 struct test_two_short_forms
 {
 
 #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator>
     void
-    operator()(pstl::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected)
+    operator()(std::execution::parallel_policy, Iterator first, Iterator last, Sum init, Sum expected)
     {
     }
     template <typename Iterator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected)
+    operator()(std::execution::parallel_unsequenced_policy, Iterator first, Iterator last, Sum init, Sum expected)
     {
     }
 #endif
 
     template <typename Policy, typename Iterator>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, Sum init, Sum expected)
     {

pstl/test/std/numerics/numeric.ops/transform_scan.pass.cpp

template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
               typename T, typename BinaryOp>
     typename std::enable_if<!TestUtils::isReverse<InputIterator>::value, void>::type
     operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first,
                OutputIterator out_last, OutputIterator expected_first, OutputIterator expected_last, Size n,
                UnaryOp unary_op, T init, BinaryOp binary_op, T trash)
     {
         using namespace std;
 
-        auto orr1 = inclusive ? transform_inclusive_scan(pstl::execution::seq, first, last, expected_first, binary_op,
+        auto orr1 = inclusive ? transform_inclusive_scan(std::execution::seq, first, last, expected_first, binary_op,
                                                          unary_op, init)
-                              : transform_exclusive_scan(pstl::execution::seq, first, last, expected_first, init,
+                              : transform_exclusive_scan(std::execution::seq, first, last, expected_first, init,
                                                          binary_op, unary_op);
         auto orr2 = inclusive ? transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op, init)
                               : transform_exclusive_scan(exec, first, last, out_first, init, binary_op, unary_op);
         EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
         check_and_reset(expected_first, out_first, n, trash);
 
         // Checks inclusive scan if init is not provided
         if (inclusive && n > 0)
         {
-            orr1 = transform_inclusive_scan(pstl::execution::seq, first, last, expected_first, binary_op, unary_op);
+            orr1 = transform_inclusive_scan(std::execution::seq, first, last, expected_first, binary_op, unary_op);
             orr2 = transform_inclusive_scan(exec, first, last, out_first, binary_op, unary_op);
             EXPECT_TRUE(out_last == orr2, "transform...scan returned wrong iterator");
             check_and_reset(expected_first, out_first, n, trash);
         }
     }
 
     template <typename Policy, typename InputIterator, typename OutputIterator, typename Size, typename UnaryOp,
               typename T, typename BinaryOp>

pstl/test/std/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp

operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n,
         std::uninitialized_move_n(exec, first, n, out_first);
         EXPECT_TRUE(T::MoveCount() == n, "wrong uninitialized_move_n");
         std::destroy_n(exec, out_first, n);
     }
 
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || _PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
     template <typename InputIterator, typename OutputIterator>
     void
-    operator()(pstl::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
+    operator()(std::execution::unsequenced_policy, InputIterator first, InputIterator last, OutputIterator out_first,
                size_t n, /*is_trivial<T>=*/std::true_type)
     {
     }
     template <typename InputIterator, typename OutputIterator>
     void
-    operator()(pstl::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
+    operator()(std::execution::parallel_unsequenced_policy, InputIterator first, InputIterator last,
                OutputIterator out_first, size_t n, /*is_trivial<T>=*/std::true_type)
     {
     }
 #endif
 
     template <typename Policy, typename InputIterator, typename OutputIterator>
     void
     operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator out_first, size_t n,

pstl/test/support/stdlib/execution

 #if _PSTL_MEMORY_FORWARD_DECLARED
 #    include <pstl/internal/glue_memory_impl.h>
 #endif
 
 #if _PSTL_NUMERIC_FORWARD_DECLARED
 #    include <pstl/internal/glue_numeric_impl.h>
 #endif
 
-#if _PSTL_CPP17_EXECUTION_POLICIES_PRESENT
-_PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
-#else
-#    include <pstl/internal/glue_execution_defs.h>
-_PSTL_PRAGMA_MESSAGE_POLICIES(
-    "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
-#endif
-
-//TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
-// standard C++ library
-namespace pstl
-{
-namespace execution
-{
-using namespace __pstl::execution;
-}
-} // namespace pstl
+#include <pstl/internal/glue_execution_defs.h>
 
 #endif /* _TEST_SUPPORT_STDLIB_EXECUTION */