1  // -*- C++ -*-
       2  //===-- execution_defs.h --------------------------------------------------===//
       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 _PSTL_EXECUTION_POLICY_DEFS_H
      11  #define _PSTL_EXECUTION_POLICY_DEFS_H
      12  
      13  #include <type_traits>
      14  
      15  namespace __pstl
      16  {
      17  namespace execution
      18  {
      19  inline namespace v1
      20  {
      21  
      22  // 2.4, Sequential execution policy
      23  class sequenced_policy
      24  {
      25    public:
      26      // For internal use only
      27      static constexpr std::false_type
      28      __allow_unsequenced()
      29      {
      30          return std::false_type{};
      31      }
      32      static constexpr std::false_type
      33      __allow_vector()
      34      {
      35          return std::false_type{};
      36      }
      37      static constexpr std::false_type
      38      __allow_parallel()
      39      {
      40          return std::false_type{};
      41      }
      42  };
      43  
      44  // 2.5, Parallel execution policy
      45  class parallel_policy
      46  {
      47    public:
      48      // For internal use only
      49      static constexpr std::false_type
      50      __allow_unsequenced()
      51      {
      52          return std::false_type{};
      53      }
      54      static constexpr std::false_type
      55      __allow_vector()
      56      {
      57          return std::false_type{};
      58      }
      59      static constexpr std::true_type
      60      __allow_parallel()
      61      {
      62          return std::true_type{};
      63      }
      64  };
      65  
      66  // 2.6, Parallel+Vector execution policy
      67  class parallel_unsequenced_policy
      68  {
      69    public:
      70      // For internal use only
      71      static constexpr std::true_type
      72      __allow_unsequenced()
      73      {
      74          return std::true_type{};
      75      }
      76      static constexpr std::true_type
      77      __allow_vector()
      78      {
      79          return std::true_type{};
      80      }
      81      static constexpr std::true_type
      82      __allow_parallel()
      83      {
      84          return std::true_type{};
      85      }
      86  };
      87  
      88  class unsequenced_policy
      89  {
      90    public:
      91      // For internal use only
      92      static constexpr std::true_type
      93      __allow_unsequenced()
      94      {
      95          return std::true_type{};
      96      }
      97      static constexpr std::true_type
      98      __allow_vector()
      99      {
     100          return std::true_type{};
     101      }
     102      static constexpr std::false_type
     103      __allow_parallel()
     104      {
     105          return std::false_type{};
     106      }
     107  };
     108  
     109  // 2.8, Execution policy objects
     110  _GLIBCXX17_INLINE constexpr sequenced_policy seq{};
     111  _GLIBCXX17_INLINE constexpr parallel_policy par{};
     112  _GLIBCXX17_INLINE constexpr parallel_unsequenced_policy par_unseq{};
     113  _GLIBCXX17_INLINE constexpr unsequenced_policy unseq{};
     114  
     115  // 2.3, Execution policy type trait
     116  template <class _Tp>
     117  struct is_execution_policy : std::false_type
     118  {
     119  };
     120  
     121  template <>
     122  struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
     123  {
     124  };
     125  template <>
     126  struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
     127  {
     128  };
     129  template <>
     130  struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
     131  {
     132  };
     133  template <>
     134  struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
     135  {
     136  };
     137  
     138  #if _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
     139  template <class _Tp>
     140  constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
     141  #endif
     142  
     143  } // namespace v1
     144  } // namespace execution
     145  
     146  namespace __internal
     147  {
     148  template <class _ExecPolicy, class _Tp>
     149  #if _GLIBCXX_RELEASE >= 9
     150  using __enable_if_execution_policy =
     151      typename std::enable_if<__pstl::execution::is_execution_policy<std::__remove_cvref_t<_ExecPolicy>>::value,
     152                              _Tp>::type;
     153  #else
     154  using __enable_if_execution_policy =
     155      typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<_ExecPolicy>::type>::value,
     156                              _Tp>::type;
     157  #endif
     158  } // namespace __internal
     159  
     160  } // namespace __pstl
     161  
     162  #endif /* _PSTL_EXECUTION_POLICY_DEFS_H */