hpx/executors/execution_policy.hpp#

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx
namespace execution

Typedefs

using sequenced_task_policy = detail::sequenced_task_policy_shim<sequenced_executor>#

Extension: The class sequenced_task_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may not be parallelized (has to run sequentially).

The algorithm returns a future representing the result of the corresponding algorithm when invoked with the sequenced_policy.

using sequenced_policy = detail::sequenced_policy_shim<sequenced_executor>#

The class sequenced_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and require that a parallel algorithm’s execution may not be parallelized.

using parallel_task_policy = detail::parallel_task_policy_shim<parallel_executor>#

Extension: The class parallel_task_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be parallelized.

The algorithm returns a future representing the result of the corresponding algorithm when invoked with the parallel_policy.

using parallel_policy = detail::parallel_policy_shim<parallel_executor>#

The class parallel_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be parallelized.

using parallel_unsequenced_task_policy = detail::parallel_unsequenced_task_policy_shim<parallel_executor>#

The class parallel_unsequenced_task_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be parallelized and vectorized.

using parallel_unsequenced_policy = detail::parallel_unsequenced_policy_shim<parallel_executor>#

The class parallel_unsequenced_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be parallelized and vectorized.

using unsequenced_task_policy = detail::unsequenced_task_policy_shim<sequenced_executor>#

The class unsequenced_task_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be vectorized.

using unsequenced_policy = detail::unsequenced_policy_shim<sequenced_executor>#

The class unsequenced_policy is an execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm’s execution may be vectorized.

Variables

constexpr task_policy_tag task = {}#
constexpr non_task_policy_tag non_task = {}#
constexpr sequenced_policy seq = {}#

Default sequential execution policy object.

constexpr parallel_policy par = {}#

Default parallel execution policy object.

constexpr parallel_unsequenced_policy par_unseq = {}#

Default vector execution policy object.

constexpr unsequenced_policy unseq = {}#

Default vector execution policy object.

struct non_task_policy_tag : public hpx::execution::experimental::to_non_task_t#
struct task_policy_tag : public hpx::execution::experimental::to_task_t#
namespace experimental
template<>
struct is_execution_policy_mapping<non_task_policy_tag> : public true_type#
template<>
struct is_execution_policy_mapping<task_policy_tag> : public true_type#