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

hpx::execution::experimental::get_chunk_size_t get_chunk_size

hpx::execution::experimental::measure_iteration_t measure_iteration

hpx::execution::experimental::maximal_number_of_chunks_t maximal_number_of_chunks

hpx::execution::experimental::reset_thread_distribution_t reset_thread_distribution

hpx::execution::experimental::processing_units_count_t processing_units_count

hpx::execution::experimental::with_processing_units_count_t with_processing_units_count

hpx::execution::experimental::mark_begin_execution_t mark_begin_execution

hpx::execution::experimental::mark_end_of_scheduling_t mark_end_of_scheduling

hpx::execution::experimental::mark_end_execution_t mark_end_execution

struct get_chunk_size_t : public hpx::functional::detail::tag_priority<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.

Private Functions

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

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(get_chunk_size_t tag, Parameters &&params, Executor &&exec, std::size_t cores, std::size_t num_tasks)

template<>
struct is_scheduling_property<with_processing_units_count_t> : public true_type

struct mark_begin_execution_t : public hpx::functional::detail::tag_priority<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_priority<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_priority<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_priority<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 measure_iteration_t : public hpx::functional::detail::tag_priority<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.

Private Functions

template<typename Parameters, typename Executor, typename F>
inline decltype(auto) friend tag_fallback_invoke(measure_iteration_t, Parameters &&params, Executor &&exec, F &&f, std::size_t num_tasks)

struct null_parameters_t

struct processing_units_count_t : public hpx::functional::detail::tag_priority<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 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

Private Functions

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

template<typename Parameters, typename Executor>
inline decltype(auto) friend tag_fallback_invoke(processing_units_count_t tag, Parameters &&params, Executor &&exec, std::size_t num_tasks = 0)

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

template<typename Executor>
inline decltype(auto) friend tag_fallback_invoke(processing_units_count_t tag, Executor &&exec, std::size_t num_tasks = 0)

struct reset_thread_distribution_t : public hpx::functional::detail::tag_priority<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_priority<with_processing_units_count_t>

#include <execution_parameters_fwd.hpp>

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