[libc++][PSTL] Make the PSTL available by default under -fexperimental-library

[philnik]

Summary

This removes the need for a custom libc++ build to have a basic set of PSTL algorithms.

[philnik]

Rebased

[philnik]

Try to fix CI

[ldionne]

libcxx/include/__algorithm/pstl_for_each.h

72

Here and everywhere else, I think you mean defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL)

libcxx/utils/libcxx/test/params.py

183–184

Fly-by comment: we should try to change this to -fexperimental-library when using Clang now. On GCC we still need to do it manually.

IMO it would be good to actually change it because otherwise we're not testing the way we expect our users to enable this mode.

[ldionne]

LGTM w/ green CI and the few comments I left.

[philnik]

Try to fix CI

[philnik]

• Reabsed
• Try to fix CI

[philnik]

Format

[philnik]

More fixes

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Next try

libcxx/CMakeLists.txt

if (WIN32 AND NOT MINGW)
   # functions, that currently are provided by libgcc or compiler_rt builtins.
   # These are available in MinGW environments, but not currently in MSVC
   # environments.
   set(ENABLE_FILESYSTEM_DEFAULT OFF)
 endif()
 option(LIBCXX_ENABLE_FILESYSTEM "Build filesystem as part of the main libc++ library"
     ${ENABLE_FILESYSTEM_DEFAULT})
 option(LIBCXX_INCLUDE_TESTS "Build the libc++ tests." ${LLVM_INCLUDE_TESTS})
-option(LIBCXX_ENABLE_PARALLEL_ALGORITHMS "Enable the parallel algorithms library. This requires the PSTL to be available." OFF)
 option(LIBCXX_ENABLE_DEBUG_MODE
   "Whether to build libc++ with the debug mode enabled.
    By default, this is turned off. Turning it on results in a different ABI (additional
    symbols but also potentially different layouts of types), and one should not mix code
    built against a dylib that has debug mode and code built against a regular dylib." OFF)
 option(LIBCXX_ENABLE_RANDOM_DEVICE
   "Whether to include support for std::random_device in the library. Disabling
    this can be useful when building the library for platforms that don't have
if (NOT LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION STREQUAL "default")
   config_define("${LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION}" _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION)
 endif()
 config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_HAS_WIN32_THREAD_API _LIBCPP_HAS_THREAD_API_WIN32)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
-config_define_if(LIBCXX_ENABLE_PARALLEL_ALGORITHMS _LIBCPP_HAS_PARALLEL_ALGORITHMS)
 config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
 config_define_if_not(LIBCXX_ENABLE_FSTREAM _LIBCPP_HAS_NO_FSTREAM)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 config_define_if(LIBCXX_ENABLE_DEBUG_MODE _LIBCPP_ENABLE_DEBUG_MODE)

libcxx/cmake/caches/With-pstl.cmake

-# TODO: Remove this cache file once the PSTL is under `-fexperimental-library`
-set(LIBCXX_TEST_PARAMS "std=c++17" CACHE STRING "")
-set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")
-set(LIBCXX_ENABLE_PARALLEL_ALGORITHMS ON CACHE BOOL "")

libcxx/include/__algorithm/pstl_any_all_none_of.h

 
 #include <__algorithm/any_of.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__pstl/internal/parallel_impl.h>
 #include <__pstl/internal/unseq_backend_simd.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_execution_policy.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if _LIBCPP_STD_VER >= 17
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ExecutionPolicy,
           class _ForwardIterator,
           class _Predicate,
           enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI bool
template <class _ExecutionPolicy,
           enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI bool
 none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
   return !std::any_of(__policy, __first, __last, __pred);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 17
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___ALGORITHM_PSTL_ANY_ALL_NONE_OF_H

libcxx/include/__algorithm/pstl_fill.h

 #define _LIBCPP___ALGORITHM_PSTL_FILL_H
 
 #include <__algorithm/fill.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__pstl/internal/parallel_impl.h>
 #include <__pstl/internal/unseq_backend_simd.h>
 #include <__type_traits/is_execution_policy.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if _LIBCPP_STD_VER >= 17
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ExecutionPolicy,
           class _ForwardIterator,
           class _Tp,
           enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI void
fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _SizeT __n, const _Tp& __value) {
   if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value)
     std::fill(__policy, __first, __first + __n, __value);
   else
     std::fill_n(__first, __n, __value);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 17
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___ALGORITHM_PSTL_FILL_H

libcxx/include/__algorithm/pstl_find.h

 #define _LIBCPP___ALGORITHM_PSTL_FIND_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/find.h>
 #include <__config>
 #include <__pstl/internal/parallel_impl.h>
 #include <__pstl/internal/unseq_backend_simd.h>
 #include <__type_traits/is_execution_policy.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ExecutionPolicy,
           class _ForwardIterator,
           class _Tp,
           enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {

 find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
   return std::find_if(__policy, __first, __last, [&](__iter_reference<_ForwardIterator> __value) {
     return !__pred(__value);
   });
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif // _LIBCPP___ALGORITHM_PSTL_FIND_H

libcxx/include/__algorithm/pstl_for_each.h

 
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__pstl/internal/parallel_backend.h>
 #include <__pstl/internal/unseq_backend_simd.h>
 #include <__type_traits/is_execution_policy.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/terminate_on_exception.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ExecutionPolicy,
           class _ForwardIterator,
           class _Function,
           enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI void
if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value) {
     std::for_each(__policy, __first, __first + __size, __func);
   } else {
     std::for_each_n(__first, __size, __func);
   }
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___ALGORITHM_PSTL_FOR_EACH_H

libcxx/include/__config

 #      define _LIBCPP_ENABLE_EXPERIMENTAL
 #    endif
 #  endif
 
 // Incomplete features get their own specific disabling flags. This makes it
 // easier to grep for target specific flags once the feature is complete.
 #  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #    define _LIBCPP_HAS_NO_INCOMPLETE_FORMAT
+#    define _LIBCPP_HAS_NO_INCOMPLETE_PSTL
 #  endif
 
 // Need to detect which libc we're using if we're on Linux.
 #  if defined(__linux__)
 #    include <features.h>
 #    if defined(__GLIBC_PREREQ)
 #      define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
 #    else

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL
 #cmakedefine _LIBCPP_HAS_THREAD_API_WIN32
 #cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
 #cmakedefine _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
-#cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 #cmakedefine _LIBCPP_HAS_NO_FSTREAM
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
 #cmakedefine _LIBCPP_ENABLE_DEBUG_MODE
 
 // __USE_MINGW_ANSI_STDIO gets redefined on MinGW

libcxx/include/__pstl/internal/execution_defs.h

 #define _PSTL_EXECUTION_POLICY_DEFS_H
 
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 
 #include "pstl_config.h"
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl {
 namespace execution {
 inline namespace v1 {
 
 // 2.4, Sequential execution policy
 class sequenced_policy {};
 
 // 2.5, Parallel execution policy

 struct __serial_tag;
 template <class _IsVector>
 struct __parallel_tag;
 
 } // namespace __internal
 
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_EXECUTION_POLICY_DEFS_H */

libcxx/include/__pstl/internal/execution_impl.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_EXECUTION_IMPL_H
 #define _PSTL_EXECUTION_IMPL_H
 
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/is_base_of.h>
 
 #include "execution_defs.h"
 #include "pstl_config.h"
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl {
 namespace __internal {
 
 template <typename _IteratorTag, typename... _IteratorTypes>
 using __are_iterators_of = std::conjunction<
     std::is_base_of<_IteratorTag, typename std::iterator_traits<std::decay_t<_IteratorTypes>>::iterator_category>...>;
 
 template <typename... _IteratorTypes>
 using __are_random_access_iterators = __are_iterators_of<std::random_access_iterator_tag, _IteratorTypes...>;
 
 struct __serial_backend_tag {};
 struct __tbb_backend_tag {};
 struct __openmp_backend_tag {};
 
-#if defined(_PSTL_PAR_BACKEND_TBB)
+#  if defined(_PSTL_PAR_BACKEND_TBB)
 using __par_backend_tag = __tbb_backend_tag;
-#elif defined(_PSTL_PAR_BACKEND_OPENMP)
+#  elif defined(_PSTL_PAR_BACKEND_OPENMP)
 using __par_backend_tag = __openmp_backend_tag;
-#elif defined(_PSTL_PAR_BACKEND_SERIAL)
+#  elif defined(_PSTL_PAR_BACKEND_SERIAL)
 using __par_backend_tag = __serial_backend_tag;
-#else
-#  error "A parallel backend must be specified";
-#endif
+#  else
+#    error "A parallel backend must be specified";
+#  endif
 
 template <class _IsVector>
 struct __serial_tag {
   using __is_vector = _IsVector;
 };
 
 template <class _IsVector>
 struct __parallel_tag {

 _LIBCPP_HIDE_FROM_ABI __tag_type<__internal::__are_random_access_iterators<_IteratorTypes...>, _IteratorTypes...>
 __select_backend(__pstl::execution::parallel_unsequenced_policy, _IteratorTypes&&...) {
   return {};
 }
 
 } // namespace __internal
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_EXECUTION_IMPL_H */

libcxx/include/__pstl/internal/parallel_backend.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_PARALLEL_BACKEND_H
 #define _PSTL_PARALLEL_BACKEND_H
 
 #include "pstl_config.h"
 
 #if defined(_PSTL_PAR_BACKEND_SERIAL)
 #    include "parallel_backend_serial.h"
+#    if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 namespace __pstl
 {
 namespace __par_backend = __serial_backend;
 } // namespace __pstl
+#    endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 #elif defined(_PSTL_PAR_BACKEND_TBB)
 #    include "parallel_backend_tbb.h"
 namespace __pstl
 {
 namespace __par_backend = __tbb_backend;
 }
 #elif defined(_PSTL_PAR_BACKEND_OPENMP)
 #    include "parallel_backend_omp.h"

libcxx/include/__pstl/internal/parallel_backend_serial.h

 #define _PSTL_PARALLEL_BACKEND_SERIAL_H
 
 #include <__memory/allocator.h>
 #include <__pstl/internal/execution_impl.h>
 #include <__utility/forward.h>
 
 #include "pstl_config.h"
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl
 {
 namespace __serial_backend
 {
 
 template <typename _Tp>
 class __buffer
 {

 {
     std::forward<_F1>(__f1)();
     std::forward<_F2>(__f2)();
 }
 
 } // namespace __serial_backend
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_PARALLEL_BACKEND_SERIAL_H */

libcxx/include/__pstl/internal/parallel_impl.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_PARALLEL_IMPL_H
 #define _PSTL_PARALLEL_IMPL_H
 
 #include "pstl_config.h"
 
 #include <__atomic/atomic.h>
+#include <__atomic/memory_order.h>
 #include <__pstl/internal/parallel_backend.h>
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl
 {
 namespace __internal
 {
 
 //------------------------------------------------------------------------
 // parallel_find
 //-----------------------------------------------------------------------
__par_backend::__parallel_for(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                       }
                                   });
     return __found;
 }
 
 } // namespace __internal
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_PARALLEL_IMPL_H */

libcxx/include/__pstl/internal/unseq_backend_simd.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _PSTL_UNSEQ_BACKEND_SIMD_H
 #define _PSTL_UNSEQ_BACKEND_SIMD_H
 
 #include <__functional/operations.h>
+#include <__type_traits/is_arithmetic.h>
 #include <__utility/pair.h>
+#include <cstddef>
+#include <cstdint>
 
 #include "pstl_config.h"
 #include "utils.h"
 
 // This header defines the minimum set of vector routines required
 // to support parallel STL.
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl
 {
 namespace __unseq_backend
 {
 
 // Expect vector width up to 64 (or 512 bit)
 const std::size_t __lane_size = 64;
 
for (_DifferenceType __i = 1; __i < __n; ++__i)
             ++__cnt;
         }
     }
     return __current + __cnt;
 }
 } // namespace __unseq_backend
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_UNSEQ_BACKEND_SIMD_H */

libcxx/include/__pstl/internal/utils.h

 #ifndef _PSTL_UTILS_H
 #define _PSTL_UTILS_H
 
 #include <__exception/terminate.h>
 #include <__pstl/internal/pstl_config.h>
 #include <__utility/forward.h>
 #include <new>
 
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 namespace __pstl {
 namespace __internal {
 
 template <typename _Fp>
 _LIBCPP_HIDE_FROM_ABI auto __except_handler(_Fp __f) -> decltype(__f()) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) {
   } else {
     return __comp(*__a, *__b) ? __a : __b;
   }
 }
 
 } // namespace __internal
 } // namespace __pstl
 
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
 #endif /* _PSTL_UTILS_H */

libcxx/include/__type_traits/is_execution_policy.h

 inline constexpr bool __is_parallel_execution_policy_impl = false;
 
 template <class _Tp>
 inline constexpr bool __is_parallel_execution_policy_v = __is_parallel_execution_policy_impl<__remove_cvref_t<_Tp>>;
 
 // Removes the "parallel" part of an execution policy.
 // For example, turns par_unseq into unseq, and par into seq.
 template <class _ExecutionPolicy>
-const auto& __remove_parallel_policy(_ExecutionPolicy&&);
+_LIBCPP_HIDE_FROM_ABI const auto& __remove_parallel_policy(_ExecutionPolicy&&);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_EXECUTION_POLICY_H

libcxx/include/algorithm

 #include <__algorithm/nth_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
+#include <__algorithm/pstl_any_all_none_of.h>
+#include <__algorithm/pstl_fill.h>
+#include <__algorithm/pstl_find.h>
+#include <__algorithm/pstl_for_each.h>
 #include <__algorithm/push_heap.h>
 #include <__algorithm/ranges_adjacent_find.h>
 #include <__algorithm/ranges_all_of.h>
 #include <__algorithm/ranges_any_of.h>
 #include <__algorithm/ranges_binary_search.h>
 #include <__algorithm/ranges_clamp.h>
 #include <__algorithm/ranges_copy.h>
 #include <__algorithm/ranges_copy_backward.h>

 #include <__algorithm/stable_sort.h>
 #include <__algorithm/swap_ranges.h>
 #include <__algorithm/transform.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__algorithm/upper_bound.h>
 
-#ifdef _LIBCPP_HAS_PARALLEL_ALGORITHMS
-#  include <__algorithm/pstl_any_all_none_of.h>
-#  include <__algorithm/pstl_fill.h>
-#  include <__algorithm/pstl_find.h>
-#  include <__algorithm/pstl_for_each.h>
-#endif
-
 // standard-mandated includes
 
 // [algorithm.syn]
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/execution

 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cvref.h>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace execution {
 struct __disable_user_instantiations_tag {
   explicit __disable_user_instantiations_tag() = default;
 };
 

 inline constexpr bool __is_unsequenced_execution_policy_impl<execution::unsequenced_policy> = true;
 
 #  endif
 
 template <class _Tp>
 struct is_execution_policy : bool_constant<is_execution_policy_v<_Tp>> {};
 
 template <class _ExecutionPolicy>
-const auto& __remove_parallel_policy(_ExecutionPolicy&&) {
+_LIBCPP_HIDE_FROM_ABI const auto& __remove_parallel_policy(_ExecutionPolicy&&) {
   using _ExecPol = __remove_cvref_t<_ExecutionPolicy>;
   if constexpr (is_same_v<_ExecPol, execution::parallel_policy>) {
     return execution::seq;
   } else if constexpr (is_same_v<_ExecPol, execution::parallel_unsequenced_policy>) {
     return execution::__unseq;
   }
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP_EXECUTION

libcxx/include/module.modulemap.in

module atomic {
     header "atomic"
     export *
 
     module __atomic {
       module aliases             {
         private header "__atomic/aliases.h"
         export atomic
       }
-      module atomic              { private header "__atomic/atomic.h" }
+      module atomic              {
+        private header "__atomic/atomic.h"
+
+        export atomic_base
+      }
       module atomic_base         { private header "__atomic/atomic_base.h" }
       module atomic_flag         { private header "__atomic/atomic_flag.h" }
       module atomic_init         { private header "__atomic/atomic_init.h" }
       module atomic_lock_free    { private header "__atomic/atomic_lock_free.h" }
       module atomic_sync         { private header "__atomic/atomic_sync.h" }
       module check_memory_order  { private header "__atomic/check_memory_order.h" }
       module contention_t        { private header "__atomic/contention_t.h" }
       module cxx_atomic_impl     { private header "__atomic/cxx_atomic_impl.h" }

libcxx/test/libcxx/diagnostics/pstl.nodiscard_extensions.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Check that PSTL algorithms aren't marked [[nodiscard]] when
 // _LIBCPP_DISBALE_NODISCARD_EXT is defined
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_NODISCARD_EXT
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 #include <algorithm>
 #include <execution>
+#include <iterator>
 
 void test() {
   int a[] = {1};
   auto pred = [](auto) { return false; };
   std::all_of(std::execution::par, std::begin(a), std::end(a), pred);
   std::any_of(std::execution::par, std::begin(a), std::end(a), pred);
   std::none_of(std::execution::par, std::begin(a), std::end(a), pred);
 }

libcxx/test/libcxx/diagnostics/pstl.nodiscard_extensions.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Check that PSTL algorithms are marked [[nodiscard]] as a conforming extension
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // UNSUPPORTED: c++03, c++11, c++14
 
 #include <algorithm>
 #include <execution>
+#include <iterator>
 
 void test() {
   int a[] = {1};
   auto pred = [](auto) { return false; };
   std::all_of(std::execution::par, std::begin(a), std::end(a), pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
   std::any_of(std::execution::par, std::begin(a), std::end(a), pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
   std::none_of(std::execution::par, std::begin(a), std::end(a), pred); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }

libcxx/test/libcxx/transitive_includes.sh.cpp

 // This test uses --trace-includes, which is not supported by GCC.
 // UNSUPPORTED: gcc
 
 // This test is not supported when we remove the transitive includes provided for backwards
 // compatibility. When we bulk-remove them, we'll adjust the includes that are expected by
 // this test instead.
 // UNSUPPORTED: transitive-includes-disabled
 
-// FIXME: This should pass with the PSTL enabled
-// XFAIL: with-pstl
-
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.
 #if defined(__DEPRECATED)
 #    undef __DEPRECATED
 #endif
 
 /*
 BEGIN-SCRIPT
 

libcxx/test/libcxx/transitive_includes/cxx03.csv

 algorithm atomic
 algorithm bit
 algorithm climits
 algorithm concepts
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm iterator
 algorithm limits
 algorithm memory
 algorithm new
+algorithm ratio
 algorithm stdexcept
 algorithm type_traits
 algorithm utility
 algorithm version
 any atomic
 any chrono
 any concepts
 any cstddef

libcxx/test/libcxx/transitive_includes/cxx11.csv

 algorithm atomic
 algorithm bit
 algorithm climits
 algorithm concepts
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm iterator
 algorithm limits
 algorithm memory
 algorithm new
+algorithm ratio
 algorithm stdexcept
 algorithm type_traits
 algorithm utility
 algorithm version
 any atomic
 any chrono
 any concepts
 any cstddef

libcxx/test/libcxx/transitive_includes/cxx14.csv

 algorithm atomic
 algorithm bit
 algorithm climits
 algorithm concepts
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm iterator
 algorithm limits
 algorithm memory
 algorithm new
+algorithm ratio
 algorithm stdexcept
 algorithm type_traits
 algorithm utility
 algorithm version
 any atomic
 any chrono
 any concepts
 any cstddef

libcxx/test/libcxx/transitive_includes/cxx17.csv

 algorithm atomic
 algorithm bit
 algorithm climits
 algorithm concepts
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm iterator
 algorithm limits
 algorithm memory
 algorithm new
+algorithm ratio
 algorithm stdexcept
 algorithm type_traits
 algorithm utility
 algorithm version
 any atomic
 any chrono
 any concepts
 any cstddef

libcxx/test/libcxx/transitive_includes/cxx20.csv

 algorithm atomic
 algorithm bit
 algorithm climits
 algorithm concepts
 algorithm cstddef
 algorithm cstdint
 algorithm cstdlib
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm iterator
 algorithm limits
 algorithm memory
 algorithm new
+algorithm ratio
 algorithm stdexcept
 algorithm type_traits
 algorithm utility
 algorithm version
 any atomic
 any concepts
 any cstddef
 any cstdint

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 algorithm climits
 algorithm cstddef
 algorithm cstdint
 algorithm cstring
+algorithm ctime
 algorithm initializer_list
 algorithm iosfwd
 algorithm limits
 algorithm new
+algorithm ratio
 algorithm version
 any cstddef
 any cstdint
 any cstring
 any initializer_list
 any limits
 any new
 any typeinfo

libcxx/test/libcxx/utilities/expol/policies.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure we don't allow copying the execution policies in any way to avoid users relying on it.
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 #include <execution>
 #include <type_traits>
 
 #include "test_macros.h"
 
 static_assert(!std::is_default_constructible_v<std::execution::sequenced_policy>);
 static_assert(!std::is_copy_constructible_v<std::execution::sequenced_policy>);

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/pstl.fill.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // template<class ExecutionPolicy, class ForwardIterator, class T>
 //   void fill(ExecutionPolicy&& exec,
 //             ForwardIterator first, ForwardIterator last, const T& value);
 
 #include <algorithm>
 #include <cassert>
 #include <vector>
void operator()(Policy&& policy) {
     { // check that a large range works
       std::vector<int> a(234, 2);
       std::fill(policy, Iter(std::data(a)), Iter(std::data(a) + std::size(a)), 33);
       assert(std::all_of(std::begin(a), std::end(a), [](int i) { return i == 33; }));
     }
   }
 };
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 struct ThrowOnCopy {
   ThrowOnCopy& operator=(const ThrowOnCopy&) { throw int{}; }
 };
+#endif
 
 int main(int, char**) {
   types::for_each(types::forward_iterator_list<int*>{}, TestIteratorWithPolicies<Test>{});
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   std::set_terminate(terminate_successful);
   ThrowOnCopy a[2];
   try {
     (void)std::fill(std::execution::par, std::begin(a), std::end(a), ThrowOnCopy{});
   } catch (int) {
     assert(false);
   }
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/pstl.fill_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
 //   ForwardIterator fill_n(ExecutionPolicy&& exec,
 //                          ForwardIterator first, Size n, const T& value);
 
 #include <algorithm>
 #include <cassert>
 #include <vector>
void operator()(Policy&& policy) {
     { // check that a large range works
       std::vector<int> a(234, 2);
       std::fill_n(policy, Iter(std::data(a)), std::size(a), 33);
       assert(std::all_of(std::begin(a), std::end(a), [](int i) { return i == 33; }));
     }
   }
 };
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 struct ThrowOnCopy {
   ThrowOnCopy& operator=(const ThrowOnCopy&) { throw int{}; }
 };
+#endif
 
 int main(int, char**) {
   types::for_each(types::forward_iterator_list<int*>{}, TestIteratorWithPolicies<Test>{});
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   std::set_terminate(terminate_successful);
   ThrowOnCopy a[2];
   try {
     (void)std::fill_n(std::execution::par, std::begin(a), std::size(a), ThrowOnCopy{});
   } catch (int) {
     assert(false);
   }
 #endif
 
   return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/pstl.all_of.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Predicate>
 //   bool all_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //               Predicate pred);
 
 #include <algorithm>

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/pstl.any_of.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Predicate>
 //   bool any_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //               Predicate pred);
 
 #include <algorithm>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class T>
 //   ForwardIterator find(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //                        const T& value);
 
 #include <algorithm>
void operator()(Policy&& policy) {
     vec[176] = 5;
     assert(base(std::find(policy, Iter(std::data(vec)), Iter(std::data(vec) + std::size(vec)), 5)) ==
            std::data(vec) + 176);
   }
 };
 
 struct ThrowOnCompare {};
 
+#ifndef TEST_HAS_NO_EXCEPTIONS
 bool operator==(ThrowOnCompare, ThrowOnCompare) { throw int{}; }
+#endif
 
 int main(int, char**) {
   types::for_each(types::forward_iterator_list<int*>{}, TestIteratorWithPolicies<Test>{});
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
   std::set_terminate(terminate_successful);
   ThrowOnCompare a[2];
   try {
     (void)std::find(std::execution::par, std::begin(a), std::end(a), ThrowOnCompare{});
   } catch (int) {
     assert(false);
   }
 #endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Predicate>
 //   ForwardIterator find_if(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //                           Predicate pred);
 
 #include <algorithm>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Predicate>
 //   ForwardIterator find_if_not(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //                               Predicate pred);
 
 #include <algorithm>

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Function>
 //   void for_each(ExecutionPolicy&& exec,
 //                 ForwardIterator first, ForwardIterator last,
 //                 Function f);
 

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/pstl.for_each_n.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
 //   ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
 //                              Function f);
 
 #include <algorithm>

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/pstl.none_of.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: c++03, c++11, c++14
+
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 // <algorithm>
 
 // template<class ExecutionPolicy, class ForwardIterator, class Predicate>
 //   bool none_of(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last,
 //                Predicate pred);
 
 #include <algorithm>

libcxx/test/std/utilities/expol/is_execution_policy.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // template<class T> struct is_execution_policy;
 // template<class T> constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 #include <execution>
 
 #include "test_macros.h"
 
 static_assert(std::is_execution_policy<std::execution::sequenced_policy>::value);
 static_assert(std::is_execution_policy_v<std::execution::sequenced_policy>);
 static_assert(std::is_execution_policy<std::execution::parallel_policy>::value);
 static_assert(std::is_execution_policy_v<std::execution::parallel_policy>);
 static_assert(std::is_execution_policy<std::execution::parallel_unsequenced_policy>::value);
 static_assert(std::is_execution_policy_v<std::execution::parallel_unsequenced_policy>);
 
 #if TEST_STD_VER >= 20
 static_assert(std::is_execution_policy<std::execution::unsequenced_policy>::value);
 static_assert(std::is_execution_policy_v<std::execution::unsequenced_policy>);
 #endif

libcxx/test/std/utilities/expol/policies.compile.pass.cpp

 //
 // inline constexpr sequenced_policy seq = implementation-defined;
 // inline constexpr parallel_policy par = implementation-defined;
 // inline constexpr parallel_unsequenced_policy par_unseq = implementation-defined;
 // inline constexpr unsequenced_policy unseq = implementation-defined; // since C++20
 
 // UNSUPPORTED: c++03, c++11, c++14
 
-// REQUIRES: with-pstl
+// UNSUPPORTED: libcpp-has-no-incomplete-pstl
 
 #include <execution>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class T>
 using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

libcxx/utils/ci/buildkite-pipeline.yml

agents:
       queue: "libcxx-builders"
       os: "linux"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
     timeout_in_minutes: 120
 
-  - label: "With PSTL support"
-    command: "libcxx/utils/ci/run-buildbot with-pstl"
-    artifact_paths:
-      - "**/test-results.xml"
-    env:
-      CC: "clang-${LLVM_HEAD_VERSION}"
-      CXX: "clang++-${LLVM_HEAD_VERSION}"
-    agents:
-      queue: "libcxx-builders"
-      os: "linux"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-    timeout_in_minutes: 120
-
   - label: "With LLVM's libunwind"
     command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     env:
         CC: "clang-${LLVM_HEAD_VERSION}"
         CXX: "clang++-${LLVM_HEAD_VERSION}"

libcxx/utils/ci/run-buildbot

 #
 # Other miscellaneous jobs
 #
 generic-abi-unstable)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-abi-unstable.cmake"
     check-runtimes
 ;;
-with-pstl)
-    clean
-    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/With-pstl.cmake"
-    check-runtimes
-;;
 apple-system)
     clean
 
     arch="$(uname -m)"
     xcrun --sdk macosx                                              \
         ${MONOREPO_ROOT}/libcxx/utils/ci/apple-install-libcxx.sh    \
             --llvm-root ${MONOREPO_ROOT}                            \
             --build-dir ${BUILD_DIR}                                \

libcxx/utils/libcxx/test/features.py

macros = {
   '_LIBCPP_ABI_VERSION': 'libcpp-abi-version',
   '_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY': 'no-filesystem',
   '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'no-random-device',
   '_LIBCPP_HAS_NO_LOCALIZATION': 'no-localization',
   '_LIBCPP_HAS_NO_FSTREAM': 'no-fstream',
   '_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'no-wide-characters',
   '_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode',
   '_LIBCPP_ENABLE_DEBUG_MODE': 'libcpp-has-debug-mode',
-  '_LIBCPP_HAS_PARALLEL_ALGORITHMS': 'with-pstl',
 }
 for macro, feature in macros.items():
   DEFAULT_FEATURES.append(
     Feature(name=lambda cfg, m=macro, f=feature: f + ('={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''),
             when=lambda cfg, m=macro: m in compilerMacros(cfg))
   )
 
 

libcxx/utils/libcxx/test/params.py

Parameter(name='enable_experimental', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests for experimental C++ Library features.",
             actions=lambda experimental: [
               # When linking in MSVC mode via the Clang driver, a -l<foo>
               # maps to <foo>.lib, so we need to use -llibc++experimental here
               # to make it link against the static libc++experimental.lib.
               # We can't check for the feature 'msvc' in available_features
               # as those features are added after processing parameters.
               AddFeature('c++experimental'),
               PrependLinkFlag(lambda cfg: '-llibc++experimental' if _isMSVC(cfg) else '-lc++experimental'),
               AddCompileFlag('-D_LIBCPP_ENABLE_EXPERIMENTAL'),
             ] if experimental else [
               AddFeature('libcpp-has-no-incomplete-format'),
+              AddFeature('libcpp-has-no-incomplete-pstl'),
             ]),
 
   Parameter(name='long_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",
             actions=lambda enabled: [] if not enabled else [
               AddFeature('long_tests')
             ]),