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
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).- Parameters
params
: [in] The executor parameters object to use for determining the chunk size for the given number of tasks num_tasks.exec
: [in] The executor object which will be used for scheduling of the loop iterations.f
: [in] The function which will be optionally scheduled using the given executor.cores
: [in] The number of cores the number of chunks should be determined for.num_tasks
: [in] The number of tasks the chunk size should be determined for
Private Functions
-
template<typename
Parameters
, typenameExecutor
, typenameF
>
decltype(auto) friendtag_fallback_invoke
(get_chunk_size_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use as a fallback if the executor does not expose
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(mark_begin_execution_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use as a fallback if the executor does not expose
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(mark_end_execution_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use as a fallback if the executor does not expose
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(mark_end_of_scheduling_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use for determining the number of chunks for the given number of cores.exec
: [in] The executor object which will be used for scheduling of the loop iterations.cores
: [in] The number of cores the number of chunks should be determined for.num_tasks
: [in] The number of tasks the chunk size should be determined for
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(maximal_number_of_chunks_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use as a fallback if the executor does not expose
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(processing_units_count_t, Parameters &¶ms, 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.
- Parameters
params
: [in] The executor parameters object to use for resetting the thread distribution scheme.exec
: [in] The executor object to use.
Private Functions
-
template<typename
Parameters
, typenameExecutor
>
decltype(auto) friendtag_fallback_invoke
(reset_thread_distribution_t, Parameters &¶ms, 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.
-
hpx::parallel::execution::get_chunk_size_t
-
namespace
-
namespace