11.2.0/pstl/execution_defs.h

// -*- C++ -*-
//===-- execution_defs.h --------------------------------------------------===//
//
// 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_POLICY_DEFS_H
#define _PSTL_EXECUTION_POLICY_DEFS_H

#include <type_traits>

namespace __pstl
{
namespace execution
{
inline namespace v1
{

// 2.4, Sequential execution policy
class sequenced_policy
{
  public:
    // For internal use only
    static constexpr std::false_type
    __allow_unsequenced()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_vector()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_parallel()
    {
        return std::false_type{};
    }
};

// 2.5, Parallel execution policy
class parallel_policy
{
  public:
    // For internal use only
    static constexpr std::false_type
    __allow_unsequenced()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_vector()
    {
        return std::false_type{};
    }
    static constexpr std::true_type
    __allow_parallel()
    {
        return std::true_type{};
    }
};

// 2.6, Parallel+Vector execution policy
class parallel_unsequenced_policy
{
  public:
    // For internal use only
    static constexpr std::true_type
    __allow_unsequenced()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_vector()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_parallel()
    {
        return std::true_type{};
    }
};

class unsequenced_policy
{
  public:
    // For internal use only
    static constexpr std::true_type
    __allow_unsequenced()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_vector()
    {
        return std::true_type{};
    }
    static constexpr std::false_type
    __allow_parallel()
    {
        return std::false_type{};
    }
};

// 2.8, Execution policy objects
constexpr sequenced_policy seq{};
constexpr parallel_policy par{};
constexpr parallel_unsequenced_policy par_unseq{};
constexpr unsequenced_policy unseq{};

// 2.3, Execution policy type trait
template <class _Tp>
struct is_execution_policy : std::false_type
{
};

template <>
struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
{
};

#if _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
template <class _Tp>
constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
#endif

} // namespace v1
} // namespace execution

namespace __internal
{
template <class _ExecPolicy, class _Tp>
#if _GLIBCXX_RELEASE >= 9
using __enable_if_execution_policy =
    typename std::enable_if<__pstl::execution::is_execution_policy<std::__remove_cvref_t<_ExecPolicy>>::value,
                            _Tp>::type;
#else
using __enable_if_execution_policy =
    typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<_ExecPolicy>::type>::value,
                            _Tp>::type;
#endif
} // namespace __internal

} // namespace __pstl

#endif /* _PSTL_EXECUTION_POLICY_DEFS_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	3694 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
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	constexpr sequenced_policy seq{};
111	constexpr parallel_policy par{};
112	constexpr parallel_unsequenced_policy par_unseq{};
113	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 */