hpx/execution/executors/execution_parameters_fwd.hpp#

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

template<>
struct is_scheduling_property<hpx::parallel::execution::with_processing_units_count_t> : public true_type#
namespace hpx
namespace execution
namespace experimental
template<> with_processing_units_count_t > : public true_type
namespace parallel
namespace execution

Variables

hpx::parallel::execution::get_chunk_size_t get_chunk_size#
hpx::parallel::execution::maximal_number_of_chunks_t maximal_number_of_chunks#
hpx::parallel::execution::reset_thread_distribution_t reset_thread_distribution#
hpx::parallel::execution::processing_units_count_t processing_units_count#
hpx::parallel::execution::with_processing_units_count_t with_processing_units_count#
hpx::parallel::execution::mark_begin_execution_t mark_begin_execution#
hpx::parallel::execution::mark_end_of_scheduling_t mark_end_of_scheduling#
hpx::parallel::execution::mark_end_execution_t mark_end_execution#
struct get_chunk_size_t : public hpx::functional::detail::tag_fallback<get_chunk_size_t>#
#include <execution_parameters_fwd.hpp>

Return the number of invocations of the given function f which should be combined into a single task

Note

The parameter f is expected to be a nullary function returning a std::size_t representing the number of iteration the function has already executed (i.e. which don’t have to be scheduled anymore).

Param params

[in] The executor parameters object to use for determining the chunk size for the given number of tasks num_tasks.

Param exec

[in] The executor object which will be used for scheduling of the loop iterations.

Param f

[in] The function which will be optionally scheduled using the given executor.

Param cores

[in] The number of cores the number of chunks should be determined for.

Param num_tasks

[in] The number of tasks the chunk size should be determined for

Private Functions

template<typename Parameters, typename Executor, typename F>
inline decltype(auto) friend tag_fallback_invoke(get_chunk_size_t, Parameters &&params, Executor &&exec, F &&f, std::size_t cores, std::size_t num_tasks)#
struct mark_begin_execution_t : public hpx::functional::detail::tag_fallback<mark_begin_execution_t>#
#include <execution_parameters_fwd.hpp>

Mark the begin of a parallel algorithm execution

Note

This calls params.mark_begin_execution(exec) if it exists; otherwise it does nothing.

Param params

[in] The executor parameters object to use as a fallback if the executor does not expose

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(mark_begin_execution_t, Parameters &&params, Executor &&exec)#
struct mark_end_execution_t : public hpx::functional::detail::tag_fallback<mark_end_execution_t>#
#include <execution_parameters_fwd.hpp>

Mark the end of a parallel algorithm execution

Note

This calls params.mark_end_execution(exec) if it exists; otherwise it does nothing.

Param params

[in] The executor parameters object to use as a fallback if the executor does not expose

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(mark_end_execution_t, Parameters &&params, Executor &&exec)#
struct mark_end_of_scheduling_t : public hpx::functional::detail::tag_fallback<mark_end_of_scheduling_t>#
#include <execution_parameters_fwd.hpp>

Mark the end of scheduling tasks during parallel algorithm execution

Note

This calls params.mark_begin_execution(exec) if it exists; otherwise it does nothing.

Param params

[in] The executor parameters object to use as a fallback if the executor does not expose

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(mark_end_of_scheduling_t, Parameters &&params, Executor &&exec)#
struct maximal_number_of_chunks_t : public hpx::functional::detail::tag_fallback<maximal_number_of_chunks_t>#
#include <execution_parameters_fwd.hpp>

Return the largest reasonable number of chunks to create for a single algorithm invocation.

Param params

[in] The executor parameters object to use for determining the number of chunks for the given number of cores.

Param exec

[in] The executor object which will be used for scheduling of the loop iterations.

Param cores

[in] The number of cores the number of chunks should be determined for.

Param num_tasks

[in] The number of tasks the chunk size should be determined for

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(maximal_number_of_chunks_t, Parameters &&params, Executor &&exec, std::size_t cores, std::size_t num_tasks)#
struct processing_units_count_t : public hpx::functional::detail::tag_fallback<processing_units_count_t>#
#include <execution_parameters_fwd.hpp>

Retrieve the number of (kernel-)threads used by the associated executor.

Note

This calls params.processing_units_count(Executor&&) if it exists; otherwise it forwards the request to the executor parameters object.

Param params

[in] The executor parameters object to use as a fallback if the executor does not expose

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(processing_units_count_t, Parameters &&params, Executor &&exec)#
struct reset_thread_distribution_t : public hpx::functional::detail::tag_fallback<reset_thread_distribution_t>#
#include <execution_parameters_fwd.hpp>

Reset the internal round robin thread distribution scheme for the given executor.

Note

This calls params.reset_thread_distribution(exec) if it exists; otherwise it does nothing.

Param params

[in] The executor parameters object to use for resetting the thread distribution scheme.

Param exec

[in] The executor object to use.

Private Functions

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(reset_thread_distribution_t, Parameters &&params, Executor &&exec)#
struct with_processing_units_count_t : public hpx::functional::detail::tag_fallback<with_processing_units_count_t>#
#include <execution_parameters_fwd.hpp>

Generate a policy that supports setting the number of cores for execution.