Refactor our execution policies

We currently tag our execution policies with just an enumeration for that represents the  standard execution policies.

However, this is not sufficient for our use cases, because we also want to pass along the execution backend and the memory_direction of the algorithm.

This changes our policies so that they take an unsigned integer instead of an enumeration and then adds facilities to set and get the respective properties

Author: miscco

cudax/include/cuda/experimental/__execution/policy.cuh

@@ -44,48 +44,48 @@ struct any_execution_policy
 
   _CCCL_HIDE_FROM_ABI any_execution_policy() = default;
 
-  template <__execution_policy _Policy>
-  _CCCL_HOST_API constexpr any_execution_policy(::cuda::std::execution::__policy<_Policy>) noexcept
-      : value(_Policy)
+  template <uint32_t _Policy>
+  _CCCL_HOST_API constexpr any_execution_policy(::cuda::std::execution::__execution_policy_base<_Policy>) noexcept
+      : value(value_type{_Policy})
   {}
 
   _CCCL_HOST_API constexpr operator __execution_policy() const noexcept
   {
     return value;
   }
 
-  _CCCL_HOST_API constexpr auto operator()() const noexcept -> __execution_policy
+  _CCCL_HOST_API constexpr auto operator()() const noexcept -> value_type
   {
     return value;
   }
 
-  template <__execution_policy _Policy>
+  template <uint32_t _Policy>
   [[nodiscard]] _CCCL_HOST_API friend constexpr bool
-  operator==(const any_execution_policy& pol, const ::cuda::std::execution::__policy<_Policy>&) noexcept
+  operator==(const any_execution_policy& pol, const ::cuda::std::execution::__execution_policy_base<_Policy>&) noexcept
   {
-    return pol.value == _Policy;
+    return pol.value == value_type{_Policy};
   }
 
 #if _CCCL_STD_VER <= 2017
-  template <__execution_policy _Policy>
+  template <uint32_t _Policy>
   [[nodiscard]] _CCCL_HOST_API friend constexpr bool
-  operator==(const ::cuda::std::execution::__policy<_Policy>&, const any_execution_policy& pol) noexcept
+  operator==(const ::cuda::std::execution::__execution_policy_base<_Policy>&, const any_execution_policy& pol) noexcept
   {
-    return pol.value == _Policy;
+    return pol.value == value_type{_Policy};
   }
 
-  template <__execution_policy _Policy>
+  template <uint32_t _Policy>
   [[nodiscard]] _CCCL_HOST_API friend constexpr bool
-  operator!=(const any_execution_policy& pol, const ::cuda::std::execution::__policy<_Policy>&) noexcept
+  operator!=(const any_execution_policy& pol, const ::cuda::std::execution::__execution_policy_base<_Policy>&) noexcept
   {
-    return pol.value != _Policy;
+    return pol.value != value_type{_Policy};
   }
 
-  template <__execution_policy _Policy>
+  template <uint32_t _Policy>
   [[nodiscard]] _CCCL_HOST_API friend constexpr bool
-  operator!=(const ::cuda::std::execution::__policy<_Policy>&, const any_execution_policy& pol)
+  operator!=(const ::cuda::std::execution::__execution_policy_base<_Policy>&, const any_execution_policy& pol)
   {
-    return pol.value != _Policy;
+    return pol.value != value_type{_Policy};
   }
 #endif // _CCCL_STD_VER <= 2017
 

libcudacxx/include/cuda/std/__execution/policy.h

@@ -20,14 +20,14 @@
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/__type_traits/underlying_type.h>
 #include <cuda/std/cstdint>
 
 #include <cuda/std/__cccl/prologue.h>
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD_EXECUTION
 
-enum class __execution_policy : uint32_t
+//! @brief Enumerates the standard execution policies
+enum class __execution_policy : uint8_t
 {
   __invalid_execution_policy = 0,
   __sequenced                = 1 << 0,
@@ -36,49 +36,73 @@ enum class __execution_policy : uint32_t
   __parallel_unsequenced     = __execution_policy::__parallel | __execution_policy::__unsequenced,
 };
 
-[[nodiscard]] _CCCL_API constexpr bool
-__satisfies_execution_policy(__execution_policy __lhs, __execution_policy __rhs) noexcept
+//! @brief Enumerates the different backends we support
+//! @note Not an enum class because a user might specify multiple backends
+enum __execution_backend : uint8_t
 {
-  return (static_cast<uint32_t>(__lhs) & static_cast<uint32_t>(__rhs)) != 0;
-}
+  // The backends we provide
+  __none = 0,
+#if _CCCL_HAS_BACKEND_CUDA()
+  __cuda = 1 << 1,
+#endif // _CCCL_HAS_BACKEND_CUDA()
+#if _CCCL_HAS_BACKEND_OMP()
+  __omp = 1 << 2,
+#endif // _CCCL_HAS_BACKEND_OMP()
+#if _CCCL_HAS_BACKEND_TBB()
+  __tbb = 1 << 3,
+#endif // _CCCL_HAS_BACKEND_TBB()
+};
 
-template <__execution_policy _Policy>
-struct __policy
+//! @brief Base class for our execution policies.
+//! It takes an untagged uint32_t because we want to be able to store 3 different enumerations in it.
+template <uint32_t _Policy>
+struct __execution_policy_base
 {
-  template <__execution_policy _OtherPolicy>
-  [[nodiscard]] _CCCL_API friend constexpr bool operator==(const __policy&, const __policy<_OtherPolicy>&) noexcept
+  template <uint32_t _OtherPolicy>
+  [[nodiscard]] _CCCL_API friend constexpr bool
+  operator==(const __execution_policy_base&, const __execution_policy_base<_OtherPolicy>&) noexcept
   {
-    using __underlying_t = underlying_type_t<__execution_policy>;
-    return (static_cast<__underlying_t>(_Policy) == static_cast<__underlying_t>(_OtherPolicy));
+    return _Policy == _OtherPolicy;
   }
 
 #if _CCCL_STD_VER <= 2017
-  template <__execution_policy _OtherPolicy>
-  [[nodiscard]] _CCCL_API friend constexpr bool operator!=(const __policy&, const __policy<_OtherPolicy>&) noexcept
+  template <uint32_t _OtherPolicy>
+  [[nodiscard]] _CCCL_API friend constexpr bool
+  operator!=(const __execution_policy_base&, const __execution_policy_base<_OtherPolicy>&) noexcept
   {
-    using __underlying_t = underlying_type_t<__execution_policy>;
-    return (static_cast<__underlying_t>(_Policy) != static_cast<__underlying_t>(_OtherPolicy));
+    return _Policy != _OtherPolicy;
   }
 #endif // _CCCL_STD_VER <= 2017
 
-  static constexpr __execution_policy __policy_ = _Policy;
-};
+  //! @brief Tag that identifies this and all derived classes as a CCCL execution policy
+  static constexpr uint32_t __cccl_policy_ = _Policy;
+
+  //! @brief Extracts the execution policy from the stored _Policy
+  [[nodiscard]] _CCCL_API static constexpr __execution_policy __get_policy() noexcept
+  {
+    constexpr uint32_t __policy_mask{0x000000FF};
+    return __execution_policy{_Policy & __policy_mask};
+  }
 
-struct sequenced_policy : public __policy<__execution_policy::__sequenced>
-{};
+  //! @brief Extracts the execution backend from the stored _Policy
+  [[nodiscard]] _CCCL_API static constexpr __execution_backend __get_backend() noexcept
+  {
+    constexpr uint32_t __backend_mask{0x0000FF00};
+    return __execution_backend{(_Policy & __backend_mask) >> 8};
+  }
+};
 
+using sequenced_policy = __execution_policy_base<static_cast<uint32_t>(__execution_policy::__sequenced)>;
 _CCCL_GLOBAL_CONSTANT sequenced_policy seq{};
 
-struct parallel_policy : public __policy<__execution_policy::__parallel>
-{};
+using parallel_policy = __execution_policy_base<static_cast<uint32_t>(__execution_policy::__parallel)>;
 _CCCL_GLOBAL_CONSTANT parallel_policy par{};
 
-struct parallel_unsequenced_policy : public __policy<__execution_policy::__parallel_unsequenced>
-{};
+using parallel_unsequenced_policy =
+  __execution_policy_base<static_cast<uint32_t>(__execution_policy::__parallel_unsequenced)>;
 _CCCL_GLOBAL_CONSTANT parallel_unsequenced_policy par_unseq{};
 
-struct unsequenced_policy : public __policy<__execution_policy::__unsequenced>
-{};
+using unsequenced_policy = __execution_policy_base<static_cast<uint32_t>(__execution_policy::__unsequenced)>;
 _CCCL_GLOBAL_CONSTANT unsequenced_policy unseq{};
 
 _CCCL_END_NAMESPACE_CUDA_STD_EXECUTION

libcudacxx/include/cuda/std/__internal/pstl_config.h

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_STD___INTERNAL_PSTL_CONFIG_H
+#define _CUDA_STD___INTERNAL_PSTL_CONFIG_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__cccl/prologue.h>
+
+#define _CCCL_HAS_BACKEND_CUDA() 0
+#define _CCCL_HAS_BACKEND_OMP()  0
+#define _CCCL_HAS_BACKEND_TBB()  0
+
+#include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CUDA_STD___INTERNAL_PSTL_CONFIG_H

libcudacxx/include/cuda/std/__type_traits/is_execution_policy.h

@@ -28,51 +28,33 @@
 
 _CCCL_BEGIN_NAMESPACE_CUDA_STD
 
-template <class>
+template <class, class = void>
 inline constexpr bool is_execution_policy_v = false;
 
-// Ensure we ignore cv qualifiers
-template <class _Tp>
-inline constexpr bool is_execution_policy_v<const _Tp> = is_execution_policy_v<_Tp>;
-
-template <class _Tp>
-inline constexpr bool is_execution_policy_v<volatile _Tp> = is_execution_policy_v<_Tp>;
-
-template <class _Tp>
-inline constexpr bool is_execution_policy_v<const volatile _Tp> = is_execution_policy_v<_Tp>;
-
-// Explicitly mark our execution policies as such
-template <>
-inline constexpr bool is_execution_policy_v<::cuda::std::execution::sequenced_policy> = true;
-
-template <>
-inline constexpr bool is_execution_policy_v<::cuda::std::execution::parallel_policy> = true;
-
-template <>
-inline constexpr bool is_execution_policy_v<::cuda::std::execution::parallel_unsequenced_policy> = true;
-
-template <>
-inline constexpr bool is_execution_policy_v<::cuda::std::execution::unsequenced_policy> = true;
+template <class _Policy>
+inline constexpr bool is_execution_policy_v<_Policy, void_t<decltype(_Policy::__cccl_policy_)>> = true;
 
 template <class _Tp>
 struct _CCCL_NO_SPECIALIZATIONS is_execution_policy : bool_constant<is_execution_policy_v<_Tp>>
 {};
 
 // Detect parallel policies
-template <class, class = void>
+template <class _Policy, bool = is_execution_policy_v<_Policy>>
 inline constexpr bool __is_parallel_execution_policy_v = false;
 
 template <class _Policy>
-inline constexpr bool __is_parallel_execution_policy_v<_Policy, void_t<decltype(_Policy::__policy_)>> =
-  __satisfies_execution_policy(_Policy::__policy_, ::cuda::std::execution::__execution_policy::__parallel);
+inline constexpr bool __is_parallel_execution_policy_v<_Policy, true> =
+  _Policy::__get_policy() == ::cuda::std::execution::__execution_policy::__parallel
+  || _Policy::__get_policy() == ::cuda::std::execution::__execution_policy::__parallel_unsequenced;
 
 // Detect unsequenced policies
-template <class, class = void>
+template <class _Policy, bool = is_execution_policy_v<_Policy>>
 inline constexpr bool __is_unsequenced_execution_policy_v = false;
 
 template <class _Policy>
-inline constexpr bool __is_unsequenced_execution_policy_v<_Policy, void_t<decltype(_Policy::__policy_)>> =
-  __satisfies_execution_policy(_Policy::__policy_, ::cuda::std::execution::__execution_policy::__unsequenced);
+inline constexpr bool __is_unsequenced_execution_policy_v<_Policy, true> =
+  _Policy::__get_policy() == ::cuda::std::execution::__execution_policy::__unsequenced
+  || _Policy::__get_policy() == ::cuda::std::execution::__execution_policy::__parallel_unsequenced;
 
 _CCCL_END_NAMESPACE_CUDA_STD
 

libcudacxx/include/cuda/std/detail/__config

@@ -15,6 +15,7 @@
 #include <cuda/std/__internal/cpp_dialect.h>
 #include <cuda/std/__internal/features.h>
 #include <cuda/std/__internal/namespaces.h>
+#include <cuda/std/__internal/pstl_config.h>
 #include <cuda/std/__internal/thread_api.h>
 #include <cuda/std/__internal/version.h>