Param params: [in] The executor parameters object to use as a fallback if the executor does not expose
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.
Param num_elements: [in] The overall number of elements for the algorithm.
Param num_cores: [in] The overall number of cores to utilize for the algorithm.
Param num_chunks: [in] The overall number of chunks for the algorithm.
Param chunk_size: [in] The size of the chunks created for the algorithm.

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t num_elements, std::size_t num_cores, std::size_t num_chunks, std::size_t chunk_size) const#

struct 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

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 iteration_duration: [in] The time one of the tasks require to be executed.
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
Return: The size of the chunks (number of iterations per chunk) that should be used for parallel execution.

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, hpx::chrono::steady_duration const &iteration_duration, std::size_t cores, std::size_t num_tasks) const#

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t cores, std::size_t num_tasks) const#

template<> struct is_scheduling_property<with_processing_units_count_t> : public true_type#

struct 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
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec) const#

struct 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
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec) const#

struct 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
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec) const#

struct mark_partition_t#

#include <execution_parameters_fwd.hpp>

Mark custom point in parallel algorithm execution

Note

This calls params.mark_partition(exec, partition, args…) 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
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.

Public Functions

template<typename Parameters, typename Executor, typename ...Args> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t partition, Args&&... args) const#

struct 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

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t cores, std::size_t num_tasks) const#

struct measure_iteration_t#

#include <execution_parameters_fwd.hpp>

Return the measured execution time for one iteration based on running the given function.

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 num_tasks: [in] The number of tasks the chunk size should be determined for
Return: The execution time for one of the tasks.

Public Functions

template<typename Parameters, typename Executor, typename F> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, F &&f, std::size_t num_tasks) const#

struct null_parameters_t#

struct 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
Param exec: [in] The executor object which will be used for scheduling of the loop iterations.
Param iteration_duration: [in] The time one of the tasks require to be executed.
Param num_tasks: [in] The number of tasks the number of cores should be determined for
Return: The number of cores to use

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, hpx::chrono::steady_duration const &iteration_duration, std::size_t num_tasks) const#

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t num_tasks) const#

template<typename Executor> inline decltype(auto) operator()(Executor &&exec, hpx::chrono::steady_duration const &iteration_duration, std::size_t num_tasks) const#

template<typename Executor> inline decltype(auto) operator()(Executor &&exec, std::size_t num_tasks) const#

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec) const#

template<typename Executor> inline decltype(auto) operator()(Executor &&exec) const#

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, hpx::chrono::steady_duration const &iteration_duration, std::size_t num_tasks) const

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec, std::size_t num_tasks = 0) const

template<typename Executor> inline decltype(auto) operator()(Executor &&exec, hpx::chrono::steady_duration const &iteration_duration, std::size_t num_tasks) const

template<typename Executor> inline decltype(auto) operator()(Executor &&exec, std::size_t num_tasks = 0) const

template<typename ExPolicy> inline decltype(auto) operator()(ExPolicy &&policy) const#

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

Public Functions

template<typename Parameters, typename Executor> inline decltype(auto) operator()(Parameters &&params, Executor &&exec) const#

struct with_processing_units_count_t#

#include <execution_parameters_fwd.hpp>

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

Public Functions

template<typename Executor> inline decltype(auto) operator()(Executor &&exec, std::size_t num_cores) const#

template<typename Policy, typename Property> inline decltype(auto) operator()(Policy &&policy, Property &&property) const#