hpx/execution/executors/execution_parameters_fwd.hpp

Defined in header 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.

namespace hpx

namespace execution

namespace experimental

Variables

constexpr struct hpx::execution::experimental::null_parameters_t null_parameters

constexpr struct hpx::execution::experimental::get_chunk_size_t get_chunk_size

constexpr struct hpx::execution::experimental::measure_iteration_t measure_iteration

constexpr struct hpx::execution::experimental::maximal_number_of_chunks_t maximal_number_of_chunks

constexpr struct hpx::execution::experimental::reset_thread_distribution_t reset_thread_distribution

constexpr struct hpx::execution::experimental::processing_units_count_t processing_units_count

constexpr struct hpx::execution::experimental::with_processing_units_count_t with_processing_units_count

constexpr struct hpx::execution::experimental::mark_begin_execution_t mark_begin_execution

constexpr struct hpx::execution::experimental::mark_end_of_scheduling_t mark_end_of_scheduling

constexpr struct hpx::execution::experimental::mark_end_execution_t mark_end_execution

constexpr struct hpx::execution::experimental::mark_partition_t mark_partition

constexpr struct hpx::execution::experimental::collect_execution_parameters_t collect_execution_parameters

struct null_parameters_t

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

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

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_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_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_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 collect_execution_parameters_t

#include <execution_parameters_fwd.hpp>

Collect various parameters of the chunking for this 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.

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

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