libcxx/include/execution

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_EXECUTION
  11 #define _LIBCPP_EXECUTION
  12
  13 /*
  14 namespace std::execution {
  15   struct sequenced_policy;
  16   struct parallel_policy;
  17   struct parallel_unsequenced_policy;
  18   struct unsequenced_policy; // since C++20
  19
  20   inline constexpr sequenced_policy seq = implementation-defined;
  21   inline constexpr parallel_policy par = implementation-defined;
  22   inline constexpr parallel_unsequenced_policy par_unseq = implementation-defined;
  23   inline constexpr unsequenced_policy unseq = implementation-defined; // since C++20
  24 }
  25
  26 namespace std {
  27   template <class T>
  28   struct is_execution_policy;
  29
  30   template <class T>
  31   inline constexpr bool is_execution_policy_v;
  32 }
  33 */
  34
  35 #include <__assert> // all public C++ headers provide the assertion handler
  36 #include <__config>
  37 #include <__type_traits/is_execution_policy.h>
  38 #include <__type_traits/is_same.h>
  39 #include <__type_traits/remove_cvref.h>
  40 #include <version>
  41
  42 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  43 #  pragma GCC system_header
  44 #endif
  45
  46 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
  47
  48 _LIBCPP_BEGIN_NAMESPACE_STD
  49
  50 namespace execution {
  51 struct sequenced_policy {
  52   _LIBCPP_HIDE_FROM_ABI constexpr explicit sequenced_policy(__disable_user_instantiations_tag) {}
  53   sequenced_policy(const sequenced_policy&)            = delete;
  54   sequenced_policy& operator=(const sequenced_policy&) = delete;
  55 };
  56
  57 inline constexpr sequenced_policy seq{__disable_user_instantiations_tag{}};
  58
  59 struct parallel_policy {
  60   _LIBCPP_HIDE_FROM_ABI constexpr explicit parallel_policy(__disable_user_instantiations_tag) {}
  61   parallel_policy(const parallel_policy&)            = delete;
  62   parallel_policy& operator=(const parallel_policy&) = delete;
  63 };
  64
  65 inline constexpr parallel_policy par{__disable_user_instantiations_tag{}};
  66
  67 struct parallel_unsequenced_policy {
  68   _LIBCPP_HIDE_FROM_ABI constexpr explicit parallel_unsequenced_policy(__disable_user_instantiations_tag) {}
  69   parallel_unsequenced_policy(const parallel_unsequenced_policy&)            = delete;
  70   parallel_unsequenced_policy& operator=(const parallel_unsequenced_policy&) = delete;
  71 };
  72
  73 inline constexpr parallel_unsequenced_policy par_unseq{__disable_user_instantiations_tag{}};
  74
  75 struct __unsequenced_policy {
  76   _LIBCPP_HIDE_FROM_ABI constexpr explicit __unsequenced_policy(__disable_user_instantiations_tag) {}
  77   __unsequenced_policy(const __unsequenced_policy&)            = delete;
  78   __unsequenced_policy& operator=(const __unsequenced_policy&) = delete;
  79 };
  80
  81 constexpr __unsequenced_policy __unseq{__disable_user_instantiations_tag{}};
  82
  83 #  if _LIBCPP_STD_VER >= 20
  84
  85 struct unsequenced_policy {
  86   _LIBCPP_HIDE_FROM_ABI constexpr explicit unsequenced_policy(__disable_user_instantiations_tag) {}
  87   unsequenced_policy(const unsequenced_policy&)            = delete;
  88   unsequenced_policy& operator=(const unsequenced_policy&) = delete;
  89 };
  90
  91 inline constexpr unsequenced_policy unseq{__disable_user_instantiations_tag{}};
  92
  93 #  endif // _LIBCPP_STD_VER >= 20
  94
  95 } // namespace execution
  96
  97 template <>
  98 inline constexpr bool is_execution_policy_v<execution::sequenced_policy> = true;
  99
 100 template <>
 101 inline constexpr bool is_execution_policy_v<execution::parallel_policy> = true;
 102
 103 template <>
 104 inline constexpr bool is_execution_policy_v<execution::parallel_unsequenced_policy> = true;
 105
 106 template <>
 107 inline constexpr bool is_execution_policy_v<execution::__unsequenced_policy> = true;
 108
 109 template <>
 110 inline constexpr bool __is_parallel_execution_policy_impl<execution::parallel_policy> = true;
 111
 112 template <>
 113 inline constexpr bool __is_parallel_execution_policy_impl<execution::parallel_unsequenced_policy> = true;
 114
 115 template <>
 116 inline constexpr bool __is_unsequenced_execution_policy_impl<execution::__unsequenced_policy> = true;
 117
 118 template <>
 119 inline constexpr bool __is_unsequenced_execution_policy_impl<execution::parallel_unsequenced_policy> = true;
 120
 121 #  if _LIBCPP_STD_VER >= 20
 122 template <>
 123 inline constexpr bool is_execution_policy_v<execution::unsequenced_policy> = true;
 124
 125 template <>
 126 inline constexpr bool __is_unsequenced_execution_policy_impl<execution::unsequenced_policy> = true;
 127
 128 #  endif
 129
 130 template <class _Tp>
 131 struct is_execution_policy : bool_constant<is_execution_policy_v<_Tp>> {};
 132
 133 template <class _ExecutionPolicy>
 134 _LIBCPP_HIDE_FROM_ABI auto __remove_parallel_policy(const _ExecutionPolicy&) {
 135   if constexpr (is_same_v<_ExecutionPolicy, execution::parallel_policy>) {
 136     return execution::sequenced_policy(execution::__disable_user_instantiations_tag{});
 137   } else if constexpr (is_same_v<_ExecutionPolicy, execution::parallel_unsequenced_policy>) {
 138     return execution::__unsequenced_policy{execution::__disable_user_instantiations_tag{}};
 139   }
 140 }
 141
 142 _LIBCPP_END_NAMESPACE_STD
 143
 144 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 145
 146 #endif // _LIBCPP_EXECUTION