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