Add execution header

[zoecarver]

Summary

Adds the execution header and all members.

[mclow.lists]

I think we're going to get this from the work that @ldionne and Thomas Rodgers are doing on the pstl project. You should check with them.

For future reference - adding a new header file is more complicated than this.

• You need to update the "double include tester" - test/libcxx/double_include.sh.cpp
• You need to put an entry in the module map - include/module.modulemap

[ldionne]

Yes, indeed, this will be provided by the PSTL.

[zoecarver]

@ldionne Okay, great. I assume you mean this PSTL? Is that ever merged into libc++? Also, it doesn't look like PSTL contains any of the execution policies (or is_execution_policy). Should I make a patch to that repository, or would you rather implement those yourself?

@mclow.lists Thanks for the reference on adding header files.

[ldionne]

In D60032#1450205, @zoecarver wrote:

@ldionne Okay, great. I assume you mean this PSTL? Is that ever merged into libc++?

Not right now, but I'm working on integrating it into libc++.

Also, it doesn't look like PSTL contains any of the execution policies (or is_execution_policy). Should I make a patch to that repository, or would you rather implement those yourself?

See https://github.com/llvm-mirror/pstl/blob/master/include/pstl/internal/execution_defs.h#L23

[zoecarver]

I see, thanks (didn't find that file for some reason). Let me know if you want any help implementing it into libc++ :)

[zoecarver]

@ldionne's got this :)

include/execution

+// -*- C++ -*-
+//===-------------------------- execution ---------------------------------===//
+//
+// 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 _LIBCPP_EXECUTION
+#define _LIBCPP_EXECUTION
+
+/*
+    execution synopsis
+
+namespace std
+{
+
+template<class T> struct is_execution_policy;
+template<class T> inline constexpr bool is_execution_policy_v
+    = is_execution_policy<T>::value;
+
+namespace execution
+{
+
+    class sequenced_policy;
+    class parallel_policy;
+    class parallel_unsequenced_policy;
+    class unsequenced_policy;
+
+    inline constexpr sequenced_policy seq;
+    inline constexpr parallel_policy par;
+    inline constexpr parallel_unsequenced_policy par_unseq;
+    inline constexpr unsequenced_policy unseq;
+}
+
+}
+
+*/
+
+#include <type_traits>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace execution
+{
+    class __policy_type { };
+
+    class sequenced_policy : __policy_type { };
+    class parallel_policy : __policy_type { };
+    class parallel_unsequenced_policy : __policy_type { };
+    class unsequenced_policy : __policy_type { };
+
+    inline constexpr sequenced_policy seq;
+    inline constexpr parallel_policy par;
+    inline constexpr parallel_unsequenced_policy par_unseq;
+    inline constexpr unsequenced_policy unseq;
+}
+
+template<class _Tp>
+struct is_execution_policy: is_base_of<execution::__policy_type, _Tp> { };
+template<class _Tp>
+inline constexpr bool is_execution_policy_v = is_execution_policy<_Tp>::value;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_EXECUTION

test/std/algorithms/algorithms.parallel.exec/execution_policy.pass.cpp

+#include <execution>
+#include <type_traits>
+
+class not_ep_c { };
+struct not_ep_s { };
+
+template<class EP>
+void assert_is_execution_policy()
+{ static_assert(std::is_execution_policy<EP>::value, ""); }
+
+int main()
+{
+    assert_is_execution_policy<std::execution::sequenced_policy>();
+    assert_is_execution_policy<std::execution::parallel_policy>();
+    assert_is_execution_policy<std::execution::parallel_unsequenced_policy>();
+    assert_is_execution_policy<std::execution::unsequenced_policy>();
+
+    assert_is_execution_policy<decltype(std::execution::seq)>();
+    assert_is_execution_policy<decltype(std::execution::par)>();
+    assert_is_execution_policy<decltype(std::execution::par_unseq)>();
+    assert_is_execution_policy<decltype(std::execution::unseq)>();
+
+    static_assert(std::is_convertible<decltype(std::execution::seq),
+            std::execution::sequenced_policy>::value, "");
+    static_assert(std::is_convertible<decltype(std::execution::par),
+            std::execution::parallel_policy>::value, "");
+    static_assert(std::is_convertible<decltype(std::execution::par_unseq),
+            std::execution::parallel_unsequenced_policy>::value, "");
+    static_assert(std::is_convertible<decltype(std::execution::unseq),
+            std::execution::unsequenced_policy>::value, "");
+
+    static_assert(!std::is_execution_policy<int>::value, "");
+    static_assert(!std::is_execution_policy<not_ep_c>::value, "");
+    static_assert(!std::is_execution_policy<not_ep_s>::value, "");
+
+    return 0;
+}
 No newline at end of file