execution

#include <hpx/execution/executors.hpp>

#include <hpx/execution/execution_policy.hpp>

namespace hpx
namespace parallel
namespace execution

Variables

constexpr task_policy_tag task

Default sequential execution policy object.

HPX_STATIC_CONSTEXPR sequenced_policy hpx::parallel::execution::seq

Default sequential execution policy object.

HPX_STATIC_CONSTEXPR parallel_policy hpx::parallel::execution::par

Default parallel execution policy object.

HPX_STATIC_CONSTEXPR parallel_unsequenced_policy hpx::parallel::execution::par_unseq

Default vector execution policy object.

struct parallel_policy
#include <execution_policy.hpp>

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.

Subclassed by hpx::parallel::execution::parallel_policy_shim< Executor, Parameters >

Public Types

typedef parallel_executor executor_type

The type of the executor associated with this execution policy.

typedef execution::extract_executor_parameters<executor_type>::type executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef parallel_execution_tag execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr parallel_task_policy operator()(task_policy_tag) const

Create a new parallel_policy referencing a chunk size.

Return

The new parallel_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor>
rebind_executor<parallel_policy, Executor, executor_parameters_type>::type on(Executor &&exec) const

Create a new parallel_policy referencing an executor and a chunk size.

Return

The new parallel_policy

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with

template<typename ...Parameters, typename ParametersType = typename executor_parameters_join<Parameters...>::type>
rebind_executor<parallel_policy, executor_type, ParametersType>::type with(Parameters&&... params) const

Create a new parallel_policy from the given execution parameters

Note

Requires: is_executor_parameters<Parameters>::value is true

Return

The new parallel_policy

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

executor_type &executor()

Return the associated executor object.

constexpr executor_type const &executor() const

Return the associated executor object.

executor_parameters_type &parameters()

Return the associated executor parameters object.

constexpr executor_parameters_type const &parameters() const

Return the associated executor parameters object.

Private Functions

template<typename Archive>
void serialize(Archive &ar, const unsigned int version)

Private Members

executor_type exec_
executor_parameters_type params_

Friends

friend hpx::parallel::execution::hpx::serialization::access
template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

typedef parallel_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

template<typename Executor, typename Parameters>
struct parallel_policy_shim : public hpx::parallel::execution::parallel_policy
#include <execution_policy.hpp>

The class parallel_policy_shim 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.

Public Types

typedef Executor executor_type

The type of the executor associated with this execution policy.

typedef Parameters executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef hpx::traits::executor_execution_category<executor_type>::type execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr parallel_task_policy_shim<Executor, Parameters> operator()(task_policy_tag tag) const

Create a new parallel_policy referencing a chunk size.

Return

The new parallel_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor_>
rebind_executor<parallel_policy_shim, Executor_, executor_parameters_type>::type on(Executor_ &&exec) const

Create a new parallel_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new parallel_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters_, typename ParametersType = typename executor_parameters_join<Parameters_...>::type>
rebind_executor<parallel_policy_shim, executor_type, ParametersType>::type with(Parameters_&&... params) const

Create a new parallel_policy_shim from the given execution parameters

Note

Requires: is_executor_parameters<Parameters>::value is true

Return

The new parallel_policy_shim

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

Executor &executor()

Return the associated executor object.

constexpr Executor const &executor() const

Return the associated executor object.

Parameters &parameters()

Return the associated executor parameters object.

constexpr Parameters const &parameters() const

Return the associated executor parameters object.

template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

template<>
typedef parallel_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

struct parallel_task_policy
#include <execution_policy.hpp>

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.

Subclassed by hpx::parallel::execution::parallel_task_policy_shim< Executor, Parameters >

Public Types

typedef parallel_executor executor_type

The type of the executor associated with this execution policy.

typedef execution::extract_executor_parameters<executor_type>::type executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef parallel_execution_tag execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr parallel_task_policy operator()(task_policy_tag) const

Create a new parallel_task_policy from itself

Return

The new parallel_task_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor>
rebind_executor<parallel_task_policy, Executor, executor_parameters_type>::type on(Executor &&exec) const

Create a new parallel_task_policy from given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new parallel_task_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters, typename ParametersType = typename executor_parameters_join<Parameters...>::type>
rebind_executor<parallel_task_policy, executor_type, ParametersType>::type with(Parameters&&... params) const

Create a new parallel_policy_shim from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new parallel_policy_shim

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

executor_type &executor()

Return the associated executor object.

constexpr executor_type const &executor() const

Return the associated executor object.

executor_parameters_type &parameters()

Return the associated executor parameters object.

constexpr executor_parameters_type const &parameters() const

Return the associated executor parameters object.

Private Functions

template<typename Archive>
void serialize(Archive &ar, const unsigned int version)

Private Members

executor_type exec_
executor_parameters_type params_

Friends

friend hpx::parallel::execution::hpx::serialization::access
template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

typedef parallel_task_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

template<typename Executor, typename Parameters>
struct parallel_task_policy_shim : public hpx::parallel::execution::parallel_task_policy
#include <execution_policy.hpp>

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

Public Types

typedef Executor executor_type

The type of the executor associated with this execution policy.

typedef Parameters executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef hpx::traits::executor_execution_category<executor_type>::type execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr parallel_task_policy_shim operator()(task_policy_tag tag) const

Create a new parallel_task_policy_shim from itself

Return

The new sequenced_task_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor_>
rebind_executor<parallel_task_policy_shim, Executor_, executor_parameters_type>::type on(Executor_ &&exec) const

Create a new parallel_task_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new parallel_task_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters_, typename ParametersType = typename executor_parameters_join<Parameters_...>::type>
rebind_executor<parallel_task_policy_shim, executor_type, ParametersType>::type with(Parameters_&&... params) const

Create a new parallel_policy_shim from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new parallel_policy_shim

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

Executor &executor()

Return the associated executor object.

constexpr Executor const &executor() const

Return the associated executor object.

Parameters &parameters()

Return the associated executor parameters object.

constexpr Parameters const &parameters() const

Return the associated executor parameters object.

template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

template<>
typedef parallel_task_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

struct parallel_unsequenced_policy
#include <execution_policy.hpp>

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 vectorized.

Public Types

typedef parallel_executor executor_type

The type of the executor associated with this execution policy.

typedef execution::extract_executor_parameters<executor_type>::type executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef parallel_execution_tag execution_category

The category of the execution agents created by this execution policy.

Public Functions

parallel_unsequenced_policy operator()(task_policy_tag) const

Create a new parallel_unsequenced_policy from itself

Return

The new parallel_unsequenced_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

executor_type &executor()

Return the associated executor object.

constexpr executor_type const &executor() const

Return the associated executor object.

executor_parameters_type &parameters()

Return the associated executor parameters object.

constexpr executor_parameters_type const &parameters() const

Return the associated executor parameters object.

Private Functions

template<typename Archive>
void serialize(Archive &ar, const unsigned int version)

Private Members

executor_type exec_
executor_parameters_type params_

Friends

friend hpx::parallel::execution::hpx::serialization::access
struct sequenced_policy
#include <execution_policy.hpp>

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.

Subclassed by hpx::parallel::execution::sequenced_policy_shim< Executor, Parameters >

Public Types

typedef sequenced_executor executor_type

The type of the executor associated with this execution policy.

typedef execution::extract_executor_parameters<executor_type>::type executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef sequenced_execution_tag execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr sequenced_task_policy operator()(task_policy_tag) const

Create a new sequenced_task_policy.

Return

The new sequenced_task_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor>
rebind_executor<sequenced_policy, Executor, executor_parameters_type>::type on(Executor &&exec) const

Create a new sequenced_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new sequenced_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters, typename ParametersType = typename executor_parameters_join<Parameters...>::type>
rebind_executor<sequenced_policy, executor_type, ParametersType>::type with(Parameters&&... params) const

Create a new sequenced_policy from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new sequenced_policy

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

executor_type &executor()

Return the associated executor object. Return the associated executor object.

constexpr executor_type const &executor() const

Return the associated executor object.

executor_parameters_type &parameters()

Return the associated executor parameters object.

constexpr executor_parameters_type const &parameters() const

Return the associated executor parameters object.

Private Functions

template<typename Archive>
void serialize(Archive &ar, const unsigned int version)

Private Members

executor_type exec_
executor_parameters_type params_

Friends

friend hpx::parallel::execution::hpx::serialization::access
template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

typedef sequenced_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

template<typename Executor, typename Parameters>
struct sequenced_policy_shim : public hpx::parallel::execution::sequenced_policy
#include <execution_policy.hpp>

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.

Public Types

typedef Executor executor_type

The type of the executor associated with this execution policy.

typedef Parameters executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef hpx::traits::executor_execution_category<executor_type>::type execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr sequenced_task_policy_shim<Executor, Parameters> operator()(task_policy_tag tag) const

Create a new sequenced_task_policy.

Return

The new sequenced_task_policy_shim

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor_>
rebind_executor<sequenced_policy_shim, Executor_, executor_parameters_type>::type on(Executor_ &&exec) const

Create a new sequenced_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new sequenced_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters_, typename ParametersType = typename executor_parameters_join<Parameters_...>::type>
rebind_executor<sequenced_policy_shim, executor_type, ParametersType>::type with(Parameters_&&... params) const

Create a new sequenced_policy_shim from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new sequenced_policy_shim

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

Executor &executor()

Return the associated executor object.

constexpr Executor const &executor() const

Return the associated executor object.

Parameters &parameters()

Return the associated executor parameters object.

constexpr Parameters const &parameters() const

Return the associated executor parameters object.

template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

template<>
typedef sequenced_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

struct sequenced_task_policy
#include <execution_policy.hpp>

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.

Subclassed by hpx::parallel::execution::sequenced_task_policy_shim< Executor, Parameters >

Public Types

typedef sequenced_executor executor_type

The type of the executor associated with this execution policy.

typedef execution::extract_executor_parameters<executor_type>::type executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef sequenced_execution_tag execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr sequenced_task_policy operator()(task_policy_tag) const

Create a new sequenced_task_policy from itself

Return

The new sequenced_task_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor>
rebind_executor<sequenced_task_policy, Executor, executor_parameters_type>::type on(Executor &&exec) const

Create a new sequenced_task_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new sequenced_task_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters, typename ParametersType = typename executor_parameters_join<Parameters...>::type>
rebind_executor<sequenced_task_policy, executor_type, ParametersType>::type with(Parameters&&... params) const

Create a new sequenced_task_policy from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new sequenced_task_policy

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

executor_type &executor()

Return the associated executor object.

constexpr executor_type const &executor() const

Return the associated executor object.

executor_parameters_type &parameters()

Return the associated executor parameters object.

constexpr executor_parameters_type const &parameters() const

Return the associated executor parameters object.

Private Functions

template<typename Archive>
void serialize(Archive &ar, const unsigned int version)

Private Members

executor_type exec_
executor_parameters_type params_

Friends

friend hpx::parallel::execution::hpx::serialization::access
template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

typedef sequenced_task_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

template<typename Executor, typename Parameters>
struct sequenced_task_policy_shim : public hpx::parallel::execution::sequenced_task_policy
#include <execution_policy.hpp>

Extension: The class sequenced_task_policy_shim is an execution policy type used as a unique type to disambiguate parallel algorithm overloading based on combining a underlying sequenced_task_policy and an executor 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.

Public Types

typedef Executor executor_type

The type of the executor associated with this execution policy.

typedef Parameters executor_parameters_type

The type of the associated executor parameters object which is associated with this execution policy

typedef hpx::traits::executor_execution_category<executor_type>::type execution_category

The category of the execution agents created by this execution policy.

Public Functions

constexpr sequenced_task_policy_shim const &operator()(task_policy_tag tag) const

Create a new sequenced_task_policy from itself

Return

The new sequenced_task_policy

Parameters
  • tag: [in] Specify that the corresponding asynchronous execution policy should be used

template<typename Executor_>
rebind_executor<sequenced_task_policy_shim, Executor_, executor_parameters_type>::type on(Executor_ &&exec) const

Create a new sequenced_task_policy from the given executor

Note

Requires: is_executor<Executor>::value is true

Return

The new sequenced_task_policy

Template Parameters
  • Executor: The type of the executor to associate with this execution policy.

Parameters
  • exec: [in] The executor to use for the execution of the parallel algorithm the returned execution policy is used with.

template<typename ...Parameters_, typename ParametersType = typename executor_parameters_join<Parameters_...>::type>
rebind_executor<sequenced_task_policy_shim, executor_type, ParametersType>::type with(Parameters_&&... params) const

Create a new sequenced_task_policy_shim from the given execution parameters

Note

Requires: all parameters are executor_parameters, different parameter types can’t be duplicated

Return

The new sequenced_task_policy_shim

Template Parameters
  • Parameters: The type of the executor parameters to associate with this execution policy.

Parameters
  • params: [in] The executor parameters to use for the execution of the parallel algorithm the returned execution policy is used with.

Executor &executor()

Return the associated executor object.

constexpr Executor const &executor() const

Return the associated executor object.

Parameters &parameters()

Return the associated executor parameters object.

constexpr Parameters const &parameters() const

Return the associated executor parameters object.

template<typename Executor_, typename Parameters_>
struct rebind
#include <execution_policy.hpp>

Rebind the type of executor used by this execution policy. The execution category of Executor shall not be weaker than that of this execution policy

Public Types

template<>
typedef sequenced_task_policy_shim<Executor_, Parameters_> type

The type of the rebound execution policy.

#include <hpx/execution/execution_policy_fwd.hpp>

#include <hpx/execution/exception_list.hpp>

#include <hpx/execution/execution.hpp>

#include <hpx/execution/executor_parameters.hpp>

#include <hpx/execution/executors/sequenced_executor.hpp>

namespace hpx
namespace parallel
namespace execution
struct sequenced_executor
#include <sequenced_executor.hpp>

A sequential_executor creates groups of sequential execution agents which execute in the calling thread. The sequential order is given by the lexicographical order of indices in the index space.

#include <hpx/execution/executors/thread_pool_executors.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using local_priority_queue_executor = threads::executors::local_priority_queue_executor

Creates a new local_priority_queue_executor

Parameters
  • max_punits: [in] The maximum number of processing units to associate with the newly created executor.

  • min_punits: [in] The minimum number of processing units to associate with the newly created executor (default: 1).

#include <hpx/execution/executors/post_policy_dispatch.hpp>

#include <hpx/execution/executors/static_chunk_size.hpp>

namespace hpx
namespace parallel
namespace execution
struct static_chunk_size
#include <static_chunk_size.hpp>

Loop iterations are divided into pieces of size chunk_size and then assigned to threads. If chunk_size is not specified, the iterations are evenly (if possible) divided contiguously among the threads.

Note

This executor parameters type is equivalent to OpenMP’s STATIC scheduling directive.

Public Functions

constexpr static_chunk_size()

Construct a static_chunk_size executor parameters object

Note

By default the number of loop iterations is determined from the number of available cores and the overall number of loop iterations to schedule.

constexpr static_chunk_size(std::size_t chunk_size)

Construct a static_chunk_size executor parameters object

Parameters
  • chunk_size: [in] The optional chunk size to use as the number of loop iterations to run on a single thread.

#include <hpx/execution/executors/fused_bulk_execute.hpp>

#include <hpx/execution/executors/guided_chunk_size.hpp>

namespace hpx
namespace parallel
namespace execution
struct guided_chunk_size
#include <guided_chunk_size.hpp>

Iterations are dynamically assigned to threads in blocks as threads request them until no blocks remain to be assigned. Similar to dynamic_chunk_size except that the block size decreases each time a number of loop iterations is given to a thread. The size of the initial block is proportional to number_of_iterations / number_of_cores. Subsequent blocks are proportional to number_of_iterations_remaining / number_of_cores. The optional chunk size parameter defines the minimum block size. The default chunk size is 1.

Note

This executor parameters type is equivalent to OpenMP’s GUIDED scheduling directive.

Public Functions

constexpr guided_chunk_size(std::size_t min_chunk_size = 1)

Construct a guided_chunk_size executor parameters object

Parameters
  • min_chunk_size: [in] The optional minimal chunk size to use as the minimal number of loop iterations to schedule together. The default minimal chunk size is 1.

#include <hpx/execution/executors/auto_chunk_size.hpp>

namespace hpx
namespace parallel
namespace execution
struct auto_chunk_size
#include <auto_chunk_size.hpp>

Loop iterations are divided into pieces and then assigned to threads. The number of loop iterations combined is determined based on measurements of how long the execution of 1% of the overall number of iterations takes. This executor parameters type makes sure that as many loop iterations are combined as necessary to run for the amount of time specified.

Public Functions

constexpr auto_chunk_size()

Construct an auto_chunk_size executor parameters object

Note

Default constructed auto_chunk_size executor parameter types will use 80 microseconds as the minimal time for which any of the scheduled chunks should run.

auto_chunk_size(hpx::util::steady_duration const &rel_time)

Construct an auto_chunk_size executor parameters object

Parameters
  • rel_time: [in] The time duration to use as the minimum to decide how many loop iterations should be combined.

#include <hpx/execution/executors/execution_parameters.hpp>

namespace hpx
namespace parallel
namespace execution

Functions

template<typename ...Params>
executor_parameters_join<Params...>::type join_executor_parameters(Params&&... params)
template<typename Param>
Param &&join_executor_parameters(Param &&param)
template<typename ...Params>
struct executor_parameters_join

Public Types

template<>
using type = detail::executor_parameters<typename hpx::util::decay<Params>::type...>
template<typename Param>
struct executor_parameters_join<Param>

Public Types

template<>
using type = Param

#include <hpx/execution/executors/execution_parameters_fwd.hpp>

#include <hpx/execution/executors/execution_fwd.hpp>

namespace hpx
namespace parallel
namespace execution
struct parallel_execution_tag
#include <execution_fwd.hpp>

Function invocations executed by a group of parallel execution agents execute in unordered fashion. Any such invocations executing in the same thread are indeterminately sequenced with respect to each other.

Note

parallel_execution_tag is weaker than sequenced_execution_tag.

struct sequenced_execution_tag
#include <execution_fwd.hpp>

Function invocations executed by a group of sequential execution agents execute in sequential order.

struct unsequenced_execution_tag
#include <execution_fwd.hpp>

Function invocations executed by a group of vector execution agents are permitted to execute in unordered fashion when executed in different threads, and un-sequenced with respect to one another when executed in the same thread.

Note

unsequenced_execution_tag is weaker than parallel_execution_tag.

#include <hpx/execution/executors/service_executors.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using service_executor = threads::executors::service_executor

A service_executor exposes one of the predefined HPX thread pools through an executor interface.

Note

All tasks executed by one of these executors will run on one of the OS-threads dedicated for the given thread pool. The tasks will not run as HPX-threads.

using io_pool_executor = threads::executors::io_pool_executor

A io_pool_executor exposes the predefined HPX IO thread pool through an executor interface.

Note

All tasks executed by one of these executors will run on one of the OS-threads dedicated for the IO thread pool. The tasks will not run as HPX-threads.

using parcel_pool_executor = threads::executors::parcel_pool_executor

A io_pool_executor exposes the predefined HPX parcel thread pool through an executor interface.

Note

All tasks executed by one of these executors will run on one of the OS-threads dedicated for the parcel thread pool. The tasks will not run as HPX-threads.

using timer_pool_executor = threads::executors::timer_pool_executor

A io_pool_executor exposes the predefined HPX timer thread pool through an executor interface.

Note

All tasks executed by one of these executors will run on one of the OS-threads dedicated for the timer thread pool. The tasks will not run as HPX-threads.

using main_pool_executor = threads::executors::main_pool_executor

A io_pool_executor exposes the predefined HPX main thread pool through an executor interface.

Note

All tasks executed by one of these executors will run on one of the OS-threads dedicated for the main thread pool. The tasks will not run as HPX-threads.

#include <hpx/execution/executors/thread_execution_information.hpp>

namespace hpx
namespace threads

Functions

template<typename Executor, typename Parameters>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, std::size_t>::type processing_units_count(Executor &&exec, Parameters&)
template<typename Executor>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, bool>::type has_pending_closures(Executor &&exec)
template<typename Executor>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, threads::mask_cref_type>::type get_pu_mask(Executor &&exec, threads::topology &topo, std::size_t thread_num)
template<typename Executor, typename Mode>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value>::type set_scheduler_mode(Executor &&exec, Mode mode)

#include <hpx/execution/executors/thread_pool_executor.hpp>

namespace hpx
namespace parallel
namespace execution
struct thread_pool_executor
#include <thread_pool_executor.hpp>

A thread_pool_executor creates groups of parallel execution agents which execute in threads implicitly created by the executor. This executor prefers continuing with the creating thread first before executing newly created threads.

This executor conforms to the concepts of a TwoWayExecutor, and a BulkTwoWayExecutor

Public Types

typedef parallel_execution_tag execution_category

Associate the parallel_execution_tag executor tag type as a default with this executor.

typedef static_chunk_size executor_parameters_type

Associate the static_chunk_size executor parameters type as a default with this executor.

Public Functions

thread_pool_executor(threads::thread_pool_base *pool)

Create a new parallel executor.

Private Members

threads::thread_pool_base *pool_

#include <hpx/execution/executors/thread_pool_os_executors.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using local_priority_queue_os_executor = threads::executors::local_priority_queue_os_executor

Creates a new local_priority_queue_executor

Parameters
  • max_punits: [in] The maximum number of processing units to associate with the newly created executor.

  • min_punits: [in] The minimum number of processing units to associate with the newly created executor (default: 1).

#include <hpx/execution/executors/thread_pool_attached_executors.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using local_priority_queue_attached_executor = threads::executors::local_priority_queue_attached_executor

#include <hpx/execution/executors/pool_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using pool_executor = threads::executors::pool_executor

#include <hpx/execution/executors/thread_execution.hpp>

namespace hpx
namespace threads

Functions

template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, hpx::lcos::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>>::type async_execute(Executor &&exec, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>::type sync_execute(Executor &&exec, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename Future, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, hpx::lcos::future<typename hpx::util::detail::invoke_deferred_result<F, Future, Ts...>::type>>::type then_execute(Executor &&exec, F &&f, Future &&predecessor, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value>::type post(Executor &&exec, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename Hint, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value && std::is_same<typename hpx::util::decay<Hint>::type, hpx::threads::thread_schedule_hint>::value>::type post(Executor &&exec, F &&f, Hint &&hint, const char *annotation, Ts&&... ts)
template<typename Executor, typename F, typename Shape, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, std::vector<hpx::lcos::future<typename parallel::execution::detail::bulk_function_result<F, Shape, Ts...>::type>>>::type bulk_async_execute(Executor &&exec, F &&f, Shape const &shape, Ts&&... ts)
template<typename Executor, typename F, typename Shape, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, typename parallel::execution::detail::bulk_execute_result<F, Shape, Ts...>::type>::type bulk_sync_execute(Executor &&exec, F &&f, Shape const &shape, Ts&&... ts)
template<typename Executor, typename F, typename Shape, typename Future, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, hpx::future<typename parallel::execution::detail::bulk_then_execute_result<F, Shape, Future, Ts...>::type>>::type bulk_then_execute(Executor &&exec, F &&f, Shape const &shape, Future &&predecessor, Ts&&... ts)

#include <hpx/execution/executors/parallel_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using parallel_executor = parallel_policy_executor<hpx::launch>
template<typename Policy>
struct parallel_policy_executor
#include <parallel_executor.hpp>

A parallel_executor creates groups of parallel execution agents which execute in threads implicitly created by the executor. This executor prefers continuing with the creating thread first before executing newly created threads.

This executor conforms to the concepts of a TwoWayExecutor, and a BulkTwoWayExecutor

Public Types

typedef parallel_execution_tag execution_category

Associate the parallel_execution_tag executor tag type as a default with this executor.

typedef static_chunk_size executor_parameters_type

Associate the static_chunk_size executor parameters type as a default with this executor.

Public Functions

constexpr parallel_policy_executor(Policy l = detail::get_default_policy<Policy>::call(), std::size_t spread = 4, std::size_t tasks = std::size_t(-1))

Create a new parallel executor.

#include <hpx/execution/executors/execution.hpp>

#include <hpx/execution/executors/rebind_executor.hpp>

namespace hpx
namespace parallel
namespace execution
template<typename ExecutionPolicy, typename Executor, typename Parameters>
struct rebind_executor
#include <rebind_executor.hpp>

Rebind the type of executor used by an execution policy. The execution category of Executor shall not be weaker than that of ExecutionPolicy.

Public Types

typedef ExecutionPolicy::template rebind<executor_type, parameters_type>::type type

The type of the rebound execution policy.

#include <hpx/execution/executors/timed_execution.hpp>

#include <hpx/execution/executors/execution_information_fwd.hpp>

#include <hpx/execution/executors/timed_executors.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using sequenced_timed_executor = timed_executor<execution::sequenced_executor>
using parallel_timed_executor = timed_executor<execution::parallel_executor>
template<typename BaseExecutor>
struct timed_executor

Public Types

typedef std::decay<BaseExecutor>::type base_executor_type
typedef hpx::traits::executor_execution_category<base_executor_type>::type execution_category
typedef hpx::traits::executor_parameters_type<base_executor_type>::type parameters_type

Public Functions

timed_executor(hpx::util::steady_time_point const &abs_time)
timed_executor(hpx::util::steady_duration const &rel_time)
template<typename Executor>
timed_executor(Executor &&exec, hpx::util::steady_time_point const &abs_time)
template<typename Executor>
timed_executor(Executor &&exec, hpx::util::steady_duration const &rel_time)
template<typename F, typename ...Ts>
hpx::util::detail::invoke_deferred_result<F, Ts...>::type sync_execute(F &&f, Ts&&... ts)
template<typename F, typename ...Ts>
hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type> async_execute(F &&f, Ts&&... ts)
template<typename F, typename ...Ts>
void post(F &&f, Ts&&... ts)

Public Members

BaseExecutor exec_
std::chrono::steady_clock::time_point execute_at_

#include <hpx/execution/executors/default_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using default_executor = threads::executors::default_executor

Refers to the currently used base-executor.

#include <hpx/execution/executors/this_thread_executors.hpp>

#include <hpx/execution/executors/parallel_executor_aggregated.hpp>

template<>
struct parallel_policy_executor_aggregated<hpx::launch>

Public Types

template<>
using execution_category = parallel_execution_tag

Associate the parallel_execution_tag executor tag type as a default with this executor.

template<>
using executor_parameters_type = static_chunk_size

Associate the static_chunk_size executor parameters type as a default with this executor.

Public Functions

constexpr parallel_policy_executor_aggregated(hpx::launch l = hpx::launch::async_policy{}, std::size_t spread = 4, std::size_t tasks = std::size_t(-1))

Create a new parallel executor.

template<typename F, typename S, typename ...Ts>
std::vector<hpx::future<void>> bulk_async_execute(F &&f, S const &shape, Ts&&... ts) const
namespace hpx
namespace parallel
namespace execution

Typedefs

using parallel_executor_aggregated = parallel_policy_executor_aggregated<hpx::launch::async_policy>
template<typename Policy = hpx::launch::async_policy>
struct parallel_policy_executor_aggregated
#include <parallel_executor_aggregated.hpp>

A parallel_executor_aggregated creates groups of parallel execution agents that execute in threads implicitly created by the executor. This executor prefers continuing with the creating thread first before executing newly created threads.

This executor conforms to the concepts of a TwoWayExecutor, and a BulkTwoWayExecutor

Public Types

template<>
using execution_category = parallel_execution_tag

Associate the parallel_execution_tag executor tag type as a default with this executor.

template<>
using executor_parameters_type = static_chunk_size

Associate the static_chunk_size executor parameters type as a default with this executor.

Public Functions

constexpr parallel_policy_executor_aggregated(std::size_t spread = 4, std::size_t tasks = std::size_t(-1))

Create a new parallel executor.

template<typename F, typename S, typename ...Ts>
std::vector<hpx::future<void>> bulk_async_execute(F &&f, S const &shape, Ts&&... ts) const
template<>
struct parallel_policy_executor_aggregated<hpx::launch>

Public Types

template<>
using execution_category = parallel_execution_tag

Associate the parallel_execution_tag executor tag type as a default with this executor.

template<>
using executor_parameters_type = static_chunk_size

Associate the static_chunk_size executor parameters type as a default with this executor.

Public Functions

constexpr parallel_policy_executor_aggregated(hpx::launch l = hpx::launch::async_policy{}, std::size_t spread = 4, std::size_t tasks = std::size_t(-1))

Create a new parallel executor.

template<typename F, typename S, typename ...Ts>
std::vector<hpx::future<void>> bulk_async_execute(F &&f, S const &shape, Ts&&... ts) const

#include <hpx/execution/executors/thread_timed_execution.hpp>

namespace hpx
namespace threads

Functions

template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value>::type post_at(Executor &&exec, hpx::util::steady_time_point const &abs_time, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value>::type post_after(Executor &&exec, hpx::util::steady_duration const &rel_time, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>>::type async_execute_at(Executor &&exec, hpx::util::steady_time_point const &abs_time, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, hpx::future<typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>>::type async_execute_after(Executor &&exec, hpx::util::steady_duration const &rel_time, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>::type sync_execute_at(Executor &&exec, hpx::util::steady_time_point const &abs_time, F &&f, Ts&&... ts)
template<typename Executor, typename F, typename ...Ts>
std::enable_if<hpx::traits::is_threads_executor<Executor>::value, typename hpx::util::detail::invoke_deferred_result<F, Ts...>::type>::type sync_execute_after(Executor &&exec, hpx::util::steady_duration const &rel_time, F &&f, Ts&&... ts)

#include <hpx/execution/executors/dynamic_chunk_size.hpp>

namespace hpx
namespace parallel
namespace execution
struct dynamic_chunk_size
#include <dynamic_chunk_size.hpp>

Loop iterations are divided into pieces of size chunk_size and then dynamically scheduled among the threads; when a thread finishes one chunk, it is dynamically assigned another If chunk_size is not specified, the default chunk size is 1.

Note

This executor parameters type is equivalent to OpenMP’s DYNAMIC scheduling directive.

Public Functions

constexpr dynamic_chunk_size(std::size_t chunk_size = 1)

Construct a dynamic_chunk_size executor parameters object

Parameters
  • chunk_size: [in] The optional chunk size to use as the number of loop iterations to schedule together. The default chunk size is 1.

#include <hpx/execution/executors/timed_execution_fwd.hpp>

#include <hpx/execution/executors/distribution_policy_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Functions

template<typename DistPolicy>
distribution_policy_executor<typename hpx::util::decay<DistPolicy>::type> make_distribution_policy_executor(DistPolicy &&policy)

Create a new distribution_policy_executor from the given distribution_policy.

Parameters
  • policy: The distribution_policy to create an executor from

template<typename DistPolicy>
class distribution_policy_executor
#include <distribution_policy_executor.hpp>

A distribution_policy_executor creates groups of parallel execution agents which execute in threads implicitly created by the executor and placed on any of the associated localities.

Template Parameters
  • DistPolicy: The distribution policy type for which an executor should be created. The expression hpx::traits::is_distribution_policy<DistPolicy>::value must evaluate to true.

Public Functions

template<typename DistPolicy_, typename Enable = typename std::enable_if<!std::is_same<distribution_policy_executor, typename hpx::util::decay<DistPolicy_>::type>::value>::type>
distribution_policy_executor(DistPolicy_ &&policy)

Create a new distribution_policy executor from the given distribution policy

Parameters
  • policy: The distribution_policy to create an executor from

Private Members

DistPolicy policy_

#include <hpx/execution/executors/persistent_auto_chunk_size.hpp>

namespace hpx
namespace parallel
namespace execution
struct persistent_auto_chunk_size
#include <persistent_auto_chunk_size.hpp>

Loop iterations are divided into pieces and then assigned to threads. The number of loop iterations combined is determined based on measurements of how long the execution of 1% of the overall number of iterations takes. This executor parameters type makes sure that as many loop iterations are combined as necessary to run for the amount of time specified.

Public Functions

constexpr persistent_auto_chunk_size()

Construct an persistent_auto_chunk_size executor parameters object

Note

Default constructed persistent_auto_chunk_size executor parameter types will use 0 microseconds as the execution time for each chunk and 80 microseconds as the minimal time for which any of the scheduled chunks should run.

persistent_auto_chunk_size(hpx::util::steady_duration const &time_cs)

Construct an persistent_auto_chunk_size executor parameters object

Parameters
  • time_cs: The execution time for each chunk.

persistent_auto_chunk_size(hpx::util::steady_duration const &time_cs, hpx::util::steady_duration const &rel_time)

Construct an persistent_auto_chunk_size executor parameters object

Parameters
  • rel_time: [in] The time duration to use as the minimum to decide how many loop iterations should be combined.

  • time_cs: The execution time for each chunk.

#include <hpx/execution/executors/execution_information.hpp>

namespace hpx
namespace threads

Functions

threads::mask_cref_type get_pu_mask(threads::topology &topo, std::size_t thread_num)

#include <hpx/execution/traits/is_timed_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using is_timed_executor_t = typename is_timed_executor<T>::type

#include <hpx/execution/traits/is_executor.hpp>

namespace hpx
namespace parallel
namespace execution

Typedefs

using is_one_way_executor_t = typename is_one_way_executor<T>::type
using is_never_blocking_one_way_executor_t = typename is_never_blocking_one_way_executor<T>::type
using is_bulk_one_way_executor_t = typename is_bulk_one_way_executor<T>::type
using is_two_way_executor_t = typename is_two_way_executor<T>::type
using is_bulk_two_way_executor_t = typename is_bulk_two_way_executor<T>::type
namespace traits

Typedefs

using is_one_way_executor_t = typename is_one_way_executor<T>::type
using is_never_blocking_one_way_executor_t = typename is_never_blocking_one_way_executor<T>::type
using is_bulk_one_way_executor_t = typename is_bulk_one_way_executor<T>::type
using is_two_way_executor_t = typename is_two_way_executor<T>::type
using is_bulk_two_way_executor_t = typename is_bulk_two_way_executor<T>::type
using is_executor_any_t = typename is_executor_any<T>::type

#include <hpx/execution/traits/is_execution_policy.hpp>

namespace hpx
namespace parallel
namespace execution
template<typename T>
struct is_async_execution_policy : public execution::detail::is_async_execution_policy<hpx::util::decay<T>::type>
#include <is_execution_policy.hpp>

Extension: Detect whether given execution policy makes algorithms asynchronous

  1. The type is_async_execution_policy can be used to detect asynchronous execution policies for the purpose of excluding function signatures from otherwise ambiguous overload resolution participation.

  2. If T is the type of a standard or implementation-defined execution policy, is_async_execution_policy<T> shall be publicly derived from integral_constant<bool, true>, otherwise from integral_constant<bool, false>.

  3. The behavior of a program that adds specializations for is_async_execution_policy is undefined.

template<typename T>
struct is_execution_policy : public execution::detail::is_execution_policy<hpx::util::decay<T>::type>
#include <is_execution_policy.hpp>

  1. The type is_execution_policy can be used to detect execution policies for the purpose of excluding function signatures from otherwise ambiguous overload resolution participation.

  2. If T is the type of a standard or implementation-defined execution policy, is_execution_policy<T> shall be publicly derived from integral_constant<bool, true>, otherwise from integral_constant<bool, false>.

  3. The behavior of a program that adds specializations for is_execution_policy is undefined.

template<typename T>
struct is_parallel_execution_policy : public execution::detail::is_parallel_execution_policy<hpx::util::decay<T>::type>
#include <is_execution_policy.hpp>

Extension: Detect whether given execution policy enables parallelization

  1. The type is_parallel_execution_policy can be used to detect parallel execution policies for the purpose of excluding function signatures from otherwise ambiguous overload resolution participation.

  2. If T is the type of a standard or implementation-defined execution policy, is_parallel_execution_policy<T> shall be publicly derived from integral_constant<bool, true>, otherwise from integral_constant<bool, false>.

  3. The behavior of a program that adds specializations for is_parallel_execution_policy is undefined.

template<typename T>
struct is_sequenced_execution_policy : public execution::detail::is_sequenced_execution_policy<hpx::util::decay<T>::type>
#include <is_execution_policy.hpp>

Extension: Detect whether given execution policy does not enable parallelization

  1. The type is_sequenced_execution_policy can be used to detect non-parallel execution policies for the purpose of excluding function signatures from otherwise ambiguous overload resolution participation.

  2. If T is the type of a standard or implementation-defined execution policy, is_sequenced_execution_policy<T> shall be publicly derived from integral_constant<bool, true>, otherwise from integral_constant<bool, false>.

  3. The behavior of a program that adds specializations for is_sequenced_execution_policy is undefined.

#include <hpx/execution/traits/executor_traits.hpp>

namespace hpx
namespace parallel
namespace execution
template<typename Executor>
struct executor_context

Public Types

template<>
using type = typename std::decay::type
template<typename Executor>
struct executor_execution_category

Public Types

template<>
using type = hpx::util::detected_or_t<unsequenced_execution_tag, execution_category, Executor>

Private Types

template<>
using execution_category = typename T::execution_category
template<typename Executor>
struct executor_index

Public Types

template<>
using type = hpx::util::detected_or_t<typename executor_shape<Executor>::type, index_type, Executor>

Private Types

template<>
using index_type = typename T::index_type
template<typename Executor>
struct executor_parameters_type

Public Types

template<>
using type = hpx::util::detected_or_t<parallel::execution::static_chunk_size, parameters_type, Executor>

Private Types

template<>
using parameters_type = typename T::parameters_type
template<typename Executor>
struct executor_shape

Public Types

template<>
using type = hpx::util::detected_or_t<std::size_t, shape_type, Executor>

Private Types

template<>
using shape_type = typename T::shape_type
namespace traits

Typedefs

using executor_context_t = typename executor_context<Executor>::type
using executor_execution_category_t = typename executor_execution_category<Executor>::type
using executor_shape_t = typename executor_shape<Executor>::type
using executor_index_t = typename executor_index<Executor>::type
using executor_parameters_type_t = typename executor_parameters_type<Executor>::type

#include <hpx/execution/traits/is_executor_parameters.hpp>

template<typename Executor>
struct extract_executor_parameters<Executor, typename hpx::util::always_void<typename Executor::executor_parameters_type>::type>

Public Types

template<>
using type = typename Executor::executor_parameters_type
template<typename Parameters>
struct extract_has_variable_chunk_size<Parameters, typename hpx::util::always_void<typename Parameters::has_variable_chunk_size>::type>

Public Types

template<>
using type = typename Parameters::has_variable_chunk_size
namespace hpx
namespace parallel
namespace execution

Typedefs

using is_executor_parameters_t = typename is_executor_parameters<T>::type
template<typename Executor, typename Enable = void>
struct extract_executor_parameters

Public Types

template<>
using type = sequential_executor_parameters
template<typename Executor>
struct extract_executor_parameters<Executor, typename hpx::util::always_void<typename Executor::executor_parameters_type>::type>

Public Types

template<>
using type = typename Executor::executor_parameters_type
template<typename Parameters, typename Enable = void>
struct extract_has_variable_chunk_size

Public Types

template<>
using type = std::false_type
template<typename Parameters>
struct extract_has_variable_chunk_size<Parameters, typename hpx::util::always_void<typename Parameters::has_variable_chunk_size>::type>

Public Types

template<>
using type = typename Parameters::has_variable_chunk_size
namespace traits

Typedefs

using is_executor_parameters_t = typename is_executor_parameters<T>::type

#include <hpx/execution/parallel/traits/vector_pack_count_bits.hpp>

namespace hpx
namespace parallel
namespace traits

Functions

HPX_HOST_DEVICE std::size_t hpx::parallel::traits::count_bits(bool value)

#include <hpx/execution/parallel/traits/vector_pack_load_store.hpp>

#include <hpx/execution/parallel/traits/vector_pack_type.hpp>

#include <hpx/execution/parallel/traits/vector_pack_alignment_size.hpp>

#include <hpx/execution/datapar/execution_policy.hpp>

#include <hpx/execution/datapar/execution_policy_fwd.hpp>

#include <compatibility/hpx/traits/is_timed_executor.hpp>

#include <compatibility/hpx/traits/is_executor.hpp>

#include <compatibility/hpx/traits/is_execution_policy.hpp>

#include <compatibility/hpx/traits/executor_traits.hpp>

#include <compatibility/hpx/traits/is_executor_parameters.hpp>

#include <compatibility/hpx/parallel/executors.hpp>

#include <compatibility/hpx/parallel/execution_policy.hpp>

#include <compatibility/hpx/parallel/execution_policy_fwd.hpp>

#include <compatibility/hpx/parallel/exception_list.hpp>

#include <compatibility/hpx/parallel/execution.hpp>

#include <compatibility/hpx/parallel/executor_parameters.hpp>

#include <compatibility/hpx/parallel/executors/sequenced_executor.hpp>

#include <compatibility/hpx/parallel/executors/thread_pool_executors.hpp>

#include <compatibility/hpx/parallel/executors/post_policy_dispatch.hpp>

#include <compatibility/hpx/parallel/executors/static_chunk_size.hpp>

#include <compatibility/hpx/parallel/executors/fused_bulk_execute.hpp>

#include <compatibility/hpx/parallel/executors/guided_chunk_size.hpp>

#include <compatibility/hpx/parallel/executors/auto_chunk_size.hpp>

#include <compatibility/hpx/parallel/executors/execution_parameters.hpp>

#include <compatibility/hpx/parallel/executors/execution_parameters_fwd.hpp>

#include <compatibility/hpx/parallel/executors/execution_fwd.hpp>

#include <compatibility/hpx/parallel/executors/service_executors.hpp>

#include <compatibility/hpx/parallel/executors/thread_execution_information.hpp>

#include <compatibility/hpx/parallel/executors/thread_pool_executor.hpp>

#include <compatibility/hpx/parallel/executors/thread_pool_os_executors.hpp>

#include <compatibility/hpx/parallel/executors/thread_pool_attached_executors.hpp>

#include <compatibility/hpx/parallel/executors/pool_executor.hpp>

#include <compatibility/hpx/parallel/executors/thread_execution.hpp>

#include <compatibility/hpx/parallel/executors/parallel_executor.hpp>

#include <compatibility/hpx/parallel/executors/execution.hpp>

#include <compatibility/hpx/parallel/executors/rebind_executor.hpp>

#include <compatibility/hpx/parallel/executors/timed_execution.hpp>

#include <compatibility/hpx/parallel/executors/execution_information_fwd.hpp>

#include <compatibility/hpx/parallel/executors/timed_executors.hpp>

#include <compatibility/hpx/parallel/executors/default_executor.hpp>

#include <compatibility/hpx/parallel/executors/this_thread_executors.hpp>

#include <compatibility/hpx/parallel/executors/parallel_executor_aggregated.hpp>

#include <compatibility/hpx/parallel/executors/thread_timed_execution.hpp>

#include <compatibility/hpx/parallel/executors/dynamic_chunk_size.hpp>

#include <compatibility/hpx/parallel/executors/timed_execution_fwd.hpp>

#include <compatibility/hpx/parallel/executors/distribution_policy_executor.hpp>

#include <compatibility/hpx/parallel/executors/persistent_auto_chunk_size.hpp>

#include <compatibility/hpx/parallel/executors/execution_information.hpp>

#include <compatibility/hpx/parallel/traits/vector_pack_count_bits.hpp>

#include <compatibility/hpx/parallel/traits/vector_pack_load_store.hpp>

#include <compatibility/hpx/parallel/traits/vector_pack_type.hpp>

#include <compatibility/hpx/parallel/traits/vector_pack_alignment_size.hpp>

#include <compatibility/hpx/parallel/datapar/execution_policy.hpp>

#include <compatibility/hpx/parallel/datapar/execution_policy_fwd.hpp>